2 * Copyright (C) 2016 Universita` di Pisa. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * This program implements NMREPLAY, a program to replay a pcap file
29 * enforcing the output rate and possibly random losses and delay
31 * It is meant to be run from the command line and implemented with a main
32 * control thread for monitoring, plus a thread to push packets out.
34 * The control thread parses command line arguments, prepares a
35 * schedule for transmission in a memory buffer and then sits
36 * in a loop where it periodically reads traffic statistics from
37 * the other threads and prints them out on the console.
39 * The transmit buffer contains headers and packets. Each header
40 * includes a timestamp that determines when the packet should be sent out.
41 * A "consumer" thread cons() reads from the queue and transmits packets
42 * on the output netmap port when their time has come.
44 * The program does CPU pinning and sets the scheduler and priority
45 * for the "cons" threads. Externally one should do the
46 * assignment of other threads (e.g. interrupt handlers) and
47 * make sure that network interfaces are configured properly.
49 * --- Main functions of the program ---
50 * within each function, q is used as a pointer to the queue holding
51 * packets and parameters.
55 * reads from the pcap file and prepares packets to transmit.
56 * After reading a packet from the pcap file, the following information
57 * are extracted which can be used to determine the schedule:
59 * q->cur_pkt points to the buffer containing the packet
60 * q->cur_len packet length, excluding CRC
61 * q->cur_caplen available packet length (may be shorter than cur_len)
62 * q->cur_tt transmission time for the packet, computed from the trace.
64 * The following functions are then called in sequence:
66 * q->c_loss (set with the -L command line option) decides
67 * whether the packet should be dropped before even queuing.
68 * This is generally useful to emulate random loss.
69 * The function is supposed to set q->c_drop = 1 if the
70 * packet should be dropped, or leave it to 0 otherwise.
72 * q->c_bw (set with the -B command line option) is used to
73 * enforce the transmit bandwidth. The function must store
74 * in q->cur_tt the transmission time (in nanoseconds) of
75 * the packet, which is typically proportional to the length
76 * of the packet, i.e. q->cur_tt = q->cur_len / <bandwidth>
77 * Variants are possible, eg. to account for constant framing
78 * bits as on the ethernet, or variable channel acquisition times,
80 * This mechanism can also be used to simulate variable queueing
81 * delay e.g. due to the presence of cross traffic.
83 * q->c_delay (set with the -D option) implements delay emulation.
84 * The function should set q->cur_delay to the additional
85 * delay the packet is subject to. The framework will take care of
86 * computing the actual exit time of a packet so that there is no
91 #define NED(_fmt, ...) do {} while (0)
92 #define ED(_fmt, ...) \
95 gettimeofday(&_t0, NULL); \
96 fprintf(stderr, "%03d.%03d %-10.10s [%5d] \t" _fmt "\n", \
97 (int)(_t0.tv_sec % 1000), (int)_t0.tv_usec/1000, \
98 __FUNCTION__, __LINE__, ##__VA_ARGS__); \
101 /* WWW is for warnings, EEE is for errors */
102 #define WWW(_fmt, ...) ED("--WWW-- " _fmt, ##__VA_ARGS__)
103 #define EEE(_fmt, ...) ED("--EEE-- " _fmt, ##__VA_ARGS__)
104 #define DDD(_fmt, ...) ED("--DDD-- " _fmt, ##__VA_ARGS__)
106 #define _GNU_SOURCE // for CPU_SET() etc
109 #include <libnetmap.h>
110 #include <math.h> /* log, exp etc. */
113 #include <pthread_np.h> /* pthread w/ affinity */
114 #include <sys/cpuset.h> /* cpu_set */
115 #endif /* __FreeBSD__ */
119 #include <string.h> /* memcpy */
121 #include <sys/ioctl.h>
122 #include <sys/mman.h>
123 #include <sys/poll.h>
124 #include <sys/resource.h> // setpriority
125 #include <sys/time.h>
130 * A packet in the queue is q_pkt plus the payload.
132 * For the packet descriptor we need the following:
134 * - position of next packet in the queue (can go backwards).
135 * We can reduce to 32 bits if we consider alignments,
136 * or we just store the length to be added to the current
137 * value and assume 0 as a special index.
138 * - actual packet length (16 bits may be ok)
139 * - queue output time, in nanoseconds (64 bits)
140 * - delay line output time, in nanoseconds
141 * One of the two can be packed to a 32bit value
143 * A convenient coding uses 32 bytes per packet.
147 uint64_t next; /* buffer index for next packet */
148 uint64_t pktlen; /* actual packet len */
149 uint64_t pt_qout; /* time of output from queue */
150 uint64_t pt_tx; /* transmit time */
155 * The header for a pcap file
157 struct pcap_file_header {
159 /*used to detect the file format itself and the byte
160 ordering. The writing application writes 0xa1b2c3d4 with it's native byte
161 ordering format into this field. The reading application will read either
162 0xa1b2c3d4 (identical) or 0xd4c3b2a1 (swapped). If the reading application
163 reads the swapped 0xd4c3b2a1 value, it knows that all the following fields
164 will have to be swapped too. For nanosecond-resolution files, the writing
165 application writes 0xa1b23c4d, with the two nibbles of the two lower-order
166 bytes swapped, and the reading application will read either 0xa1b23c4d
167 (identical) or 0x4d3cb2a1 (swapped)*/
168 uint16_t version_major;
169 uint16_t version_minor; /*the version number of this file format */
171 /*the correction time in seconds between GMT (UTC) and the
172 local timezone of the following packet header timestamps. Examples: If the
173 timestamps are in GMT (UTC), thiszone is simply 0. If the timestamps are in
174 Central European time (Amsterdam, Berlin, ...) which is GMT + 1:00, thiszone
176 uint32_t stampacc; /*the accuracy of time stamps in the capture*/
178 /*the "snapshot length" for the capture (typically 65535
179 or even more, but might be limited by the user)*/
181 /*link-layer header type, specifying the type of headers
182 at the beginning of the packet (e.g. 1 for Ethernet); this can be various
183 types such as 802.11, 802.11 with various radio information, PPP, Token
187 #if 0 /* from pcap.h */
188 struct pcap_file_header {
190 u_short version_major;
191 u_short version_minor;
192 bpf_int32 thiszone; /* gmt to local correction */
193 bpf_u_int32 sigfigs; /* accuracy of timestamps */
194 bpf_u_int32 snaplen; /* max length saved portion of each pkt */
195 bpf_u_int32 linktype; /* data link type (LINKTYPE_*) */
199 struct timeval ts; /* time stamp */
200 bpf_u_int32 caplen; /* length of portion present */
201 bpf_u_int32 len; /* length this packet (off wire) */
203 #endif /* from pcap.h */
206 uint32_t ts_sec; /* seconds from epoch */
207 uint32_t ts_frac; /* microseconds or nanoseconds depending on sigfigs */
209 /*the number of bytes of packet data actually captured
210 and saved in the file. This value should never become larger than orig_len
211 or the snaplen value of the global header*/
212 uint32_t len; /* wire length */
216 #define PKT_PAD (32) /* padding on packets */
218 static inline int pad(int x)
220 return ((x) + PKT_PAD - 1) & ~(PKT_PAD - 1) ;
226 * wrapper around the pcap file.
227 * We mmap the file so it is easy to do multiple passes through it.
229 struct nm_pcap_file {
232 const char *data; /* mmapped file */
236 uint64_t tot_bytes_rounded; /* need hdr + pad(len) */
237 uint32_t resolution; /* 1000 for us, 1 for ns */
238 int swap; /* need to swap fields ? */
241 uint64_t total_tx_time;
243 * total_tx_time is computed as last_ts - first_ts, plus the
244 * transmission time for the first packet which in turn is
245 * computed according to the average bandwidth
249 const char *cur; /* running pointer */
250 const char *lim; /* data + file_len */
254 static struct nm_pcap_file *readpcap(const char *fn);
255 static void destroy_pcap(struct nm_pcap_file *file);
258 #define NS_SCALE 1000000000UL /* nanoseconds in 1s */
260 static void destroy_pcap(struct nm_pcap_file *pf)
265 munmap((void *)(uintptr_t)pf->data, pf->filesize);
267 bzero(pf, sizeof(*pf));
272 // convert a field of given size if swap is needed.
274 cvt(const void *src, int size, char swap)
277 if (size != 2 && size != 4) {
278 EEE("Invalid size %d\n", size);
281 memcpy(&ret, src, size);
283 unsigned char tmp, *data = (unsigned char *)&ret;
285 for (i = 0; i < size / 2; i++) {
287 data[i] = data[size - (1 + i)];
288 data[size - (1 + i)] = tmp;
295 read_next_info(struct nm_pcap_file *pf, int size)
297 const char *end = pf->cur + size;
303 ret = cvt(pf->cur, size, pf->swap);
310 * mmap the file, make sure timestamps are sorted, and count
312 * Timestamps represent the receive time of the packets.
313 * We need to compute also the 'first_ts' which refers to a hypotetical
314 * packet right before the first one, see the code for details.
316 static struct nm_pcap_file *
317 readpcap(const char *fn)
319 struct nm_pcap_file _f, *pf = &_f;
320 uint64_t prev_ts, first_pkt_time;
321 uint32_t magic, first_len = 0;
323 bzero(pf, sizeof(*pf));
324 pf->fd = open(fn, O_RDONLY);
326 EEE("cannot open file %s", fn);
330 pf->filesize = lseek(pf->fd, 0, SEEK_END);
331 lseek(pf->fd, 0, SEEK_SET);
332 ED("filesize is %lu", (u_long)(pf->filesize));
333 if (pf->filesize < sizeof(struct pcap_file_header)) {
334 EEE("file too short %s", fn);
338 pf->data = mmap(NULL, pf->filesize, PROT_READ, MAP_SHARED, pf->fd, 0);
339 if (pf->data == MAP_FAILED) {
340 EEE("cannot mmap file %s", fn);
345 pf->lim = pf->data + pf->filesize;
347 pf->swap = 0; /* default, same endianness when read magic */
349 magic = read_next_info(pf, 4);
350 ED("magic is 0x%x", magic);
352 case 0xa1b2c3d4: /* native, us resolution */
354 pf->resolution = 1000;
356 case 0xd4c3b2a1: /* swapped, us resolution */
358 pf->resolution = 1000;
360 case 0xa1b23c4d: /* native, ns resolution */
362 pf->resolution = 1; /* nanoseconds */
364 case 0x4d3cb2a1: /* swapped, ns resolution */
366 pf->resolution = 1; /* nanoseconds */
369 EEE("unknown magic 0x%x", magic);
373 ED("swap %d res %d\n", pf->swap, pf->resolution);
374 pf->cur = pf->data + sizeof(struct pcap_file_header);
375 pf->lim = pf->data + pf->filesize;
378 while (pf->cur < pf->lim && pf->err == 0) {
379 uint32_t base = pf->cur - pf->data;
380 uint64_t cur_ts = read_next_info(pf, 4) * NS_SCALE +
381 read_next_info(pf, 4) * pf->resolution;
382 uint32_t caplen = read_next_info(pf, 4);
383 uint32_t len = read_next_info(pf, 4);
386 WWW("end of pcap file after %d packets\n",
390 if (cur_ts < prev_ts) {
391 WWW("reordered packet %d\n",
396 if (pf->tot_pkt == 0) {
397 pf->first_ts = cur_ts;
401 pf->tot_bytes += len;
402 pf->tot_bytes_rounded += pad(len) + sizeof(struct q_pkt);
405 pf->total_tx_time = prev_ts - pf->first_ts; /* excluding first packet */
406 ED("tot_pkt %lu tot_bytes %lu tx_time %.6f s first_len %lu",
407 (u_long)pf->tot_pkt, (u_long)pf->tot_bytes,
408 1e-9*pf->total_tx_time, (u_long)first_len);
410 * We determine that based on the
411 * average bandwidth of the trace, as follows
412 * first_pkt_ts = p[0].len / avg_bw
413 * In turn avg_bw = (total_len - p[0].len)/(p[n-1].ts - p[0].ts)
415 * first_ts = p[0].ts - p[0].len * (p[n-1].ts - p[0].ts) / (total_len - p[0].len)
417 if (pf->tot_bytes == first_len) {
418 /* cannot estimate bandwidth, so force 1 Gbit */
419 first_pkt_time = first_len * 8; /* * 10^9 / bw */
421 first_pkt_time = pf->total_tx_time * first_len / (pf->tot_bytes - first_len);
423 ED("first_pkt_time %.6f s", 1e-9*first_pkt_time);
424 pf->total_tx_time += first_pkt_time;
425 pf->first_ts -= first_pkt_time;
427 /* all correct, allocate a record and copy */
428 pf = calloc(1, sizeof(*pf));
430 /* reset pointer to start */
431 pf->cur = pf->data + sizeof(struct pcap_file_header);
436 enum my_pcap_mode { PM_NONE, PM_FAST, PM_FIXED, PM_REAL };
438 static int verbose = 0;
440 static int do_abort = 0;
443 #define cpuset_t cpu_set_t
447 #define cpuset_t uint64_t // XXX
448 static inline void CPU_ZERO(cpuset_t *p)
453 static inline void CPU_SET(uint32_t i, cpuset_t *p)
455 *p |= 1<< (i & 0x3f);
458 #define pthread_setaffinity_np(a, b, c) ((void)a, 0)
459 #define sched_setscheduler(a, b, c) (1) /* error */
460 #define clock_gettime(a,b) \
461 do {struct timespec t0 = {0,0}; *(b) = t0; } while (0)
463 #define _P64 unsigned long
468 /* we use uint64_t widely, but printf gives trouble on different
469 * platforms so we use _P64 as a cast
471 #define _P64 uint64_t
472 #endif /* print stuff */
475 struct _qs; /* forward */
477 * descriptor of a configuration entry.
478 * Each handler has a parse function which takes ac/av[] and returns
479 * true if successful. Any allocated space is stored into struct _cfg *
480 * that is passed as argument.
481 * arg and arg_len are included for convenience.
484 int (*parse)(struct _qs *, struct _cfg *, int ac, char *av[]); /* 0 ok, 1 on error */
485 int (*run)(struct _qs *, struct _cfg *arg); /* 0 Ok, 1 on error */
486 // int close(struct _qs *, void *arg); /* 0 Ok, 1 on error */
488 const char *optarg; /* command line argument. Initial value is the error message */
489 /* placeholders for common values */
490 void *arg; /* allocated memory if any */
491 int arg_len; /* size of *arg in case a realloc is needed */
492 uint64_t d[16]; /* static storage for simple cases */
493 double f[4]; /* static storage for simple cases */
498 * communication occurs through this data structure, with fields
499 * cache-aligned according to who are the readers/writers.
502 The queue is an array of memory (buf) of size buflen (does not change).
504 The producer uses 'tail' as an index in the queue to indicate
505 the first empty location (ie. after the last byte of data),
506 the consumer uses head to indicate the next byte to consume.
508 For best performance we should align buffers and packets
509 to multiples of cacheline, but this would explode memory too much.
510 Worst case memory explosion is with 65 byte packets.
511 Memory usage as shown below:
514 size 32-16 32-32 32-64 64-64
520 An empty queue has head == tail, a full queue will have free space
521 below a threshold. In our case the queue is large enough and we
522 are non blocking so we can simply drop traffic when the queue
523 approaches a full state.
525 To simulate bandwidth limitations efficiently, the producer has a second
526 pointer, prod_tail_1, used to check for expired packets. This is done lazily.
530 * When sizing the buffer, we must assume some value for the bandwidth.
531 * INFINITE_BW is supposed to be faster than what we support
533 #define INFINITE_BW (200ULL*1000000*1000)
534 #define MY_CACHELINE (128ULL)
535 #define MAX_PKT (9200) /* max packet size */
537 #define ALIGN_CACHE __attribute__ ((aligned (MY_CACHELINE)))
539 struct _qs { /* shared queue */
540 uint64_t t0; /* start of times */
542 uint64_t buflen; /* queue length */
545 /* handlers for various options */
550 /* producer's fields */
551 uint64_t tx ALIGN_CACHE; /* tx counter */
552 uint64_t prod_tail_1; /* head of queue */
553 uint64_t prod_head; /* cached copy */
554 uint64_t prod_tail; /* cached copy */
555 uint64_t prod_drop; /* drop packet count */
556 uint64_t prod_max_gap; /* rx round duration */
558 struct nm_pcap_file *pcap; /* the pcap struct */
560 /* parameters for reading from the netmap port */
561 struct nmport_d *src_port; /* netmap descriptor */
562 const char * prod_ifname; /* interface name or pcap file */
563 struct netmap_ring *rxring; /* current ring being handled */
564 uint32_t si; /* ring index */
566 uint32_t rx_qmax; /* stats on max queued */
568 uint64_t qt_qout; /* queue exit time for last packet */
570 * when doing shaping, the software computes and stores here
571 * the time when the most recently queued packet will exit from
575 uint64_t qt_tx; /* delay line exit time for last packet */
577 * The software computes the time at which the most recently
578 * queued packet exits from the queue.
579 * To avoid reordering, the next packet should exit at least
583 /* producer's fields controlling the queueing */
584 const char * cur_pkt; /* current packet being analysed */
585 uint32_t cur_len; /* length of current packet */
586 uint32_t cur_caplen; /* captured length of current packet */
588 int cur_drop; /* 1 if current packet should be dropped. */
590 * cur_drop can be set as a result of the loss emulation,
591 * and may need to use the packet size, current time, etc.
594 uint64_t cur_tt; /* transmission time (ns) for current packet */
596 * The transmission time is how much link time the packet will consume.
597 * should be set by the function that does the bandwidth emulation,
598 * but could also be the result of a function that emulates the
599 * presence of competing traffic, MAC protocols etc.
600 * cur_tt is 0 for links with infinite bandwidth.
603 uint64_t cur_delay; /* delay (ns) for current packet from c_delay.run() */
605 * this should be set by the function that computes the extra delay
606 * applied to the packet.
607 * The code makes sure that there is no reordering and possibly
608 * bumps the output time as needed.
612 /* consumer's fields */
613 const char * cons_ifname;
614 uint64_t rx ALIGN_CACHE; /* rx counter */
615 uint64_t cons_head; /* cached copy */
616 uint64_t cons_tail; /* cached copy */
617 uint64_t cons_now; /* most recent producer timestamp */
618 uint64_t rx_wait; /* stats */
621 volatile uint64_t _tail ALIGN_CACHE ; /* producer writes here */
622 volatile uint64_t _head ALIGN_CACHE ; /* consumer reads from here */
628 pthread_t cons_tid; /* main thread */
629 pthread_t prod_tid; /* producer thread */
632 int cons_core; /* core for cons() */
633 int prod_core; /* core for prod() */
635 struct nmport_d *pa; /* netmap descriptor */
641 #define NS_IN_S (1000000000ULL) // nanoseconds
642 #define TIME_UNITS NS_IN_S
643 /* set the thread affinity. */
648 struct sched_param p;
653 /* Set thread affinity affinity.*/
655 CPU_SET(i, &cpumask);
657 if (pthread_setaffinity_np(pthread_self(), sizeof(cpuset_t), &cpumask) != 0) {
658 WWW("Unable to set affinity: %s", strerror(errno));
660 if (setpriority(PRIO_PROCESS, 0, -10)) {; // XXX not meaningful
661 WWW("Unable to set priority: %s", strerror(errno));
663 bzero(&p, sizeof(p));
664 p.sched_priority = 10; // 99 on linux ?
665 // use SCHED_RR or SCHED_FIFO
666 if (sched_setscheduler(0, SCHED_RR, &p)) {
667 WWW("Unable to set scheduler: %s", strerror(errno));
674 * set the timestamp from the clock, subtract t0
677 set_tns_now(uint64_t *now, uint64_t t0)
681 clock_gettime(CLOCK_REALTIME, &t); // XXX precise on FreeBSD ?
682 *now = (uint64_t)(t.tv_nsec + NS_IN_S * t.tv_sec);
688 /* compare two timestamps */
689 static inline int64_t
690 ts_cmp(uint64_t a, uint64_t b)
692 return (int64_t)(a - b);
695 /* create a packet descriptor */
696 static inline struct q_pkt *
697 pkt_at(struct _qs *q, uint64_t ofs)
699 return (struct q_pkt *)(q->buf + ofs);
704 * we have already checked for room and prepared p->next
709 struct q_pkt *p = pkt_at(q, q->prod_tail);
711 /* hopefully prefetch has been done ahead */
712 nm_pkt_copy(q->cur_pkt, (char *)(p+1), q->cur_caplen);
713 p->pktlen = q->cur_len;
714 p->pt_qout = q->qt_qout;
716 p->next = q->prod_tail + pad(q->cur_len) + sizeof(struct q_pkt);
717 ND("enqueue len %d at %d new tail %ld qout %.6f tx %.6f",
718 q->cur_len, (int)q->prod_tail, p->next,
719 1e-9*p->pt_qout, 1e-9*p->pt_tx);
720 q->prod_tail = p->next;
726 * simple handler for parameters not supplied
729 null_run_fn(struct _qs *q, struct _cfg *cfg)
739 * put packet data into the buffer.
740 * We read from the mmapped pcap file, construct header, copy
741 * the captured length of the packet and pad with zeroes.
746 struct pipe_args *pa = _pa;
747 struct _qs *q = &pa->q;
748 struct nm_pcap_file *pf = q->pcap; /* already opened by readpcap */
749 uint32_t loops, i, tot_pkts;
751 /* data plus the loop record */
753 uint64_t t_tx, tt, last_ts; /* last timestamp from trace */
756 * For speed we make sure the trace is at least some 1000 packets,
757 * so we may need to loop the trace more than once (for short traces)
759 loops = (1 + 10000 / pf->tot_pkt);
760 tot_pkts = loops * pf->tot_pkt;
761 need = loops * pf->tot_bytes_rounded + sizeof(struct q_pkt);
762 q->buf = calloc(1, need);
763 if (q->buf == NULL) {
764 D("alloc %lld bytes for queue failed, exiting",(long long)need);
767 q->prod_head = q->prod_tail = 0;
770 pf->cur = pf->data + sizeof(struct pcap_file_header);
773 ED("--- start create %lu packets at tail %d",
774 (u_long)tot_pkts, (int)q->prod_tail);
775 last_ts = pf->first_ts; /* beginning of the trace */
777 q->qt_qout = 0; /* first packet out of the queue */
779 for (loops = 0, i = 0; i < tot_pkts && !do_abort; i++) {
780 const char *next_pkt; /* in the pcap buffer */
783 /* read values from the pcap buffer */
784 cur_ts = read_next_info(pf, 4) * NS_SCALE +
785 read_next_info(pf, 4) * pf->resolution;
786 q->cur_caplen = read_next_info(pf, 4);
787 q->cur_len = read_next_info(pf, 4);
788 next_pkt = pf->cur + q->cur_caplen;
790 /* prepare fields in q for the generator */
791 q->cur_pkt = pf->cur;
792 /* initial estimate of tx time */
793 q->cur_tt = cur_ts - last_ts;
794 // -pf->first_ts + loops * pf->total_tx_time - last_ts;
796 if ((i % pf->tot_pkt) == 0)
797 ED("insert %5d len %lu cur_tt %.6f",
798 i, (u_long)q->cur_len, 1e-9*q->cur_tt);
800 /* prepare for next iteration */
803 if (next_pkt == pf->lim) { //last pkt
804 pf->cur = pf->data + sizeof(struct pcap_file_header);
805 last_ts = pf->first_ts; /* beginning of the trace */
809 q->c_loss.run(q, &q->c_loss);
812 q->c_bw.run(q, &q->c_bw);
819 q->c_delay.run(q, &q->c_delay); /* compute delay */
820 t_tx = q->qt_qout + q->cur_delay;
821 ND(5, "tt %ld qout %ld tx %ld qt_tx %ld", tt, q->qt_qout, t_tx, q->qt_tx);
822 /* insure no reordering and spacing by transmission time */
823 q->qt_tx = (t_tx >= q->qt_tx + tt) ? t_tx : q->qt_tx + tt;
827 ND("ins %d q->prod_tail = %lu", (int)insert, (unsigned long)q->prod_tail);
830 ED("done q->prod_tail:%d",(int)q->prod_tail);
831 q->_tail = q->prod_tail; /* publish */
835 if (q->buf != NULL) {
838 nmport_close(pa->pb);
844 * the consumer reads from the queue using head,
845 * advances it every now and then.
850 struct pipe_args *pa = _pa;
851 struct _qs *q = &pa->q;
853 uint64_t last_ts = 0;
855 /* read the start of times in q->t0 */
856 set_tns_now(&q->t0, 0);
857 /* set the time (cons_now) to clock - q->t0 */
858 set_tns_now(&q->cons_now, q->t0);
859 q->cons_head = q->_head;
860 q->cons_tail = q->_tail;
861 while (!do_abort) { /* consumer, infinite */
862 struct q_pkt *p = pkt_at(q, q->cons_head);
864 __builtin_prefetch (q->buf + p->next);
866 if (q->cons_head == q->cons_tail) { //reset record
867 ND("Transmission restarted");
869 * add to q->t0 the time for the last packet
872 set_tns_now(&q->cons_now, q->t0);
873 q->cons_head = 0; //restart from beginning of the queue
877 if (ts_cmp(p->pt_tx, q->cons_now) > 0) {
880 /* the ioctl should be conditional */
881 ioctl(pa->pb->fd, NIOCTXSYNC, 0); // XXX just in case
884 set_tns_now(&q->cons_now, q->t0);
887 /* XXX copy is inefficient but simple */
888 if (nmport_inject(pa->pb, (char *)(p + 1), p->pktlen) == 0) {
889 RD(1, "inject failed len %d now %ld tx %ld h %ld t %ld next %ld",
890 (int)p->pktlen, (u_long)q->cons_now, (u_long)p->pt_tx,
891 (u_long)q->_head, (u_long)q->_tail, (u_long)p->next);
892 ioctl(pa->pb->fd, NIOCTXSYNC, 0);
897 if (pending > q->burst) {
898 ioctl(pa->pb->fd, NIOCTXSYNC, 0);
902 q->cons_head = p->next;
903 /* drain packets from the queue */
906 D("exiting on abort");
911 * In case of pcap file as input, the program acts in 2 different
912 * phases. It first fill the queue and then starts the cons()
915 nmreplay_main(void *_a)
917 struct pipe_args *a = _a;
918 struct _qs *q = &a->q;
919 const char *cap_fname = q->prod_ifname;
921 setaffinity(a->cons_core);
922 set_tns_now(&q->t0, 0); /* starting reference */
923 if (cap_fname == NULL) {
926 q->pcap = readpcap(cap_fname);
927 if (q->pcap == NULL) {
928 EEE("unable to read file %s", cap_fname);
932 destroy_pcap(q->pcap);
934 a->pb = nmport_open(q->cons_ifname);
936 EEE("cannot open netmap on %s", q->cons_ifname);
937 do_abort = 1; // XXX any better way ?
940 /* continue as cons() */
941 WWW("prepare to send packets");
944 EEE("exiting on abort");
946 if (q->pcap != NULL) {
947 destroy_pcap(q->pcap);
957 (void)sig; /* UNUSED */
959 signal(SIGINT, SIG_DFL);
968 "usage: nmreplay [-v] [-D delay] [-B {[constant,]bps|ether,bps|real,speedup}] [-L loss]\n"
969 "\t[-b burst] -f pcap-file -i <netmap:ifname|valeSSS:PPP>\n");
974 /*---- configuration handling ---- */
976 * support routine: split argument, returns ac and *av.
977 * av contains two extra entries, a NULL and a pointer
978 * to the entire string.
981 split_arg(const char *src, int *_ac)
983 char *my = NULL, **av = NULL;
984 const char *seps = " \t\r\n,";
985 int l, i, ac; /* number of entries */
990 /* in the first pass we count fields, in the second pass
991 * we allocate the av[] array and a copy of the string
992 * and fill av[]. av[ac] = NULL, av[ac+1]
996 ND("start pass %d: <%s>", av ? 1 : 0, my);
998 /* trim leading separator */
999 while (i <l && strchr(seps, src[i]))
1003 ND(" pass %d arg %d: <%s>", av ? 1 : 0, ac, src+i);
1004 if (av) /* in the second pass, set the result */
1008 while (i <l && !strchr(seps, src[i])) i++;
1010 my[i] = '\0'; /* write marker */
1012 if (!av) { /* end of first pass */
1014 av = calloc(1, (l+1) + (ac + 2)*sizeof(char *));
1015 my = (char *)&(av[ac+2]);
1021 for (i = 0; i < ac; i++) {
1022 NED("%d: <%s>", i, av[i]);
1032 * apply a command against a set of functions,
1033 * install a handler in *dst
1036 cmd_apply(const struct _cfg *a, const char *arg, struct _qs *q, struct _cfg *dst)
1042 if (arg == NULL || *arg == '\0')
1043 return 1; /* no argument may be ok */
1044 if (a == NULL || dst == NULL) {
1045 ED("program error - invalid arguments");
1048 av = split_arg(arg, &ac);
1050 return 1; /* error */
1051 for (i = 0; a[i].parse; i++) {
1052 struct _cfg x = a[i];
1053 const char *errmsg = x.optarg;
1058 bzero(&x.d, sizeof(x.d));
1059 ND("apply %s to %s", av[0], errmsg);
1060 ret = x.parse(q, &x, ac, av);
1061 if (ret == 2) /* not recognised */
1064 ED("invalid arguments: need '%s' have '%s'",
1072 ED("arguments %s not recognised", arg);
1077 static struct _cfg delay_cfg[];
1078 static struct _cfg bw_cfg[];
1079 static struct _cfg loss_cfg[];
1081 static uint64_t parse_bw(const char *arg);
1084 * prodcons [options]
1085 * accept separate sets of arguments for the two directions
1090 add_to(const char ** v, int l, const char *arg, const char *msg)
1092 for (; l > 0 && *v != NULL ; l--, v++);
1094 ED("%s %s", msg, arg);
1101 main(int argc, char **argv)
1106 struct pipe_args bp[N_OPTS];
1107 const char *d[N_OPTS], *b[N_OPTS], *l[N_OPTS], *q[N_OPTS], *ifname[N_OPTS], *m[N_OPTS];
1108 const char *pcap_file[N_OPTS];
1109 int cores[4] = { 2, 8, 4, 10 }; /* default values */
1111 bzero(&bp, sizeof(bp)); /* all data initially go here */
1112 bzero(d, sizeof(d));
1113 bzero(b, sizeof(b));
1114 bzero(l, sizeof(l));
1115 bzero(q, sizeof(q));
1116 bzero(m, sizeof(m));
1117 bzero(ifname, sizeof(ifname));
1118 bzero(pcap_file, sizeof(pcap_file));
1121 /* set default values */
1122 for (i = 0; i < N_OPTS; i++) {
1123 struct _qs *qs = &bp[i].q;
1126 qs->c_delay.optarg = "0";
1127 qs->c_delay.run = null_run_fn;
1128 qs->c_loss.optarg = "0";
1129 qs->c_loss.run = null_run_fn;
1130 qs->c_bw.optarg = "0";
1131 qs->c_bw.run = null_run_fn;
1135 // B bandwidth in bps
1136 // D delay in seconds
1137 // L loss probability
1145 while ( (ch = getopt(argc, argv, "B:C:D:L:b:f:i:vw:")) != -1) {
1148 D("bad option %c %s", ch, optarg);
1152 case 'C': /* CPU placement, up to 4 arguments */
1155 char **av = split_arg(optarg, &ac);
1156 if (ac == 1) { /* sequential after the first */
1157 cores[0] = atoi(av[0]);
1158 cores[1] = cores[0] + 1;
1159 cores[2] = cores[1] + 1;
1160 cores[3] = cores[2] + 1;
1161 } else if (ac == 2) { /* two sequential pairs */
1162 cores[0] = atoi(av[0]);
1163 cores[1] = cores[0] + 1;
1164 cores[2] = atoi(av[1]);
1165 cores[3] = cores[2] + 1;
1166 } else if (ac == 4) { /* four values */
1167 cores[0] = atoi(av[0]);
1168 cores[1] = atoi(av[1]);
1169 cores[2] = atoi(av[2]);
1170 cores[3] = atoi(av[3]);
1172 ED(" -C accepts 1, 2 or 4 comma separated arguments");
1180 case 'B': /* bandwidth in bps */
1181 add_to(b, N_OPTS, optarg, "-B too many times");
1184 case 'D': /* delay in seconds (float) */
1185 add_to(d, N_OPTS, optarg, "-D too many times");
1188 case 'L': /* loss probability */
1189 add_to(l, N_OPTS, optarg, "-L too many times");
1192 case 'b': /* burst */
1193 bp[0].q.burst = atoi(optarg);
1196 case 'f': /* pcap_file */
1197 add_to(pcap_file, N_OPTS, optarg, "-f too many times");
1199 case 'i': /* interface */
1200 add_to(ifname, N_OPTS, optarg, "-i too many times");
1206 bp[0].wait_link = atoi(optarg);
1216 * consistency checks for common arguments
1217 * if pcap file has been provided we need just one interface, two otherwise
1219 if (!pcap_file[0]) {
1220 ED("missing pcap file");
1224 ED("missing interface");
1227 if (bp[0].q.burst < 1 || bp[0].q.burst > 8192) {
1228 WWW("invalid burst %d, set to 1024", bp[0].q.burst);
1229 bp[0].q.burst = 1024; // XXX 128 is probably better
1231 if (bp[0].wait_link > 100) {
1232 ED("invalid wait_link %d, set to 4", bp[0].wait_link);
1233 bp[0].wait_link = 4;
1236 bp[0].q.prod_ifname = pcap_file[0];
1237 bp[0].q.cons_ifname = ifname[0];
1239 /* assign cores. prod and cons work better if on the same HT */
1240 bp[0].cons_core = cores[0];
1241 bp[0].prod_core = cores[1];
1242 ED("running on cores %d %d %d %d", cores[0], cores[1], cores[2], cores[3]);
1244 /* apply commands */
1245 for (i = 0; i < N_OPTS; i++) { /* once per queue */
1246 struct _qs *qs = &bp[i].q;
1247 err += cmd_apply(delay_cfg, d[i], qs, &qs->c_delay);
1248 err += cmd_apply(bw_cfg, b[i], qs, &qs->c_bw);
1249 err += cmd_apply(loss_cfg, l[i], qs, &qs->c_loss);
1254 pthread_create(&bp[0].cons_tid, NULL, nmreplay_main, (void*)&bp[0]);
1255 signal(SIGINT, sigint_h);
1258 struct _qs olda = bp[0].q;
1259 struct _qs *q0 = &bp[0].q;
1262 ED("%lld -> %lld maxq %d round %lld",
1263 (long long)(q0->rx - olda.rx), (long long)(q0->tx - olda.tx),
1264 q0->rx_qmax, (long long)q0->prod_max_gap
1266 ED("plr nominal %le actual %le",
1267 (double)(q0->c_loss.d[0])/(1<<24),
1268 q0->c_loss.d[1] == 0 ? 0 :
1269 (double)(q0->c_loss.d[2])/q0->c_loss.d[1]);
1270 bp[0].q.rx_qmax = (bp[0].q.rx_qmax * 7)/8; // ewma
1271 bp[0].q.prod_max_gap = (bp[0].q.prod_max_gap * 7)/8; // ewma
1273 D("exiting on abort");
1279 /* conversion factor for numbers.
1280 * Each entry has a set of characters and conversion factor,
1281 * the first entry should have an empty string and default factor,
1282 * the final entry has s = NULL.
1284 struct _sm { /* string and multiplier */
1290 * parse a generic value
1293 parse_gen(const char *arg, const struct _sm *conv, int *err)
1304 d = strtod(arg, &ep);
1305 if (ep == arg) { /* no value */
1306 ED("bad argument %s", arg);
1309 /* special case, no conversion */
1310 if (conv == NULL && *ep == '\0')
1312 ND("checking %s [%s]", arg, ep);
1313 for (;conv->s; conv++) {
1314 if (strchr(conv->s, *ep))
1318 *err = 1; /* unrecognised */
1323 ND("scale is %s %lf", conv->s, conv->m);
1324 d *= conv->m; /* apply default conversion */
1326 ND("returning %lf", d);
1330 #define U_PARSE_ERR ~(0ULL)
1332 /* returns a value in nanoseconds */
1334 parse_time(const char *arg)
1337 {"", 1000000000 /* seconds */},
1338 {"n", 1 /* nanoseconds */}, {"u", 1000 /* microseconds */},
1339 {"m", 1000000 /* milliseconds */}, {"s", 1000000000 /* seconds */},
1340 {NULL, 0 /* seconds */}
1343 uint64_t ret = (uint64_t)parse_gen(arg, a, &err);
1344 return err ? U_PARSE_ERR : ret;
1349 * parse a bandwidth, returns value in bps or U_PARSE_ERR if error.
1352 parse_bw(const char *arg)
1355 {"", 1}, {"kK", 1000}, {"mM", 1000000}, {"gG", 1000000000}, {NULL, 0}
1358 uint64_t ret = (uint64_t)parse_gen(arg, a, &err);
1359 return err ? U_PARSE_ERR : ret;
1364 * For some function we need random bits.
1365 * This is a wrapper to whatever function you want that returns
1366 * 24 useful random bits.
1369 static inline uint64_t
1370 my_random24(void) /* 24 useful bits */
1372 return random() & ((1<<24) - 1);
1376 /*-------------- user-configuration -----------------*/
1378 #if 0 /* start of comment block */
1380 Here we place the functions to implement the various features
1381 of the system. For each feature one should define a struct _cfg
1382 (see at the beginning for definition) that refers a *_parse() function
1383 to extract values from the command line, and a *_run() function
1384 that is invoked on each packet to implement the desired function.
1386 Examples of the two functions are below. In general:
1388 - the *_parse() function takes argc/argv[], matches the function
1389 name in argv[0], extracts the operating parameters, allocates memory
1390 if needed, and stores them in the struct _cfg.
1391 Return value is 2 if argv[0] is not recosnised, 1 if there is an
1392 error in the arguments, 0 if all ok.
1394 On the command line, argv[] is a single, comma separated argument
1395 that follow the specific option eg -D constant,20ms
1397 struct _cfg has some preallocated space (e.g an array of uint64_t) so simple
1398 function can use that without having to allocate memory.
1400 - the *_run() function takes struct _q *q and struct _cfg *cfg as arguments.
1401 *q contains all the informatio that may be possibly needed, including
1402 those on the packet currently under processing.
1403 The basic values are the following:
1405 char * cur_pkt points to the current packet (linear buffer)
1406 uint32_t cur_len; length of the current packet
1407 the functions are not supposed to modify these values
1409 int cur_drop; true if current packet must be dropped.
1410 Must be set to non-zero by the loss emulation function
1412 uint64_t cur_delay; delay in nanoseconds for the current packet
1413 Must be set by the delay emulation function
1415 More sophisticated functions may need to access other fields in *q,
1416 see the structure description for that.
1418 When implementing a new function for a feature (e.g. for delay,
1419 bandwidth, loss...) the struct _cfg should be added to the array
1420 that contains all possible options.
1422 --- Specific notes ---
1424 DELAY emulation -D option_arguments
1426 If the option is not supplied, the system applies 0 extra delay
1428 The resolution for times is 1ns, the precision is load dependent and
1429 generally in the order of 20-50us.
1430 Times are in nanoseconds, can be followed by a character specifying
1431 a different unit e.g.
1438 Currently implemented options:
1440 constant,t constant delay equal to t
1442 uniform,tmin,tmax uniform delay between tmin and tmax
1444 exp,tavg,tmin exponential distribution with average tavg
1445 and minimum tmin (corresponds to an exponential
1446 distribution with argument 1/(tavg-tmin) )
1449 LOSS emulation -L option_arguments
1451 Loss is expressed as packet or bit error rate, which is an absolute
1452 number between 0 and 1 (typically small).
1454 Currently implemented options
1456 plr,p uniform packet loss rate p, independent
1459 burst,p,lmin,lmax burst loss with burst probability p and
1460 burst length uniformly distributed between
1463 ber,p uniformly distributed bit error rate p,
1464 so actual loss prob. depends on size.
1466 BANDWIDTH emulation -B option_arguments
1468 Bandwidths are expressed in bits per second, can be followed by a
1469 character specifying a different unit e.g.
1472 k/K kbits/s (10^3 bits/s)
1473 m/M mbits/s (10^6 bits/s)
1474 g/G gbits/s (10^9 bits/s)
1476 Currently implemented options
1478 const,b constant bw, excluding mac framing
1479 ether,b constant bw, including ethernet framing
1480 (20 bytes framing + 4 bytes crc)
1481 real,[scale] use real time, optionally with a scaling factor
1483 #endif /* end of comment block */
1486 * Configuration options for delay
1489 /* constant delay, also accepts just a number */
1491 const_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1496 if (strncmp(av[0], "const", 5) != 0 && ac > 1)
1497 return 2; /* unrecognised */
1499 return 1; /* error */
1500 delay = parse_time(av[ac - 1]);
1501 if (delay == U_PARSE_ERR)
1502 return 1; /* error */
1504 return 0; /* success */
1507 /* runtime function, store the delay into q->cur_delay */
1509 const_delay_run(struct _qs *q, struct _cfg *arg)
1511 q->cur_delay = arg->d[0]; /* the delay */
1516 uniform_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1518 uint64_t dmin, dmax;
1521 if (strcmp(av[0], "uniform") != 0)
1522 return 2; /* not recognised */
1524 return 1; /* error */
1525 dmin = parse_time(av[1]);
1526 dmax = parse_time(av[2]);
1527 if (dmin == U_PARSE_ERR || dmax == U_PARSE_ERR || dmin > dmax)
1529 D("dmin %lld dmax %lld", (long long)dmin, (long long)dmax);
1532 dst->d[2] = dmax - dmin;
1537 uniform_delay_run(struct _qs *q, struct _cfg *arg)
1539 uint64_t x = my_random24();
1540 q->cur_delay = arg->d[0] + ((arg->d[2] * x) >> 24);
1541 #if 0 /* COMPUTE_STATS */
1542 #endif /* COMPUTE_STATS */
1547 * exponential delay: Prob(delay = x) = exp(-x/d_av)
1548 * gives a delay between 0 and infinity with average d_av
1549 * The cumulative function is 1 - d_av exp(-x/d_av)
1551 * The inverse function generates a uniform random number p in 0..1
1552 * and generates delay = (d_av-d_min) * -ln(1-p) + d_min
1554 * To speed up behaviour at runtime we tabulate the values
1558 exp_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1560 #define PTS_D_EXP 512
1561 uint64_t i, d_av, d_min, *t; /*table of values */
1564 if (strcmp(av[0], "exp") != 0)
1565 return 2; /* not recognised */
1567 return 1; /* error */
1568 d_av = parse_time(av[1]);
1569 d_min = parse_time(av[2]);
1570 if (d_av == U_PARSE_ERR || d_min == U_PARSE_ERR || d_av < d_min)
1571 return 1; /* error */
1573 dst->arg_len = PTS_D_EXP * sizeof(uint64_t);
1574 dst->arg = calloc(1, dst->arg_len);
1575 if (dst->arg == NULL)
1576 return 1; /* no memory */
1577 t = (uint64_t *)dst->arg;
1578 /* tabulate -ln(1-n)*delay for n in 0..1 */
1579 for (i = 0; i < PTS_D_EXP; i++) {
1580 double d = -log2 ((double)(PTS_D_EXP - i) / PTS_D_EXP) * d_av + d_min;
1582 ND(5, "%ld: %le", i, d);
1588 exp_delay_run(struct _qs *q, struct _cfg *arg)
1590 uint64_t *t = (uint64_t *)arg->arg;
1591 q->cur_delay = t[my_random24() & (PTS_D_EXP - 1)];
1592 RD(5, "delay %llu", (unsigned long long)q->cur_delay);
1597 /* unused arguments in configuration */
1598 #define TLEM_CFG_END NULL, 0, {0}, {0}
1600 static struct _cfg delay_cfg[] = {
1601 { const_delay_parse, const_delay_run,
1602 "constant,delay", TLEM_CFG_END },
1603 { uniform_delay_parse, uniform_delay_run,
1604 "uniform,dmin,dmax # dmin <= dmax", TLEM_CFG_END },
1605 { exp_delay_parse, exp_delay_run,
1606 "exp,dmin,davg # dmin <= davg", TLEM_CFG_END },
1607 { NULL, NULL, NULL, TLEM_CFG_END }
1610 /* standard bandwidth, also accepts just a number */
1612 const_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1617 if (strncmp(av[0], "const", 5) != 0 && ac > 1)
1618 return 2; /* unrecognised */
1620 return 1; /* error */
1621 bw = parse_bw(av[ac - 1]);
1622 if (bw == U_PARSE_ERR) {
1623 return (ac == 2) ? 1 /* error */ : 2 /* unrecognised */;
1626 return 0; /* success */
1630 /* runtime function, store the delay into q->cur_delay */
1632 const_bw_run(struct _qs *q, struct _cfg *arg)
1634 uint64_t bps = arg->d[0];
1635 q->cur_tt = bps ? 8ULL* TIME_UNITS * q->cur_len / bps : 0 ;
1639 /* ethernet bandwidth, add 672 bits per packet */
1641 ether_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1646 if (strcmp(av[0], "ether") != 0)
1647 return 2; /* unrecognised */
1649 return 1; /* error */
1650 bw = parse_bw(av[ac - 1]);
1651 if (bw == U_PARSE_ERR)
1652 return 1; /* error */
1654 return 0; /* success */
1658 /* runtime function, add 20 bytes (framing) + 4 bytes (crc) */
1660 ether_bw_run(struct _qs *q, struct _cfg *arg)
1662 uint64_t bps = arg->d[0];
1663 q->cur_tt = bps ? 8ULL * TIME_UNITS * (q->cur_len + 24) / bps : 0 ;
1667 /* real bandwidth, plus scaling factor */
1669 real_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1674 if (strcmp(av[0], "real") != 0)
1675 return 2; /* unrecognised */
1676 if (ac > 2) { /* second argument is optional */
1677 return 1; /* error */
1678 } else if (ac == 1) {
1682 scale = parse_gen(av[ac-1], NULL, &err);
1683 if (err || scale <= 0 || scale > 1000)
1686 ED("real -> scale is %.6f", scale);
1688 return 0; /* success */
1692 real_bw_run(struct _qs *q, struct _cfg *arg)
1694 q->cur_tt /= arg->f[0];
1698 static struct _cfg bw_cfg[] = {
1699 { const_bw_parse, const_bw_run,
1700 "constant,bps", TLEM_CFG_END },
1701 { ether_bw_parse, ether_bw_run,
1702 "ether,bps", TLEM_CFG_END },
1703 { real_bw_parse, real_bw_run,
1704 "real,scale", TLEM_CFG_END },
1705 { NULL, NULL, NULL, TLEM_CFG_END }
1712 const_plr_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1718 if (strcmp(av[0], "plr") != 0 && ac > 1)
1719 return 2; /* unrecognised */
1721 return 1; /* error */
1722 // XXX to be completed
1723 plr = parse_gen(av[ac-1], NULL, &err);
1724 if (err || plr < 0 || plr > 1)
1726 dst->d[0] = plr * (1<<24); /* scale is 16m */
1727 if (plr != 0 && dst->d[0] == 0)
1728 ED("WWW warning, rounding %le down to 0", plr);
1729 return 0; /* success */
1733 const_plr_run(struct _qs *q, struct _cfg *arg)
1736 uint64_t r = my_random24();
1737 q->cur_drop = r < arg->d[0];
1738 #if 1 /* keep stats */
1740 arg->d[2] += q->cur_drop;
1747 * For BER the loss is 1- (1-ber)**bit_len
1748 * The linear approximation is only good for small values, so we
1749 * tabulate (1-ber)**len for various sizes in bytes
1752 const_ber_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1754 double ber, ber8, cur;
1757 const uint32_t mask = (1<<24) - 1;
1760 if (strcmp(av[0], "ber") != 0)
1761 return 2; /* unrecognised */
1763 return 1; /* error */
1764 ber = parse_gen(av[ac-1], NULL, &err);
1765 if (err || ber < 0 || ber > 1)
1767 dst->arg_len = MAX_PKT * sizeof(uint32_t);
1768 plr = calloc(1, dst->arg_len);
1770 return 1; /* no memory */
1773 ber8 *= ber8; /* **2 */
1774 ber8 *= ber8; /* **4 */
1775 ber8 *= ber8; /* **8 */
1777 for (i=0; i < MAX_PKT; i++, cur *= ber8) {
1778 plr[i] = (mask + 1)*(1 - cur);
1782 if (i>= 60) // && plr[i] < mask/2)
1783 RD(50,"%4d: %le %ld", i, 1.0 - cur, (_P64)plr[i]);
1786 dst->d[0] = ber * (mask + 1);
1787 return 0; /* success */
1791 const_ber_run(struct _qs *q, struct _cfg *arg)
1794 uint64_t r = my_random24();
1795 uint32_t *plr = arg->arg;
1798 RD(5, "pkt len %d too large, trim to %d", l, MAX_PKT-1);
1801 q->cur_drop = r < plr[l];
1802 #if 1 /* keep stats */
1804 arg->d[2] += q->cur_drop;
1809 static struct _cfg loss_cfg[] = {
1810 { const_plr_parse, const_plr_run,
1811 "plr,prob # 0 <= prob <= 1", TLEM_CFG_END },
1812 { const_ber_parse, const_ber_run,
1813 "ber,prob # 0 <= prob <= 1", TLEM_CFG_END },
1814 { NULL, NULL, NULL, TLEM_CFG_END }