void
stats(const struct rusage *begin, const struct rusage *end, size_t rounds)
{
time_t usr_s_delta, sys_s_delta, s_delta;
suseconds_t usr_us_delta, sys_us_delta, us_delta;
double usr_delta, sys_delta, delta, usr_rate, rate;
usr_s_delta = end->ru_utime.tv_sec - begin->ru_utime.tv_sec;
sys_s_delta = end->ru_stime.tv_sec - begin->ru_stime.tv_sec;
s_delta = usr_s_delta + sys_s_delta;
usr_us_delta = end->ru_utime.tv_usec - begin->ru_utime.tv_usec;
sys_us_delta = end->ru_stime.tv_usec - begin->ru_stime.tv_usec;
us_delta = usr_us_delta + sys_us_delta;
usr_delta = (double)usr_s_delta + USEC(usr_us_delta);
sys_delta = (double)sys_s_delta + USEC(sys_us_delta);
delta = (double)s_delta + USEC(us_delta);
usr_rate = (double)rounds / usr_delta;
rate = (double)rounds / delta;
if (quiet)
printf("%.0lf\t%s\n", rate, getprogname());
else
printf("%ld\t%lf\t%lf\t%lf\t%lf\t%lf\t%s\n",
rounds, usr_delta, sys_delta, delta, usr_rate, rate,
getprogname());
}
static void _rfc1305_parse_timeval(unsigned char *read_buf, struct timeval_t *tv)
{
/* straight out of RFC-1305 Appendix A */
struct ntp_packet_t ntp_packet;
struct ntptime_t xmttime;
#ifdef NTP_DEBUG
struct ntptime_t reftime, orgtime, rectime;
#endif
memset(&ntp_packet, 0, sizeof(struct ntp_packet_t));
#define Data(i) _ntohl(((unsigned int *)read_buf)[i])
ntp_packet.li = Data(0) >> 30 & 0x03;
ntp_packet.vn = Data(0) >> 27 & 0x07;
ntp_packet.mode = Data(0) >> 24 & 0x07;
ntp_packet.stratum = Data(0) >> 16 & 0xff;
ntp_packet.poll = Data(0) >> 8 & 0xff;
ntp_packet.prec = Data(0) & 0xff;
if (ntp_packet.prec & 0x80) ntp_packet.prec |= 0xffffff00;
ntp_packet.delay = Data(1);
ntp_packet.disp = Data(2);
ntp_packet.refid = Data(3);
#ifdef NTP_DEBUG
reftime.coarse = Data(4);
reftime.fine = Data(5);
orgtime.coarse = Data(6);
orgtime.fine = Data(7);
rectime.coarse = Data(8);
rectime.fine = Data(9);
#endif
xmttime.coarse = Data(10);
xmttime.fine = Data(11);
#undef Data
#ifdef NTP_DEBUG
log_debug("LI=%d VN=%d Mode=%d Stratum=%d Poll=%d Precision=%d\n",
ntp_packet.li, ntp_packet.vn, ntp_packet.mode,
ntp_packet.stratum, ntp_packet.poll, ntp_packet.prec);
log_debug("Delay=%.1f Dispersion=%.1f Refid=%u.%u.%u.%u\n",
sec2u(ntp_packet.delay), sec2u(ntp_packet.disp),
ntp_packet.refid >> 24 & 0xff, ntp_packet.refid >> 16 & 0xff,
ntp_packet.refid >> 8 & 0xff, ntp_packet.refid & 0xff);
log_debug("Reference %u.%.6u\n", reftime.coarse - JAN_1970, USEC(reftime.fine));
log_debug("Originate %u.%.6u\n", orgtime.coarse - JAN_1970, USEC(orgtime.fine));
log_debug("Receive %u.%.6u\n", rectime.coarse - JAN_1970, USEC(rectime.fine));
log_debug("Transmit %u.%.6u\n", xmttime.coarse - JAN_1970, USEC(xmttime.fine));
#endif
tv->tv_sec = xmttime.coarse - JAN_1970;
tv->tv_usec = USEC(xmttime.fine);
}
int
main( int argc, char **argv ) {
struct timeval start, end;
rbudpReceiver_t *rbudpReceiver;
if ( argc < 5 ) {
printf
( "Usage: recvfile <sender> <path to the orig file> <path to the dest file name> <MTU>\n" );
printf
( " \n Example : recvfile <192.168.81.100 /path/to/file/on/sender /path/to/file/on/receiver 9000 \n" );
exit( 1 );
}
rbudpReceiver = malloc( sizeof( rbudpReceiver_t ) );
memset( rbudpReceiver, 0, sizeof( rbudpReceiver_t ) );
// the constructor
QUANTAnet_rbudpReceiver_c( rbudpReceiver, RECEIVE_PORT );
// the init
initReceiver( rbudpReceiver, argv[1] );
printf( "init finishes\n" );
gettimeofday( &start, NULL );
QUANTAnet_rbudpBase_c( &rbudpReceiver->rbudpBase );
getfile( rbudpReceiver, argv[2], argv[3], atoi( argv[4] ) );
gettimeofday( &end, NULL );
recvClose( rbudpReceiver );
printf( "time consumed: %d microseconds\n", USEC( &start, &end ) );
return 1;
}
void GetSynTimeFromNtpPacked(PNTPPACKED pSynNtpPacked,struct timeval* new_time)
{
NTPTIME trantime;
trantime.coarse = ntohl(pSynNtpPacked->trantime.coarse);
trantime.fine = ntohl(pSynNtpPacked->trantime.fine);
new_time->tv_sec = trantime.coarse - JAN_1970;
new_time->tv_usec = USEC(trantime.fine);
}
static void
rfc1305(uint32_t *data, struct timeval *tv)
{
#if 0
tv->tv_sec = ntohl(((uint32_t *)data)[10]) - JAN_1970 + (OUR_TZ*3600);
#else
tv->tv_sec = ntohl(((uint32_t *)data)[10]) - JAN_1970;
#endif
tv->tv_usec = USEC(ntohl(((uint32_t *)data)[11]));
}
void upm_delay_us(int time){
#if defined(linux)
usleep(time);
#elif defined(CONFIG_BOARD_ARDUINO_101) || defined(CONFIG_BOARD_ARDUINO_101_SSS) || defined(CONFIG_BOARD_QUARK_D2000_CRB)
struct nano_timer timer;
void *timer_data[1];
nano_timer_init(&timer, timer_data);
nano_timer_start(&timer, USEC(time));
nano_timer_test(&timer, TICKS_UNLIMITED);
#endif
}
static int set_time(char *srv, struct in_addr addr, uint32_t *data)
{
struct timeval tv;
tv.tv_sec = ntohl(((uint32_t *)data)[10]) - JAN_1970;
tv.tv_usec = USEC(ntohl(((uint32_t *)data)[11]));
if (settimeofday(&tv, NULL) < 0) {
perror("settimeofday");
return 1; /* Ouch, this should not happen :-( */
}
syslog(LOG_DAEMON | LOG_INFO, "Time set from %s [%s].", srv, inet_ntoa(addr));
return 0; /* All good, time set! */
}
static int init_new_client(t_server *serv, t_selfd *fd, t_client *client)
{
client->type_cli = UNKNOWN;
client->teamname = NULL;
client->cmds = NULL;
client->x = 0;
client->y = 0;
client->level = 1;
client->orientation = DOWN;
client->flag = OK;
client->tmpcmd = NULL;
client->tmpcmdsize = 0;
memset(&(client->inv), 0, sizeof(t_map));
fd->cli_num = serv->game.cli_num++;
add_to_list(&(serv->watch), fd);
send_response(fd, "BIENVENUE");
set_timeout(serv, fd, "timeout", USEC(INIT_TIMEOUT));
handle_client(fd, serv);
return (EXIT_SUCCESS);
}
void upm_delay_us(unsigned int time)
{
if (time <= 0)
time = 1;
#if defined(UPM_PLATFORM_LINUX)
struct timespec delay_time;
delay_time.tv_sec = time / 1000000;
delay_time.tv_nsec = (time % 1000000) * 1000;
// here we spin until the delay is complete - detecting signals
// and continuing where we left off
while (nanosleep(&delay_time, &delay_time) && errno == EINTR)
; // loop
#elif defined(UPM_PLATFORM_ZEPHYR)
# if KERNEL_VERSION_MAJOR == 1 && KERNEL_VERSION_MINOR >= 6
// we will use a upm_clock to do microsecond timings here as k_timer has
// only a millisecond resolution. So we init a clock and spin.
upm_clock_t timer;
upm_clock_init(&timer);
while (upm_elapsed_us(&timer) < time)
; // spin
# else
struct nano_timer timer;
void *timer_data[1];
nano_timer_init(&timer, timer_data);
nano_timer_start(&timer, USEC(time) + 1);
nano_timer_test(&timer, TICKS_UNLIMITED);
# endif
#endif
}
/*********************
* Generic functions *
********************/
static void _usleep(uint32_t usec)
{
static void (*func[3])(int32_t timeout_in_ticks) = {
NULL,
fiber_sleep,
task_sleep,
};
if (sys_execution_context_type_get() == 0) {
sys_thread_busy_wait(usec);
return;
}
/* Timeout in ticks: */
usec = USEC(usec);
/** Most likely usec will generate 0 ticks,
* so setting at least to 1
*/
if (!usec) {
usec = 1;
}
func[sys_execution_context_type_get()](usec);
}
void startToneGenerator(ToneGenerator *self,int unused){
self -> period = USEC(2145);
//self -> deadline = USEC(100);
PARALLEL_PORT_INIT(&portDevice,(int)(self -> direction));
ASYNC(self,generateTone,0);
} //public function
void setTone(ToneGenerator *self,int newTone){
self -> period = USEC(newTone);
} //public function
//
// Getting the speed of the processors in Hz. We get this from /proc/cpuinfo.
// Example output of /proc/cpuinfo:
//////////////////////////////////////////////////////////////////////
// processor : 0
// vendor_id : GenuineIntel
// cpu family : 6
// model : 7
// model name : Pentium III (Katmai)
// stepping : 3
// cpu MHz : 497.845315
// cache size : 512 KB
// ... file continues on ...
//////////////////////////////////////////////////////////////////////
// Note: We just take the first CPU we find and return its CPU speed.
double Performance::Get_Timer_Resolution()
{
#if defined(IOMTR_CPU_I386) || defined(IOMTR_CPU_XSCALE) || defined(IOMTR_CPU_X86_64) || defined(IOMTR_CPU_IA64)
int c;
char label[40];
int scanDecodes;
double result;
FILE *cpuInfo;
int khz;
if (kstatfd > 0 && ioctl(kstatfd, IM_IOC_GETCPUKHZ, &khz) >= 0) {
cout << "CPU KHZ: " << khz << endl;
return (double)khz *1000.0;
}
cpuInfo = fopen("/proc/cpuinfo", "r");
if (!cpuInfo) {
cerr << "Error determining CPU speed.\n";
return (0.0);
}
do {
fscanf(cpuInfo, "%7c", label);
if (!strncmp(label, "cpu MHz", 7)) {
scanDecodes = fscanf(cpuInfo, "%*s %lf", &result);
result *= 1000000.0;
fclose(cpuInfo);
if (scanDecodes == 1) {
return (result);
} else {
cerr << "Error determining CPU speed.\n";
return (0.0);
}
} else if (!strncmp(label, "cpu GHz", 7)) {
scanDecodes = fscanf(cpuInfo, "%*s %lf", &result);
result *= 1000000000.0;
fclose(cpuInfo);
if (scanDecodes == 1) {
return (result);
} else {
cerr << "Error determining CPU speed.\n";
return (0.0);
}
}
// Skip to the next line.
do {
c = getc(cpuInfo);
} while ((c != '\n') && (c != EOF));
} while (c != EOF);
fclose(cpuInfo);
cerr << "Error determining CPU speed.\n";
return (0.0);
#elif defined(IOMTR_CPU_PPC)
#define USEC(tv) (tv.tv_sec*1000000+tv.tv_usec)
struct timeval tv1, tv2;
DWORD t1, t2;
double result;
gettimeofday(&tv1, NULL);
t1 = get_tbl();
sleep(1);
t2 = get_tbl();
gettimeofday(&tv2, NULL);
result = ((double)(t2 - t1)) * (1000000.0 / (double)(USEC(tv2) - USEC(tv1)));
return (result);
#else
#warning ===> WARNING: You have to do some coding here to get the port done!
#endif
}
void rfc1305(uint32_t *data)
{
/*
struct ntptime *arrival;
struct timeval udp_arrival;
gettimeofday(&udp_arrival, NULL);
arrival->coarse = udp_arrival.tv_sec + JAN_1970;
arrival->fine = NTPFRAC(udp_arrival.tv_usec);
*/
/*
// straight out of RFC-1305 Appendix A
int li, vn, mode, stratum, poll, prec;
int delay, disp, refid;
struct ntptime reftime, orgtime, rectime, xmttime;
#define Data(i) ntohl(((uint32_t *)data)[i])
li = Data(0) >> 30 & 0x03;
vn = Data(0) >> 27 & 0x07;
mode = Data(0) >> 24 & 0x07;
stratum = Data(0) >> 16 & 0xff;
poll = Data(0) >> 8 & 0xff;
prec = Data(0) & 0xff;
if (prec & 0x80) prec|=0xffffff00;
delay = Data(1);
disp = Data(2);
refid = Data(3);
reftime.coarse = Data(4);
reftime.fine = Data(5);
orgtime.coarse = Data(6);
orgtime.fine = Data(7);
rectime.coarse = Data(8);
rectime.fine = Data(9);
xmttime.coarse = Data(10);
xmttime.fine = Data(11);
#undef Data
struct timeval tv_set;
// it would be even better to subtract half the slop
tv_set.tv_sec = xmttime.coarse - JAN_1970;
// divide xmttime.fine by 4294.967296
tv_set.tv_usec = USEC(xmttime.fine);
if (settimeofday(&tv_set,NULL)<0) {
perror("settimeofday");
exit(1);
}
*/
struct timeval tv_set;
tv_set.tv_sec = ntohl(((uint32_t *)data)[10]) - JAN_1970;
tv_set.tv_usec = USEC(ntohl(((uint32_t *)data)[11]));
if (settimeofday(&tv_set, NULL) < 0) {
perror("settimeofday");
exit(1);
}
/*
double el_time,st_time;
el_time=ntpdiff(&orgtime,arrival); // elapsed
st_time=ntpdiff(&rectime,&xmttime); // stall
return(el_time-st_time);
*/
}
// DMA handler
// called once per byte. handles all incoming data, but only minimally
// processes received data. at the end of a packet, it enqueues the
// received packet, fetches a new buffer, and restarts RX.
void le_DMA_IRQHandler(void) {
unsigned pos;
int8_t rssi;
uint32_t timestamp = NOW; // sampled early for most accurate measurement
// channel 0
if (DMACIntStat & (1 << 0)) {
// terminal count - byte received
if (DMACIntTCStat & (1 << 0)) {
DMACIntTCClear = (1 << 0);
// poll RSSI
rssi = (int8_t)(cc2400_get(RSSI) >> 8);
current_rxbuf->rssi_sum += rssi;
if (rssi < current_rxbuf->rssi_min) current_rxbuf->rssi_min = rssi;
if (rssi > current_rxbuf->rssi_max) current_rxbuf->rssi_max = rssi;
// grab byte from DMA buffer
pos = current_rxbuf->pos;
current_rxbuf->data[pos] = le_dma_dest[pos & 1]; // dirty hack
pos += 1;
current_rxbuf->pos = pos;
if (pos == 1) {
current_rxbuf->timestamp = timestamp - USEC(8 + 32); // packet starts at preamble
current_rxbuf->channel = rf_channel;
current_rxbuf->access_address = conn.access_address;
// data packet received: cancel timeout
// new timeout or hop timer will be set at end of packet RX
if (btle_channel_index(rf_channel) < 37) {
timer1_clear_match();
}
}
// get length from header
if (pos == 2) {
uint8_t length = dewhiten_length(current_rxbuf->channel, current_rxbuf->data[1]);
current_rxbuf->size = length + 2 + 3; // two bytes for header and three for CRC
}
// finished packet - state transition
if (pos > 2 && pos >= current_rxbuf->size) {
// stop the CC2400 before flushing SSP
cc2400_strobe(SFSON);
// stop DMA on this channel and flush SSP
DMACC0Config = 0;
DMACIntTCClear = (1 << 0); // if we don't clear a second time, data is corrupt
DIO_SSP_DMACR &= ~SSPDMACR_RXDMAE;
while (SSP1SR & SSPSR_RNE) {
uint8_t tmp = (uint8_t)DIO_SSP_DR;
}
// TODO error transition on queue_insert
queue_insert(&packet_queue, current_rxbuf);
// track connection events
if (btle_channel_index(rf_channel) < 37) {
++conn_event.num_packets;
// first packet: set connection anchor
if (conn_event.num_packets == 1) {
conn_event.anchor = current_rxbuf->timestamp;
timer1_set_match(NOW + IFS_TIMEOUT); // set a timeout for next packet
}
// second packet: close connection event, and set hop timer
else if (conn_event.num_packets == 2) {
cc2400_strobe(SRFOFF);
current_rxbuf = buffer_get();
finish_conn_event();
return;
}
}
// get a new packet
// TODO handle error transition
current_rxbuf = buffer_get();
// restart DMA and SSP
le_dma_init();
dio_ssp_start();
// wait for FS_LOCK in background
timer1_wait_fs_lock();
}
}
// error - transition to error state
if (DMACIntErrStat & (1 << 0)) {
// TODO error state transition
DMACIntErrClr = (1 << 0);
}
}
