int main(int argc, char *argv[]) {
int rv;
struct guppi_udp_params p;
static struct option long_opts[] = {
{"help", 0, NULL, 'h'},
{"port", 1, NULL, 'p'},
{0,0,0,0}
};
int opt, opti;
p.port = 50000;
p.packet_size=8200;
while ((opt=getopt_long(argc,argv,"hp:",long_opts,&opti))!=-1) {
switch (opt) {
case 'p':
p.port = atoi(optarg);
break;
default:
case 'h':
usage();
exit(0);
break;
}
}
/* Default to bee2 if no hostname given */
if (optind==argc) {
strcpy(p.sender, "bee2_10");
} else {
strcpy(p.sender, argv[optind]);
}
/* Init udp params */
rv = guppi_udp_init(&p);
if (rv!=GUPPI_OK) {
fprintf(stderr, "Error setting up networking\n");
exit(1);
}
printf("sock=%d\n", p.sock);
int rv2;
unsigned long long packet_count=0, max_id=0, seq_num;
struct guppi_udp_packet packet;
int first=1;
signal(SIGINT, stop_running);
printf("Waiting for data (sock=%d).\n", p.sock);
while (run) {
rv = guppi_udp_wait(&p);
if (rv==GUPPI_OK) {
/* recv data ,etc */
rv2 = guppi_udp_recv(&p, &packet);
if (rv2!=GUPPI_OK) {
if (rv2==GUPPI_ERR_PACKET) {
fprintf(stderr, "unexpected packet size (%zd)\n",
packet.packet_size);
} else if (rv2==GUPPI_ERR_SYS) {
if (errno!=EAGAIN) {
printf("sock=%d\n", p.sock);
perror("recv");
exit(1);
}
} else {
fprintf(stderr, "Unknown error = %d\n", rv2);
}
} else {
if (first) {
printf("Receiving (packet_size=%d).\n", (int)p.packet_size);
first=0;
}
packet_count++;
seq_num = guppi_udp_packet_seq_num(&packet);
if (seq_num>max_id) { max_id=seq_num; }
}
} else if (rv==GUPPI_TIMEOUT) {
if (first==0) { run=0; }
} else {
if (run) {
perror("poll");
guppi_udp_close(&p);
exit(1);
} else {
printf("Caught SIGINT, exiting.\n");
}
}
}
printf("Received %lld packets, dropped %lld (%.3e)\n",
packet_count, max_id+1-packet_count,
(double)(max_id+1-packet_count)/(double)(max_id+1));
guppi_udp_close(&p);
exit(0);
}
static void *run(void * _args)
{
// Cast _args
struct guppi_thread_args *args = (struct guppi_thread_args *)_args;
#ifdef DEBUG_SEMS
fprintf(stderr, "s/tid %lu/NET/' <<.\n", pthread_self());
#endif
THREAD_RUN_BEGIN(args);
THREAD_RUN_SET_AFFINITY_PRIORITY(args);
THREAD_RUN_ATTACH_STATUS(args->instance_id, st);
st_p = &st; // allow global (this source file) access to the status buffer
/* Attach to paper_input_databuf */
THREAD_RUN_ATTACH_DATABUF(args->instance_id, paper_input_databuf, db, args->output_buffer);
/* Read in general parameters */
struct guppi_params gp;
struct sdfits pf;
char status_buf[GUPPI_STATUS_SIZE];
guppi_status_lock_busywait_safe(st_p);
memcpy(status_buf, st_p->buf, GUPPI_STATUS_SIZE);
guppi_status_unlock_safe(st_p);
guppi_read_obs_params(status_buf, &gp, &pf);
pthread_cleanup_push((void *)guppi_free_sdfits, &pf);
/* Read network params */
struct guppi_udp_params up;
//guppi_read_net_params(status_buf, &up);
paper_read_net_params(status_buf, &up);
// Store bind host/port info etc in status buffer
guppi_status_lock_busywait_safe(&st);
hputs(st.buf, "BINDHOST", up.bindhost);
hputi4(st.buf, "BINDPORT", up.bindport);
hputu4(st.buf, "MISSEDFE", 0);
hputu4(st.buf, "MISSEDPK", 0);
hputs(st.buf, STATUS_KEY, "running");
guppi_status_unlock_safe(&st);
struct guppi_udp_packet p;
/* Give all the threads a chance to start before opening network socket */
sleep(1);
#ifndef TIMING_TEST
/* Set up UDP socket */
int rv = guppi_udp_init(&up);
if (rv!=GUPPI_OK) {
guppi_error("guppi_net_thread",
"Error opening UDP socket.");
pthread_exit(NULL);
}
pthread_cleanup_push((void *)guppi_udp_close, &up);
#endif
/* Main loop */
uint64_t packet_count = 0;
uint64_t elapsed_wait_ns = 0;
uint64_t elapsed_recv_ns = 0;
uint64_t elapsed_proc_ns = 0;
float ns_per_wait = 0.0;
float ns_per_recv = 0.0;
float ns_per_proc = 0.0;
struct timespec start, stop;
struct timespec recv_start, recv_stop;
signal(SIGINT,cc);
while (run_threads) {
#ifndef TIMING_TEST
/* Read packet */
clock_gettime(CLOCK_MONOTONIC, &recv_start);
do {
clock_gettime(CLOCK_MONOTONIC, &start);
p.packet_size = recv(up.sock, p.data, GUPPI_MAX_PACKET_SIZE, 0);
clock_gettime(CLOCK_MONOTONIC, &recv_stop);
} while (p.packet_size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) && run_threads);
if(!run_threads) break;
if (up.packet_size != p.packet_size) {
if (p.packet_size != -1) {
#ifdef DEBUG_NET
guppi_warn("guppi_net_thread", "Incorrect pkt size");
#endif
continue;
} else {
guppi_error("guppi_net_thread",
"guppi_udp_recv returned error");
perror("guppi_udp_recv");
pthread_exit(NULL);
}
}
#endif
packet_count++;
// Copy packet into any blocks where it belongs.
const uint64_t mcnt = write_paper_packet_to_blocks((paper_input_databuf_t *)db, &p);
clock_gettime(CLOCK_MONOTONIC, &stop);
elapsed_wait_ns += ELAPSED_NS(recv_start, start);
elapsed_recv_ns += ELAPSED_NS(start, recv_stop);
elapsed_proc_ns += ELAPSED_NS(recv_stop, stop);
if(mcnt != -1) {
// Update status
ns_per_wait = (float)elapsed_wait_ns / packet_count;
ns_per_recv = (float)elapsed_recv_ns / packet_count;
ns_per_proc = (float)elapsed_proc_ns / packet_count;
guppi_status_lock_busywait_safe(&st);
hputu8(st.buf, "NETMCNT", mcnt);
// Gbps = bits_per_packet / ns_per_packet
// (N_BYTES_PER_PACKET excludes header, so +8 for the header)
hputr4(st.buf, "NETGBPS", 8*(N_BYTES_PER_PACKET+8)/(ns_per_recv+ns_per_proc));
hputr4(st.buf, "NETWATNS", ns_per_wait);
hputr4(st.buf, "NETRECNS", ns_per_recv);
hputr4(st.buf, "NETPRCNS", ns_per_proc);
guppi_status_unlock_safe(&st);
// Start new average
elapsed_wait_ns = 0;
elapsed_recv_ns = 0;
elapsed_proc_ns = 0;
packet_count = 0;
}
#if defined TIMING_TEST || defined NET_TIMING_TEST
#define END_LOOP_COUNT (1*1000*1000)
static int loop_count=0;
static struct timespec tt_start, tt_stop;
if(loop_count == 0) {
clock_gettime(CLOCK_MONOTONIC, &tt_start);
}
//if(loop_count == 1000000) run_threads = 0;
if(loop_count == END_LOOP_COUNT) {
clock_gettime(CLOCK_MONOTONIC, &tt_stop);
int64_t elapsed = ELAPSED_NS(tt_start, tt_stop);
printf("processed %d packets in %.6f ms (%.3f us per packet)\n",
END_LOOP_COUNT, elapsed/1e6, elapsed/1e3/END_LOOP_COUNT);
exit(0);
}
loop_count++;
#endif
/* Will exit if thread has been cancelled */
pthread_testcancel();
}
/* Have to close all push's */
#ifndef TIMING_TEST
pthread_cleanup_pop(0); /* Closes push(guppi_udp_close) */
#endif
pthread_cleanup_pop(0); /* Closes guppi_free_psrfits */
THREAD_RUN_DETACH_DATAUF;
THREAD_RUN_DETACH_STATUS;
THREAD_RUN_END;
return NULL;
}
