Ejemplo n.º 1
0
/* set a timer to a specific value */
TIMEVAL timer_dup(TIMEVAL b)
{
	TIMEVAL a;

	TIMER_RESET(a);
	a.tv_sec = b.tv_sec;
	a.tv_usec = b.tv_usec;
	return a;
}
Ejemplo n.º 2
0
void
benchmark( FT_Face   face,
           btest_t*  test,
           int       max_iter,
           double    max_time )
{
  int       n, done;
  btimer_t  timer, elapsed;


  if ( test->cache_first )
  {
    if ( !cache_man )
    {
      printf( "%-25s : no cache manager\n", test->title );

      return;
    }

    TIMER_RESET( &timer );
    test->bench( &timer, face, test->user_data );
  }

  printf( "%-25s : ", test->title );
  fflush( stdout );

  n = done = 0;
  TIMER_RESET( &timer );
  TIMER_RESET( &elapsed );

  for ( n = 0; !max_iter || n < max_iter; n++ )
  {
    TIMER_START( &elapsed );

    done += test->bench( &timer, face, test->user_data );

    TIMER_STOP( &elapsed );

    if ( TIMER_GET( &elapsed ) > max_time )
      break;
  }

  printf("%5.3f us/op\n", TIMER_GET( &timer ) * 1E6 / (double)done);
}
// run with -p 20 -l 5000
int main(int argc, char *argv[])
{
  struct item items[MAX_ITEMS];	/* array of items */
  int n, capacity, sol, benchmark, help;
  char filename[100];

  my_timer_t t;
  /* standard benchmark options */
  strcpy(filename, "knapsack-example3.input");

#ifdef CILK_BLOCK
  cilk_io_init();
#endif

  get_options(argc, argv, specifiers, opt_types, &prob, &length, filename, &benchmark, &help);

  if (help)
    return usage();

  if (benchmark) {
    switch (benchmark) {
      case 1:		/* short benchmark options -- a little work */
        strcpy(filename, "knapsack-example1.input");
        break;
      case 2:		/* standard benchmark options */
        strcpy(filename, "knapsack-example2.input");
        break;
      case 3:		/* long benchmark options -- a lot of work */
        strcpy(filename, "knapsack-example3.input");
        break;
    }
  }
  if (read_input(filename, items, &capacity, &n))
    return 1;

  /* Timing. "Start" timers */
  cilk_sync;
  printf("prob = %lu\tlength=%lu\tn = %lu\n", prob, length, n);

  TIMER_RESET(t);
  TIMER_START(t);
  sol = cilk_spawn knapsack(items, capacity, n, 0);
  cilk_sync;
  TIMER_STOP(t);

#ifdef CILK_BLOCK
  cilk_io_teardown();
#endif

  printf("\nCilk Example: knapsack\n");
  printf("options: problem-file = %s\n\n", filename);
  printf("Best value is %d\n\n", sol);
  printf("Running time  = %4f s\n", TIMER_EVAL(t));

  return 0;
}
Ejemplo n.º 4
0
/* sets and returns current time from system time */
TIMEVAL set_time_now(void)
{
	int old_errno = errno;

	/* init timer */
	TIMER_RESET(time_now);
	monotonic_gettimeofday(&time_now);
	errno = old_errno;

	return time_now;
}
Ejemplo n.º 5
0
/* current time */
TIMEVAL timer_now(void)
{
	TIMEVAL curr_time;
	int old_errno = errno;

	/* init timer */
	TIMER_RESET(curr_time);
	monotonic_gettimeofday(&curr_time);
	errno = old_errno;

	return curr_time;
}
Ejemplo n.º 6
0
/* timer add */
TIMEVAL
timer_add_long(TIMEVAL a, long b)
{
	TIMEVAL ret;

	TIMER_RESET(ret);
	ret.tv_usec = a.tv_usec + b % TIMER_HZ;
	ret.tv_sec = a.tv_sec + b / TIMER_HZ;

	if (ret.tv_usec >= TIMER_HZ) {
		ret.tv_sec++;
		ret.tv_usec -= TIMER_HZ;
	}

	return ret;
}
Ejemplo n.º 7
0
/* timer sub */
TIMEVAL
timer_sub(TIMEVAL a, TIMEVAL b)
{
	TIMEVAL ret;

	TIMER_RESET(ret);
	ret.tv_usec = a.tv_usec - b.tv_usec;
	ret.tv_sec = a.tv_sec - b.tv_sec;

	if (ret.tv_usec < 0) {
		ret.tv_usec += TIMER_HZ;
		ret.tv_sec--;
	}

	return ret;
}
Ejemplo n.º 8
0
/* Timer functions */
static TIMEVAL
vrrp_compute_timer(const int fd)
{
	vrrp_rt *vrrp;
	element e;
	list l = &vrrp_data->vrrp_index_fd[fd%1024 + 1];
	TIMEVAL timer;

	/* Multiple instances on the same interface */
	TIMER_RESET(timer);
	for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
		vrrp = ELEMENT_DATA(e);
		if (timer_cmp(vrrp->sands, timer) < 0 ||
		    TIMER_ISNULL(timer))
			timer = timer_dup(vrrp->sands);
	}

	return timer;
}
Ejemplo n.º 9
0
/* sock_dgram /UCP handler */
void ev_udp_handler(int fd, int ev_flags, void *arg)
{
    int i = 0, n = 0, nevdnsbuf = 0, reqfd = -1, respfd = -1;
    unsigned char evdnsbuf[EVDNS_BUF_SIZE], *p = NULL;
    char ip[DNS_IP_MAX];
    HOSTENT hostent = {0};

    if(ev_flags & E_READ)
    {
        //if( ( n = recvfrom(fd, buffer[fd], EV_BUF_SIZE, 0, (struct sockaddr *)&rsa, &rsa_len)) > 0 )
        if( ( n = read(fd, buffer[fd], EV_BUF_SIZE)) > 0 )
        {
            TIMER_SAMPLE(timer);
            evdns_parse_reply((unsigned char *)buffer[fd], n, &hostent);
            if(hostent.naddrs  > 0)
            {
                fprintf(stdout, "time:%lld QID:%d name:%s nalias:%d naddrs:%d\n", 
                        PT_LU_USEC(timer), hostent.qid, hostent.name, 
                        hostent.nalias, hostent.naddrs);
                for(i = 0; i < hostent.nalias; i++)
                {
                    fprintf(stdout, "alias%d:%s\n", i, hostent.alias[i]);
                }
                for(i = 0; i < hostent.naddrs; i++)
                {
                    p = (unsigned char *)&(hostent.addrs[i]);
                    sprintf(ip, "%d.%d.%d.%d", *p, *(p+1), *(p+2), *(p+3));
                    fprintf(stdout, "ip[%d] [%d][%s:][%d]\n", 
                            i, hostent.addrs[i], ip, inet_addr(ip));
                }
                fprintf(stdout, "\r\n");
            }
            if((respfd = open("/tmp/dns.response", O_CREAT|O_RDWR, 0644)) > 0)
            {
                if(write(respfd, buffer[fd], n) <= 0)_exit(-1);
                close(respfd);
                respfd = -1;
                _exit(-1);
            }
            SHOW_LOG("Read %d bytes from %d", n, fd);
            buffer[fd][n] = 0;
            SHOW_LOG("Updating event[%p] on %d ", &events[fd], fd);
            event_add(&events[fd], E_WRITE);	
        }		
        else
        {
            if(n < 0 )
                FATAL_LOG("Reading from %d failed, %s", fd, strerror(errno));
            goto err;
        }
    }
    if(ev_flags & E_WRITE)
    {
        nevdnsbuf = evdns_make_query(domain, 1, 1, 1, 1, evdnsbuf);
        if((reqfd = open("/tmp/dns.query", O_CREAT|O_RDWR, 0644)) > 0)
        {
            if(write(reqfd, evdnsbuf, nevdnsbuf) <= 0)_exit(-1);
            close(reqfd);
            reqfd = -1;
        }
        //if(  (n = write(fd, buffer[fd], strlen(buffer[fd])) ) > 0 )
        if((n = write(fd, evdnsbuf, nevdnsbuf)) > 0)
        {
            SHOW_LOG("Wrote %d bytes via %d", n, fd);
            TIMER_RESET(timer);
        }
        else
        {
            if(n < 0)
                FATAL_LOG("Wrote data via %d failed, %s", fd, strerror(errno));	
            goto err;
        }
        event_del(&events[fd], E_WRITE);
    }
    return ;
err:
    {
        event_destroy(&events[fd]);
        shutdown(fd, SHUT_RDWR);
        close(fd);
        SHOW_LOG("Connection %d closed", fd);
    }
}
Ejemplo n.º 10
0
//rm -rf /tmp/1.idx* && gcc -O2 -o lkv lkv.c -DLKV_TEST -DTEST_KV -DHAVE_PTHREAD -lpthread && ./lkv
int main()
{
    LKV *lkv = NULL;
    int i = 0, j = 0, n = 0, total = 0, no = 0, stat[MASK], stat2[MASK],
        v = 0, num = 1000000, base = 60000000;
    int64_t val = 0, from = 0, to = 0, *res = NULL, all_mask = 200000;
    int64_t inputs[256], nos[256], last[256], tall[200000];
    int64_t all = 0;
    time_t stime = 0, etime = 0;
    void *timer = NULL;

    if((lkv = lkv_init("/tmp/1.idx")))
    {
        res = (int64_t *)calloc(base, sizeof(int64_t));
        TIMER_INIT(timer);
#ifdef TEST_KV
        TIMER_RESET(timer);
        for(i = 0; i < num; i++)
        {
            no = random()%base;
            LKV_SET(lkv, no, i);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "set(%d) time used:%lld\n", num, PT_LU_USEC(timer));
        TIMER_RESET(timer);
        for(i = 0; i < num; i++)
        {
            no = random()%base;
            v = LKV_GET(lkv, no);
        }
        fprintf(stdout, "get(%d) time used:%lld\n", num, PT_LU_USEC(timer));
#endif

#ifdef TEST_RFROM
            lkv_set(lkv, 1, 22);
            lkv_set(lkv, 2, 25);
            lkv_set(lkv, 3, 20);
            lkv_set(lkv, 4, 13);
            lkv_set(lkv, 6, 22);
            n = lkv_rangefrom(lkv, 21, NULL);
            fprintf(stdout, "rangefrom(21) => %d\n", n);
#endif
#ifdef TEST_DEB
        /*
            n = lkv_in(lkv, 16615, NULL);
            fprintf(stdout, "16615:%d\n", n);
        */
        n = 0;
        for(i = 0; i < lkv->state->count; i++)
        {
            /*
            if(lkv->slots[i].min <= 26650 && lkv->slots[i].max >= 26650)
            {
                fprintf(stdout, "%d:[min:%d max:%d]\n", i, lkv->slots[i].min, lkv->slots[i].max);
            }
            */
            n+= lkv->slots[i].count;
        }
        fprintf(stdout, "total:%d\n", n);
#endif
#ifdef TEST_IN
        for(i = 0; i < all_mask; i++)
        {
            tall[i] = 0;
        }
        for(i = 80000000; i > 0; i--)
        {
            no = (rand()%all_mask);
            lkv_set(lkv, i, no);
            tall[no]++;
        }
        for(i = 0; i < all_mask; i++)
        {
            n = lkv_in(lkv, i, NULL);
            if(n != tall[i])
                fprintf(stdout, "%d:[%d/%d]\n", i, n, tall[i]);
        }
#endif
#ifdef TEST_ALL
        for(i = 0; i < all_mask; i++)
        {
            tall[i] = 0;
        }
        for(i = 80000000; i > 0; i--)
        {
            no = (rand()%all_mask);
            lkv_set(lkv, i, no);
            tall[no]++;
        }
        no = (rand()%all_mask);
        total = 0;for(i = no; i < all_mask; i++) total += tall[i];
        fprintf(stdout, "rangefrom(%d):%d/%d\n", no, lkv_rangefrom(lkv, no, NULL), total);
        total = 0;for(i = 0; i <= no; i++) total += tall[i];
        fprintf(stdout, "rangeto(%d):%d/%d\n", no, lkv_rangeto(lkv, no, NULL), total);
        from = (rand()%all_mask);
        to = (rand()%all_mask);
        if(from > to){from += to; to = from - to; from = from - to;}
        total = 0;for(i = from; i <= to; i++) total += tall[i];
        fprintf(stdout, "range(%d,%d):%d/%d\n", from, no, lkv_range(lkv, from, to, NULL), total);
        for(i = 0; i < all_mask; i++)
        {
            n = lkv_in(lkv, i, NULL);
            if(n != tall[i])
                fprintf(stdout, "%d:[%d/%d]\n", i, n, tall[i]);
        }
#endif
#ifdef TEST_INS
        //fprintf(stdout, "sizeof(stat):%d\n", sizeof(stat));
        memset(stat, 0, sizeof(stat));
        memset(stat2, 0, sizeof(stat2));
        srand(time(NULL));
        n = 256;
        for(i = 0; i < n; i++)
        {
            no = (rand()%MASK);
            nos[i] = no;
            if((i % 3) == 0)
                inputs[i] = no * -1;
            else
                inputs[i] = no;
        }
        TIMER_RESET(timer);
        for(i = 1; i < 20000000; i++)
        {
           j = (rand()%n);
           val = inputs[j];
           no = nos[j];
           stat[no]++;
           lkv_set(lkv, i, val);
           last[j] = i;
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "set() 40000000 data, time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        for(i = 0; i < n; i++)
        {
            lkv_del(lkv, last[i]);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "del() time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        for(i = 0; i < n; i++)
        {
            val = inputs[i];
            no = nos[i];
            stat2[no] = lkv_in(lkv, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "in() time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        total = lkv_ins(lkv, inputs, n, NULL);
        TIMER_SAMPLE(timer);
        fprintf(stdout, "ins(keys, NULL) total:%d time used:%lld\n", total, PT_LU_USEC(timer));
        TIMER_RESET(timer);
        total = lkv_ins(lkv, inputs, n, res);
        TIMER_SAMPLE(timer);
        fprintf(stdout, "ins(keys, res:%p) total:%d time used:%lld\n", res, total, PT_LU_USEC(timer));
        for(i = 0; i < n; i++)
        {
            j = nos[i];
            if(stat[j] != stat2[j])
                fprintf(stdout, "%d:%d/%d::%d\n", j, stat[j], stat2[j], inputs[i]);
        }
#ifdef OUT_ALL
        for(i = 0; i < total; i++)
        {
            fprintf(stdout, "%d:%d\n", i, res[i]);
        }
#endif
#endif
        /*
        for(i = 0; i < lkv->state->count; i++)
        {
            fprintf(stdout, "%d:{min:%d max:%d}(%d)\n", i, lkv->slots[i].min, lkv->slots[i].max, lkv->slots[i].count);
        }
        */
#ifdef TEST_RANGEFILTER
            lkv_set(lkv, 1, 1234567);
            lkv_set(lkv, 2, 1567890);
            fprintf(stdout, "rangefrom():%d\n", lkv_rangefrom(lkv, 1569000, NULL));
            fprintf(stdout, "rangeto():%d\n", lkv_rangeto(lkv, 1111111, NULL));
            fprintf(stdout, "range():%d\n", lkv_range(lkv, 1111111, 1400000, NULL));
#endif
#ifdef TEST_RANGE
        srand(time(NULL));
        TIMER_RESET(timer);
        for(i = 1; i < 40000000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            lkv_set(lkv, i, val);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "set() 40000000 timestamps,  time used:%lld\n", PT_LU_USEC(timer));
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            all += lkv_rangefrom(lkv, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "rangefrom() 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            all += lkv_rangeto(lkv, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "rangeto() 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            from = 1356969600 + (rand()%31536000);
            to = from + rand()%31536000;
            all += lkv_range(lkv, from, to, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "range(%p) 1000 times total:%lld, time used:%lld\n", res, (long long int)all, PT_LU_USEC(timer));
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            from = 1356969600 + (rand()%31536000);
            to = from + rand()%31536000;
            all += lkv_range(lkv, from, to, NULL);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "range(null) 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));

#endif
        lkv_close(lkv);
        TIMER_CLEAN(timer);
        free(res);
    }
}
Ejemplo n.º 11
0
//gcc -o dmap dmap.c -DDMAP_TEST -DTEST_INS -DHAVE_PTHREAD -lpthread && ./dmap
int main()
{
    DMAP *dmap = NULL;
    int i = 0, j = 0, n = 0, total = 0, no = 0, stat[MASK], stat2[MASK];
    double val = 0, from = 0, to = 0, *res = NULL;
    double inputs[256], nos[256], last[256];
    double all = 0;
    time_t stime = 0, etime = 0;
    void *timer = NULL;

    if((dmap = dmap_init("/tmp/1.idx")))
    {
        res = (double *)calloc(60000000, sizeof(double));
        TIMER_INIT(timer);
#ifdef TEST_INS
        //fprintf(stdout, "sizeof(stat):%d\n", sizeof(stat));
        memset(stat, 0, sizeof(stat));
        memset(stat2, 0, sizeof(stat2));
        srand(time(NULL));
        n = 256;
        for(i = 0; i < n; i++)
        {
            no = (rand()%MASK);
            nos[i] = no;
            if((i % 3) == 0)
                inputs[i] = no * -1;
            else
                inputs[i] = no;
        }
        TIMER_RESET(timer);
        for(i = 1; i < 20000000; i++)
        {
           j = (rand()%n);
           val = inputs[j];
           no = nos[j];
           stat[no]++;
           dmap_set(dmap, i, val);
           last[j] = i;
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "set() 40000000 data, time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        for(i = 0; i < n; i++)
        {
            dmap_del(dmap, last[i]);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "del() time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        for(i = 0; i < n; i++)
        {
            val = inputs[i];
            no = nos[i];
            stat2[no] = dmap_in(dmap, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "in() time used:%lld\n", PT_LU_USEC(timer));
        TIMER_RESET(timer);
        total = dmap_ins(dmap, inputs, n, NULL);
        TIMER_SAMPLE(timer);
        fprintf(stdout, "ins(keys, NULL) total:%d time used:%lld\n", total, PT_LU_USEC(timer));
        TIMER_RESET(timer);
        total = dmap_ins(dmap, inputs, n, res);
        TIMER_SAMPLE(timer);
        fprintf(stdout, "ins(keys, res:%p) total:%d time used:%lld\n", res, total, PT_LU_USEC(timer));
        for(i = 0; i < n; i++)
        {
            j = nos[i];
            if(stat[j] != stat2[j])
                fprintf(stdout, "%d:%d/%d::%d\n", j, stat[j], stat2[j], inputs[i]);
        }
#ifdef OUT_ALL
        for(i = 0; i < total; i++)
        {
            fprintf(stdout, "%d:%d\n", i, res[i]);
        }
#endif
#endif
        /*
        for(i = 0; i < dmap->state->count; i++)
        {
            fprintf(stdout, "%d:{min:%d max:%d}(%d)\n", i, dmap->slots[i].min, dmap->slots[i].max, dmap->slots[i].count);
        }
        */
#ifdef TEST_RANGEFILTER
            dmap_set(dmap, 1, 1234567);
            dmap_set(dmap, 2, 1567890);
            fprintf(stdout, "rangefrom():%d\n", dmap_rangefrom(dmap, 1569000, NULL));
            fprintf(stdout, "rangeto():%d\n", dmap_rangeto(dmap, 1111111, NULL));
            fprintf(stdout, "range():%d\n", dmap_range(dmap, 1111111, 1600000, NULL));
#endif
#ifdef TEST_RANGE
        srand(time(NULL));
        TIMER_RESET(timer);
        for(i = 1; i < 40000000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            dmap_set(dmap, i, val);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "set() 40000000 timestamps,  time used:%lld\n", PT_LU_USEC(timer));
        fflush(stdout);
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            all += dmap_rangefrom(dmap, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "rangefrom() 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));
        fflush(stdout);
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            val = 1356969600 + (rand()%31536000);
            all += dmap_rangeto(dmap, val, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "rangeto() 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));
        fflush(stdout);
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            from = 1356969600 + (rand()%31536000);
            to = from + rand()%31536000;
            all += dmap_range(dmap, from, to, res);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "range(%p) 1000 times total:%lld, time used:%lld\n", res, (long long int)all, PT_LU_USEC(timer));
        fflush(stdout);
        srand(time(NULL));
        TIMER_RESET(timer);
        all = 0;
        for(i = 0; i < 1000; i++)
        {
            from = 1356969600 + (rand()%31536000);
            to = from + rand()%31536000;
            all += dmap_range(dmap, from, to, NULL);
        }
        TIMER_SAMPLE(timer);
        fprintf(stdout, "range(null) 1000 times total:%lld, time used:%lld\n", (long long int)all, PT_LU_USEC(timer));
        fflush(stdout);

#endif
        dmap_close(dmap);
        TIMER_CLEAN(timer);
        free(res);
    }
}
Ejemplo n.º 12
0
/****************************************************************************
* Function: main
*
* Description:  6228 hardware monitor usage.  
*
* Inputs:       none
* Return:       none
****************************************************************************/
int main ()
{
    P6228_REG_ADDR             p6228Regs;           /* 6228 registers */
    ADM1024_PARAMS             tempSensor;          /* temp. sensor params */
    ADM1024_VALUES             tempValues;          /* temp. sensor values */    
    int                        procId;
    unsigned int               status1;
    unsigned int               status2;
    int                        temp;
    int                        temperature;
    float                      voltage;
    int                        error;
    
    TIMER_RESET(0);                    /* Turn off timer 0 */
    INTR_GLOBAL_DISABLE();             /* disable global interrupts */
    CACHE_DISABLE();                   /* disable cache */

    P4290_LED0_OFF;                    /* error indicator */
    P4290_LED1_OFF;                    /* DDR bypass indicator */
    P4290_LED2_OFF;                    /* DDR selected indicator */
    P4290_LED3_OFF;                    /* activity indicator */

    /* Get the processor id on which the program running */
    procId = P4290GetProcId();

    /* Confirm the proper processor is running */
    if ((procId != P4290_PROC_A) && (procId != P4290_PROC_C))
    {
        /* Only processor A or C can run this example */
        P4290_LED0_ON;
        while(1)
            ;
    }

    /* Initialize table of 6228 register addresses */
    P6228InitRegAddr(P6228_CTRL_BASE, &p6228Regs);

    /* Get module id */
    if ((VIMGetModuleId(p6228Regs.eepromID)) != P6228_MODULE_ID)
    {
        /* Not a 6228 module. */
        P4290_LED0_ON;
        while(1)
            ;
    }
   
    /* Set 6228 registers to a default, known state */
    P6228ResetRegs(&p6228Regs);

    /* Load temperature sensor parameter table with default values. */
    P6228SetHwMonitorDefaults (&tempSensor);

    /* Temperature Sensor Parameters - there are 21 parameters in the data
     * structure, one to set the mode, two for interrupt masks and 18 limit
     * parameters.  There are two limit parameters for each condition that 
     * is monitored for the 6228, a low limit and a high limit.
     *
     * For this program, all monitored conditions are read back.  All limits
     * below are the same as default values.
     */

    /* internal temperature sensor */
    tempSensor.intTempHighLimit  = 85;
    tempSensor.intTempLowLimit   = 0;

    /* External temperature 1 (FPGA) */
    tempSensor.extTemp1HighLimit = 85;
    tempSensor.extTemp1LowLimit  = 0;

    /* External temperature 2 (board temp) */
    tempSensor.extTemp2HighLimit = 85;
    tempSensor.extTemp2LowLimit  = 0;

    /* 5 Volt monitor */
    tempSensor.v5HighLimit       = 5.50;
    tempSensor.v5LowLimit        = 4.50;

    /* Vcc monitor (3.3 Volts) */
    tempSensor.vccHighLimit      = 3.63;
    tempSensor.vccLowLimit       = 2.97;

    /* 1.5 Volt monitor (Analog Input 1) */
    tempSensor.ain1HighLimit     = 1.65;
    tempSensor.ain1LowLimit      = 1.35;

    /* 1.8 Volt monitor (Analog Input 2) */
    tempSensor.ain2HighLimit     = 1.98;
    tempSensor.ain2LowLimit      = 1.62;

    /* 2.5 Volt monitor (Vccp1) */
    tempSensor.vccp1HighLimit    = 2.75;
    tempSensor.vccp1LowLimit     = 2.25;

    /* 12 Volt monitor */
    tempSensor.v12HighLimit      = 13.2;
    tempSensor.v12LowLimit       = 10.8;
 
    /* Initialize the hardware monitor */
    P6228InitHwMonitor(&tempSensor, p6228Regs.hwMonitorPort);

    /* Delay for the ADM1024 to get settled before reading status */
    BaseboardDelayuS(25000);


    /* Main Loop -----------------------------------------------------------
     *
     * The main loop reads back the two status registers from the ADM1024.  
     * When errors are found, the specific value is read back and tested
     * against the limits.  If a value is below the lower limit, a bit is
     * set in the lower 16 bits of the variable "error".  The upper 16 bits
     * are used for values above the upper limit.  Separate bits are used 
     * for each monitored value.  "Error" can be viewed under Code Composer
     * to identify any failed values.
     */

    while (1)
    {              
        error = 0;
    
        /* read the two interrupt status registers */
        status1 = I2CTempSensorRead (p6228Regs.hwMonitorPort,
                                     P6228_TEMP_SENSOR_CHIP, 
                                     ADM1024_INTR_STAT1_REG);

        status2 = I2CTempSensorRead (p6228Regs.hwMonitorPort,
                                     P6228_TEMP_SENSOR_CHIP, 
                                     ADM1024_INTR_STAT2_REG);

        /* Check the status for each monitored condition.  If the status
         * bit indicated a limit was exceeded, determine if it was the low
         * or high limit.  
         */

        /* internal temperature */
        if (status1 & ADM1024_INTR_STAT1_INT_TEMP_MASK)
        {
            /* read value and set error code */
            temperature = I2CTempSensorRead (p6228Regs.hwMonitorPort,
                                             P6228_TEMP_SENSOR_CHIP, 
                                             ADM1024_INT_TEMP_VAL_REG);
            
            temperature = (temperature << 24) >> 24;   /* sign adjust */

            if (temperature < tempSensor.intTempLowLimit)
                error |= 0x00000001;   /* below low limit */
            else
                error |= 0x00010000;   /* above high limit */
        }

        /* external temperature - FPGA 1 */
        if (status1 & ADM1024_INTR_STAT1_EXT_TEMP1_MASK)
        {
            /* read value and set error code */
            temperature = I2CTempSensorRead (p6228Regs.hwMonitorPort,
                                             P6228_TEMP_SENSOR_CHIP, 
                                             ADM1024_EXT_TEMP1_VAL_REG);

            temperature = (temperature << 24) >> 24;   /* sign adjust */

            if (temperature < tempSensor.extTemp1LowLimit)
                error |= 0x00000002;   /* below low limit */
            else
                error |= 0x00020000;   /* above high limit */
        }