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
31 This program implements NMREPLAY, a program to replay a pcap file
32 enforcing the output rate and possibly random losses and delay
34 It is meant to be run from the command line and implemented with a main
35 control thread for monitoring, plus a thread to push packets out.
37 The control thread parses command line arguments, prepares a
38 schedule for transmission in a memory buffer and then sits
39 in a loop where it periodically reads traffic statistics from
40 the other threads and prints them out on the console.
42 The transmit buffer contains headers and packets. Each header
43 includes a timestamp that determines when the packet should be sent out.
44 A "consumer" thread cons() reads from the queue and transmits packets
45 on the output netmap port when their time has come.
47 The program does CPU pinning and sets the scheduler and priority
48 for the "cons" threads. Externally one should do the
49 assignment of other threads (e.g. interrupt handlers) and
50 make sure that network interfaces are configured properly.
52 --- Main functions of the program ---
53 within each function, q is used as a pointer to the queue holding
54 packets and parameters.
58 reads from the pcap file and prepares packets to transmit.
59 After reading a packet from the pcap file, the following information
60 are extracted which can be used to determine the schedule:
62 q->cur_pkt points to the buffer containing the packet
63 q->cur_len packet length, excluding CRC
64 q->cur_caplen available packet length (may be shorter than cur_len)
65 q->cur_tt transmission time for the packet, computed from the trace.
67 The following functions are then called in sequence:
69 q->c_loss (set with the -L command line option) decides
70 whether the packet should be dropped before even queuing.
71 This is generally useful to emulate random loss.
72 The function is supposed to set q->c_drop = 1 if the
73 packet should be dropped, or leave it to 0 otherwise.
75 q->c_bw (set with the -B command line option) is used to
76 enforce the transmit bandwidth. The function must store
77 in q->cur_tt the transmission time (in nanoseconds) of
78 the packet, which is typically proportional to the length
79 of the packet, i.e. q->cur_tt = q->cur_len / <bandwidth>
80 Variants are possible, eg. to account for constant framing
81 bits as on the ethernet, or variable channel acquisition times,
83 This mechanism can also be used to simulate variable queueing
84 delay e.g. due to the presence of cross traffic.
86 q->c_delay (set with the -D option) implements delay emulation.
87 The function should set q->cur_delay to the additional
88 delay the packet is subject to. The framework will take care of
89 computing the actual exit time of a packet so that there is no
96 #define NED(_fmt, ...) do {} while (0)
97 #define ED(_fmt, ...) \
100 gettimeofday(&_t0, NULL); \
101 fprintf(stderr, "%03d.%03d %-10.10s [%5d] \t" _fmt "\n", \
102 (int)(_t0.tv_sec % 1000), (int)_t0.tv_usec/1000, \
103 __FUNCTION__, __LINE__, ##__VA_ARGS__); \
106 /* WWW is for warnings, EEE is for errors */
107 #define WWW(_fmt, ...) ED("--WWW-- " _fmt, ##__VA_ARGS__)
108 #define EEE(_fmt, ...) ED("--EEE-- " _fmt, ##__VA_ARGS__)
109 #define DDD(_fmt, ...) ED("--DDD-- " _fmt, ##__VA_ARGS__)
111 #define _GNU_SOURCE // for CPU_SET() etc
113 #define NETMAP_WITH_LIBS
114 #include <net/netmap_user.h>
115 #include <sys/poll.h>
120 A packet in the queue is q_pkt plus the payload.
122 For the packet descriptor we need the following:
124 - position of next packet in the queue (can go backwards).
125 We can reduce to 32 bits if we consider alignments,
126 or we just store the length to be added to the current
127 value and assume 0 as a special index.
128 - actual packet length (16 bits may be ok)
129 - queue output time, in nanoseconds (64 bits)
130 - delay line output time, in nanoseconds
131 One of the two can be packed to a 32bit value
133 A convenient coding uses 32 bytes per packet.
138 uint64_t next; /* buffer index for next packet */
139 uint64_t pktlen; /* actual packet len */
140 uint64_t pt_qout; /* time of output from queue */
141 uint64_t pt_tx; /* transmit time */
146 * The header for a pcap file
148 struct pcap_file_header {
150 /*used to detect the file format itself and the byte
151 ordering. The writing application writes 0xa1b2c3d4 with it's native byte
152 ordering format into this field. The reading application will read either
153 0xa1b2c3d4 (identical) or 0xd4c3b2a1 (swapped). If the reading application
154 reads the swapped 0xd4c3b2a1 value, it knows that all the following fields
155 will have to be swapped too. For nanosecond-resolution files, the writing
156 application writes 0xa1b23c4d, with the two nibbles of the two lower-order
157 bytes swapped, and the reading application will read either 0xa1b23c4d
158 (identical) or 0x4d3cb2a1 (swapped)*/
159 uint16_t version_major;
160 uint16_t version_minor; /*the version number of this file format */
162 /*the correction time in seconds between GMT (UTC) and the
163 local timezone of the following packet header timestamps. Examples: If the
164 timestamps are in GMT (UTC), thiszone is simply 0. If the timestamps are in
165 Central European time (Amsterdam, Berlin, ...) which is GMT + 1:00, thiszone
167 uint32_t stampacc; /*the accuracy of time stamps in the capture*/
169 /*the "snapshot length" for the capture (typically 65535
170 or even more, but might be limited by the user)*/
172 /*link-layer header type, specifying the type of headers
173 at the beginning of the packet (e.g. 1 for Ethernet); this can be various
174 types such as 802.11, 802.11 with various radio information, PPP, Token
178 #if 0 /* from pcap.h */
179 struct pcap_file_header {
181 u_short version_major;
182 u_short version_minor;
183 bpf_int32 thiszone; /* gmt to local correction */
184 bpf_u_int32 sigfigs; /* accuracy of timestamps */
185 bpf_u_int32 snaplen; /* max length saved portion of each pkt */
186 bpf_u_int32 linktype; /* data link type (LINKTYPE_*) */
190 struct timeval ts; /* time stamp */
191 bpf_u_int32 caplen; /* length of portion present */
192 bpf_u_int32 len; /* length this packet (off wire) */
194 #endif /* from pcap.h */
197 uint32_t ts_sec; /* seconds from epoch */
198 uint32_t ts_frac; /* microseconds or nanoseconds depending on sigfigs */
200 /*the number of bytes of packet data actually captured
201 and saved in the file. This value should never become larger than orig_len
202 or the snaplen value of the global header*/
203 uint32_t len; /* wire length */
207 #define PKT_PAD (32) /* padding on packets */
209 static inline int pad(int x)
211 return ((x) + PKT_PAD - 1) & ~(PKT_PAD - 1) ;
217 * wrapper around the pcap file.
218 * We mmap the file so it is easy to do multiple passes through it.
220 struct nm_pcap_file {
223 const char *data; /* mmapped file */
227 uint64_t tot_bytes_rounded; /* need hdr + pad(len) */
228 uint32_t resolution; /* 1000 for us, 1 for ns */
229 int swap; /* need to swap fields ? */
232 uint64_t total_tx_time;
234 * total_tx_time is computed as last_ts - first_ts, plus the
235 * transmission time for the first packet which in turn is
236 * computed according to the average bandwidth
240 const char *cur; /* running pointer */
241 const char *lim; /* data + file_len */
245 static struct nm_pcap_file *readpcap(const char *fn);
246 static void destroy_pcap(struct nm_pcap_file *file);
254 #include <string.h> /* memcpy */
256 #include <sys/mman.h>
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 };
440 static int do_abort = 0;
445 #include <sys/time.h>
447 #include <sys/resource.h> // setpriority
450 #include <pthread_np.h> /* pthread w/ affinity */
451 #include <sys/cpuset.h> /* cpu_set */
452 #endif /* __FreeBSD__ */
455 #define cpuset_t cpu_set_t
459 #define cpuset_t uint64_t // XXX
460 static inline void CPU_ZERO(cpuset_t *p)
465 static inline void CPU_SET(uint32_t i, cpuset_t *p)
467 *p |= 1<< (i & 0x3f);
470 #define pthread_setaffinity_np(a, b, c) ((void)a, 0)
471 #define sched_setscheduler(a, b, c) (1) /* error */
472 #define clock_gettime(a,b) \
473 do {struct timespec t0 = {0,0}; *(b) = t0; } while (0)
475 #define _P64 unsigned long
480 /* we use uint64_t widely, but printf gives trouble on different
481 * platforms so we use _P64 as a cast
483 #define _P64 uint64_t
484 #endif /* print stuff */
487 struct _qs; /* forward */
489 * descriptor of a configuration entry.
490 * Each handler has a parse function which takes ac/av[] and returns
491 * true if successful. Any allocated space is stored into struct _cfg *
492 * that is passed as argument.
493 * arg and arg_len are included for convenience.
496 int (*parse)(struct _qs *, struct _cfg *, int ac, char *av[]); /* 0 ok, 1 on error */
497 int (*run)(struct _qs *, struct _cfg *arg); /* 0 Ok, 1 on error */
498 // int close(struct _qs *, void *arg); /* 0 Ok, 1 on error */
500 const char *optarg; /* command line argument. Initial value is the error message */
501 /* placeholders for common values */
502 void *arg; /* allocated memory if any */
503 int arg_len; /* size of *arg in case a realloc is needed */
504 uint64_t d[16]; /* static storage for simple cases */
505 double f[4]; /* static storage for simple cases */
510 * communication occurs through this data structure, with fields
511 * cache-aligned according to who are the readers/writers.
514 The queue is an array of memory (buf) of size buflen (does not change).
516 The producer uses 'tail' as an index in the queue to indicate
517 the first empty location (ie. after the last byte of data),
518 the consumer uses head to indicate the next byte to consume.
520 For best performance we should align buffers and packets
521 to multiples of cacheline, but this would explode memory too much.
522 Worst case memory explosion is with 65 byte packets.
523 Memory usage as shown below:
526 size 32-16 32-32 32-64 64-64
532 An empty queue has head == tail, a full queue will have free space
533 below a threshold. In our case the queue is large enough and we
534 are non blocking so we can simply drop traffic when the queue
535 approaches a full state.
537 To simulate bandwidth limitations efficiently, the producer has a second
538 pointer, prod_tail_1, used to check for expired packets. This is done lazily.
542 * When sizing the buffer, we must assume some value for the bandwidth.
543 * INFINITE_BW is supposed to be faster than what we support
545 #define INFINITE_BW (200ULL*1000000*1000)
546 #define MY_CACHELINE (128ULL)
547 #define MAX_PKT (9200) /* max packet size */
549 #define ALIGN_CACHE __attribute__ ((aligned (MY_CACHELINE)))
551 struct _qs { /* shared queue */
552 uint64_t t0; /* start of times */
554 uint64_t buflen; /* queue length */
557 /* handlers for various options */
562 /* producer's fields */
563 uint64_t tx ALIGN_CACHE; /* tx counter */
564 uint64_t prod_tail_1; /* head of queue */
565 uint64_t prod_head; /* cached copy */
566 uint64_t prod_tail; /* cached copy */
567 uint64_t prod_drop; /* drop packet count */
568 uint64_t prod_max_gap; /* rx round duration */
570 struct nm_pcap_file *pcap; /* the pcap struct */
572 /* parameters for reading from the netmap port */
573 struct nm_desc *src_port; /* netmap descriptor */
574 const char * prod_ifname; /* interface name or pcap file */
575 struct netmap_ring *rxring; /* current ring being handled */
576 uint32_t si; /* ring index */
578 uint32_t rx_qmax; /* stats on max queued */
580 uint64_t qt_qout; /* queue exit time for last packet */
582 * when doing shaping, the software computes and stores here
583 * the time when the most recently queued packet will exit from
587 uint64_t qt_tx; /* delay line exit time for last packet */
589 * The software computes the time at which the most recently
590 * queued packet exits from the queue.
591 * To avoid reordering, the next packet should exit at least
595 /* producer's fields controlling the queueing */
596 const char * cur_pkt; /* current packet being analysed */
597 uint32_t cur_len; /* length of current packet */
598 uint32_t cur_caplen; /* captured length of current packet */
600 int cur_drop; /* 1 if current packet should be dropped. */
602 * cur_drop can be set as a result of the loss emulation,
603 * and may need to use the packet size, current time, etc.
606 uint64_t cur_tt; /* transmission time (ns) for current packet */
608 * The transmission time is how much link time the packet will consume.
609 * should be set by the function that does the bandwidth emulation,
610 * but could also be the result of a function that emulates the
611 * presence of competing traffic, MAC protocols etc.
612 * cur_tt is 0 for links with infinite bandwidth.
615 uint64_t cur_delay; /* delay (ns) for current packet from c_delay.run() */
617 * this should be set by the function that computes the extra delay
618 * applied to the packet.
619 * The code makes sure that there is no reordering and possibly
620 * bumps the output time as needed.
624 /* consumer's fields */
625 const char * cons_ifname;
626 uint64_t rx ALIGN_CACHE; /* rx counter */
627 uint64_t cons_head; /* cached copy */
628 uint64_t cons_tail; /* cached copy */
629 uint64_t cons_now; /* most recent producer timestamp */
630 uint64_t rx_wait; /* stats */
633 volatile uint64_t _tail ALIGN_CACHE ; /* producer writes here */
634 volatile uint64_t _head ALIGN_CACHE ; /* consumer reads from here */
640 pthread_t cons_tid; /* main thread */
641 pthread_t prod_tid; /* producer thread */
644 int cons_core; /* core for cons() */
645 int prod_core; /* core for prod() */
647 struct nm_desc *pa; /* netmap descriptor */
653 #define NS_IN_S (1000000000ULL) // nanoseconds
654 #define TIME_UNITS NS_IN_S
655 /* set the thread affinity. */
660 struct sched_param p;
665 /* Set thread affinity affinity.*/
667 CPU_SET(i, &cpumask);
669 if (pthread_setaffinity_np(pthread_self(), sizeof(cpuset_t), &cpumask) != 0) {
670 WWW("Unable to set affinity: %s", strerror(errno));
672 if (setpriority(PRIO_PROCESS, 0, -10)) {; // XXX not meaningful
673 WWW("Unable to set priority: %s", strerror(errno));
675 bzero(&p, sizeof(p));
676 p.sched_priority = 10; // 99 on linux ?
677 // use SCHED_RR or SCHED_FIFO
678 if (sched_setscheduler(0, SCHED_RR, &p)) {
679 WWW("Unable to set scheduler: %s", strerror(errno));
686 * set the timestamp from the clock, subtract t0
689 set_tns_now(uint64_t *now, uint64_t t0)
693 clock_gettime(CLOCK_REALTIME, &t); // XXX precise on FreeBSD ?
694 *now = (uint64_t)(t.tv_nsec + NS_IN_S * t.tv_sec);
700 /* compare two timestamps */
701 static inline int64_t
702 ts_cmp(uint64_t a, uint64_t b)
704 return (int64_t)(a - b);
707 /* create a packet descriptor */
708 static inline struct q_pkt *
709 pkt_at(struct _qs *q, uint64_t ofs)
711 return (struct q_pkt *)(q->buf + ofs);
716 * we have already checked for room and prepared p->next
721 struct q_pkt *p = pkt_at(q, q->prod_tail);
723 /* hopefully prefetch has been done ahead */
724 nm_pkt_copy(q->cur_pkt, (char *)(p+1), q->cur_caplen);
725 p->pktlen = q->cur_len;
726 p->pt_qout = q->qt_qout;
728 p->next = q->prod_tail + pad(q->cur_len) + sizeof(struct q_pkt);
729 ND("enqueue len %d at %d new tail %ld qout %.6f tx %.6f",
730 q->cur_len, (int)q->prod_tail, p->next,
731 1e-9*p->pt_qout, 1e-9*p->pt_tx);
732 q->prod_tail = p->next;
738 * simple handler for parameters not supplied
741 null_run_fn(struct _qs *q, struct _cfg *cfg)
751 * put packet data into the buffer.
752 * We read from the mmapped pcap file, construct header, copy
753 * the captured length of the packet and pad with zeroes.
758 struct pipe_args *pa = _pa;
759 struct _qs *q = &pa->q;
760 struct nm_pcap_file *pf = q->pcap; /* already opened by readpcap */
761 uint32_t loops, i, tot_pkts;
763 /* data plus the loop record */
765 uint64_t t_tx, tt, last_ts; /* last timestamp from trace */
768 * For speed we make sure the trace is at least some 1000 packets,
769 * so we may need to loop the trace more than once (for short traces)
771 loops = (1 + 10000 / pf->tot_pkt);
772 tot_pkts = loops * pf->tot_pkt;
773 need = loops * pf->tot_bytes_rounded + sizeof(struct q_pkt);
774 q->buf = calloc(1, need);
775 if (q->buf == NULL) {
776 D("alloc %ld bytes for queue failed, exiting",(_P64)need);
779 q->prod_head = q->prod_tail = 0;
782 pf->cur = pf->data + sizeof(struct pcap_file_header);
785 ED("--- start create %lu packets at tail %d",
786 (u_long)tot_pkts, (int)q->prod_tail);
787 last_ts = pf->first_ts; /* beginning of the trace */
789 q->qt_qout = 0; /* first packet out of the queue */
791 for (loops = 0, i = 0; i < tot_pkts && !do_abort; i++) {
792 const char *next_pkt; /* in the pcap buffer */
795 /* read values from the pcap buffer */
796 cur_ts = read_next_info(pf, 4) * NS_SCALE +
797 read_next_info(pf, 4) * pf->resolution;
798 q->cur_caplen = read_next_info(pf, 4);
799 q->cur_len = read_next_info(pf, 4);
800 next_pkt = pf->cur + q->cur_caplen;
802 /* prepare fields in q for the generator */
803 q->cur_pkt = pf->cur;
804 /* initial estimate of tx time */
805 q->cur_tt = cur_ts - last_ts;
806 // -pf->first_ts + loops * pf->total_tx_time - last_ts;
808 if ((i % pf->tot_pkt) == 0)
809 ED("insert %5d len %lu cur_tt %.6f",
810 i, (u_long)q->cur_len, 1e-9*q->cur_tt);
812 /* prepare for next iteration */
815 if (next_pkt == pf->lim) { //last pkt
816 pf->cur = pf->data + sizeof(struct pcap_file_header);
817 last_ts = pf->first_ts; /* beginning of the trace */
821 q->c_loss.run(q, &q->c_loss);
824 q->c_bw.run(q, &q->c_bw);
831 q->c_delay.run(q, &q->c_delay); /* compute delay */
832 t_tx = q->qt_qout + q->cur_delay;
833 ND(5, "tt %ld qout %ld tx %ld qt_tx %ld", tt, q->qt_qout, t_tx, q->qt_tx);
834 /* insure no reordering and spacing by transmission time */
835 q->qt_tx = (t_tx >= q->qt_tx + tt) ? t_tx : q->qt_tx + tt;
839 ND("ins %d q->prod_tail = %lu", (int)insert, (unsigned long)q->prod_tail);
842 ED("done q->prod_tail:%d",(int)q->prod_tail);
843 q->_tail = q->prod_tail; /* publish */
847 if (q->buf != NULL) {
856 * the consumer reads from the queue using head,
857 * advances it every now and then.
862 struct pipe_args *pa = _pa;
863 struct _qs *q = &pa->q;
865 uint64_t last_ts = 0;
867 /* read the start of times in q->t0 */
868 set_tns_now(&q->t0, 0);
869 /* set the time (cons_now) to clock - q->t0 */
870 set_tns_now(&q->cons_now, q->t0);
871 q->cons_head = q->_head;
872 q->cons_tail = q->_tail;
873 while (!do_abort) { /* consumer, infinite */
874 struct q_pkt *p = pkt_at(q, q->cons_head);
876 __builtin_prefetch (q->buf + p->next);
878 if (q->cons_head == q->cons_tail) { //reset record
879 ND("Transmission restarted");
881 * add to q->t0 the time for the last packet
884 q->cons_head = 0; //restart from beginning of the queue
888 if (ts_cmp(p->pt_tx, q->cons_now) > 0) {
891 /* the ioctl should be conditional */
892 ioctl(pa->pb->fd, NIOCTXSYNC, 0); // XXX just in case
895 set_tns_now(&q->cons_now, q->t0);
898 /* XXX copy is inefficient but simple */
900 if (nm_inject(pa->pb, (char *)(p + 1), p->pktlen) == 0 ||
901 pending > q->burst) {
902 RD(1, "inject failed len %d now %ld tx %ld h %ld t %ld next %ld",
903 (int)p->pktlen, (u_long)q->cons_now, (u_long)p->pt_tx,
904 (u_long)q->_head, (u_long)q->_tail, (u_long)p->next);
905 ioctl(pa->pb->fd, NIOCTXSYNC, 0);
909 q->cons_head = p->next;
910 /* drain packets from the queue */
913 D("exiting on abort");
918 * In case of pcap file as input, the program acts in 2 different
919 * phases. It first fill the queue and then starts the cons()
922 nmreplay_main(void *_a)
924 struct pipe_args *a = _a;
925 struct _qs *q = &a->q;
926 const char *cap_fname = q->prod_ifname;
928 setaffinity(a->cons_core);
929 set_tns_now(&q->t0, 0); /* starting reference */
930 if (cap_fname == NULL) {
933 q->pcap = readpcap(cap_fname);
934 if (q->pcap == NULL) {
935 EEE("unable to read file %s", cap_fname);
939 destroy_pcap(q->pcap);
941 a->pb = nm_open(q->cons_ifname, NULL, 0, NULL);
943 EEE("cannot open netmap on %s", q->cons_ifname);
944 do_abort = 1; // XXX any better way ?
947 /* continue as cons() */
948 WWW("prepare to send packets");
951 EEE("exiting on abort");
953 if (q->pcap != NULL) {
954 destroy_pcap(q->pcap);
964 (void)sig; /* UNUSED */
966 signal(SIGINT, SIG_DFL);
975 "usage: nmreplay [-v] [-D delay] [-B {[constant,]bps|ether,bps|real,speedup}] [-L loss]\n"
976 "\t[-b burst] -i ifa-or-pcap-file -i ifb\n");
981 /*---- configuration handling ---- */
983 * support routine: split argument, returns ac and *av.
984 * av contains two extra entries, a NULL and a pointer
985 * to the entire string.
988 split_arg(const char *src, int *_ac)
990 char *my = NULL, **av = NULL, *seps = " \t\r\n,";
991 int l, i, ac; /* number of entries */
996 /* in the first pass we count fields, in the second pass
997 * we allocate the av[] array and a copy of the string
998 * and fill av[]. av[ac] = NULL, av[ac+1]
1002 ND("start pass %d: <%s>", av ? 1 : 0, my);
1004 /* trim leading separator */
1005 while (i <l && strchr(seps, src[i]))
1009 ND(" pass %d arg %d: <%s>", av ? 1 : 0, ac, src+i);
1010 if (av) /* in the second pass, set the result */
1014 while (i <l && !strchr(seps, src[i])) i++;
1016 my[i] = '\0'; /* write marker */
1018 if (!av) { /* end of first pass */
1020 av = calloc(1, (l+1) + (ac + 2)*sizeof(char *));
1021 my = (char *)&(av[ac+2]);
1027 for (i = 0; i < ac; i++) {
1028 NED("%d: <%s>", i, av[i]);
1038 * apply a command against a set of functions,
1039 * install a handler in *dst
1042 cmd_apply(const struct _cfg *a, const char *arg, struct _qs *q, struct _cfg *dst)
1048 if (arg == NULL || *arg == '\0')
1049 return 1; /* no argument may be ok */
1050 if (a == NULL || dst == NULL) {
1051 ED("program error - invalid arguments");
1054 av = split_arg(arg, &ac);
1056 return 1; /* error */
1057 for (i = 0; a[i].parse; i++) {
1058 struct _cfg x = a[i];
1059 const char *errmsg = x.optarg;
1064 bzero(&x.d, sizeof(x.d));
1065 ND("apply %s to %s", av[0], errmsg);
1066 ret = x.parse(q, &x, ac, av);
1067 if (ret == 2) /* not recognised */
1070 ED("invalid arguments: need '%s' have '%s'",
1078 ED("arguments %s not recognised", arg);
1083 static struct _cfg delay_cfg[];
1084 static struct _cfg bw_cfg[];
1085 static struct _cfg loss_cfg[];
1087 static uint64_t parse_bw(const char *arg);
1090 * prodcons [options]
1091 * accept separate sets of arguments for the two directions
1096 add_to(const char ** v, int l, const char *arg, const char *msg)
1098 for (; l > 0 && *v != NULL ; l--, v++);
1100 ED("%s %s", msg, arg);
1107 main(int argc, char **argv)
1112 struct pipe_args bp[N_OPTS];
1113 const char *d[N_OPTS], *b[N_OPTS], *l[N_OPTS], *q[N_OPTS], *ifname[N_OPTS], *m[N_OPTS];
1114 const char *pcap_file[N_OPTS];
1115 int cores[4] = { 2, 8, 4, 10 }; /* default values */
1117 bzero(&bp, sizeof(bp)); /* all data initially go here */
1118 bzero(d, sizeof(d));
1119 bzero(b, sizeof(b));
1120 bzero(l, sizeof(l));
1121 bzero(q, sizeof(q));
1122 bzero(m, sizeof(m));
1123 bzero(ifname, sizeof(ifname));
1124 bzero(pcap_file, sizeof(pcap_file));
1127 /* set default values */
1128 for (i = 0; i < N_OPTS; i++) {
1129 struct _qs *q = &bp[i].q;
1132 q->c_delay.optarg = "0";
1133 q->c_delay.run = null_run_fn;
1134 q->c_loss.optarg = "0";
1135 q->c_loss.run = null_run_fn;
1136 q->c_bw.optarg = "0";
1137 q->c_bw.run = null_run_fn;
1141 // B bandwidth in bps
1142 // D delay in seconds
1143 // L loss probability
1151 while ( (ch = getopt(argc, argv, "B:C:D:L:b:f:i:vw:")) != -1) {
1154 D("bad option %c %s", ch, optarg);
1158 case 'C': /* CPU placement, up to 4 arguments */
1161 char **av = split_arg(optarg, &ac);
1162 if (ac == 1) { /* sequential after the first */
1163 cores[0] = atoi(av[0]);
1164 cores[1] = cores[0] + 1;
1165 cores[2] = cores[1] + 1;
1166 cores[3] = cores[2] + 1;
1167 } else if (ac == 2) { /* two sequential pairs */
1168 cores[0] = atoi(av[0]);
1169 cores[1] = cores[0] + 1;
1170 cores[2] = atoi(av[1]);
1171 cores[3] = cores[2] + 1;
1172 } else if (ac == 4) { /* four values */
1173 cores[0] = atoi(av[0]);
1174 cores[1] = atoi(av[1]);
1175 cores[2] = atoi(av[2]);
1176 cores[3] = atoi(av[3]);
1178 ED(" -C accepts 1, 2 or 4 comma separated arguments");
1186 case 'B': /* bandwidth in bps */
1187 add_to(b, N_OPTS, optarg, "-B too many times");
1190 case 'D': /* delay in seconds (float) */
1191 add_to(d, N_OPTS, optarg, "-D too many times");
1194 case 'L': /* loss probability */
1195 add_to(l, N_OPTS, optarg, "-L too many times");
1198 case 'b': /* burst */
1199 bp[0].q.burst = atoi(optarg);
1202 case 'f': /* pcap_file */
1203 add_to(pcap_file, N_OPTS, optarg, "-f too many times");
1205 case 'i': /* interface */
1206 add_to(ifname, N_OPTS, optarg, "-i too many times");
1212 bp[0].wait_link = atoi(optarg);
1222 * consistency checks for common arguments
1223 * if pcap file has been provided we need just one interface, two otherwise
1225 if (!pcap_file[0]) {
1226 ED("missing pcap file");
1230 ED("missing interface");
1233 if (bp[0].q.burst < 1 || bp[0].q.burst > 8192) {
1234 WWW("invalid burst %d, set to 1024", bp[0].q.burst);
1235 bp[0].q.burst = 1024; // XXX 128 is probably better
1237 if (bp[0].wait_link > 100) {
1238 ED("invalid wait_link %d, set to 4", bp[0].wait_link);
1239 bp[0].wait_link = 4;
1242 bp[0].q.prod_ifname = pcap_file[0];
1243 bp[0].q.cons_ifname = ifname[0];
1245 /* assign cores. prod and cons work better if on the same HT */
1246 bp[0].cons_core = cores[0];
1247 bp[0].prod_core = cores[1];
1248 ED("running on cores %d %d %d %d", cores[0], cores[1], cores[2], cores[3]);
1250 /* apply commands */
1251 for (i = 0; i < N_OPTS; i++) { /* once per queue */
1252 struct _qs *q = &bp[i].q;
1253 err += cmd_apply(delay_cfg, d[i], q, &q->c_delay);
1254 err += cmd_apply(bw_cfg, b[i], q, &q->c_bw);
1255 err += cmd_apply(loss_cfg, l[i], q, &q->c_loss);
1258 pthread_create(&bp[0].cons_tid, NULL, nmreplay_main, (void*)&bp[0]);
1259 signal(SIGINT, sigint_h);
1262 struct _qs olda = bp[0].q;
1263 struct _qs *q0 = &bp[0].q;
1266 ED("%ld -> %ld maxq %d round %ld",
1267 (_P64)(q0->rx - olda.rx), (_P64)(q0->tx - olda.tx),
1268 q0->rx_qmax, (_P64)q0->prod_max_gap
1270 ED("plr nominal %le actual %le",
1271 (double)(q0->c_loss.d[0])/(1<<24),
1272 q0->c_loss.d[1] == 0 ? 0 :
1273 (double)(q0->c_loss.d[2])/q0->c_loss.d[1]);
1274 bp[0].q.rx_qmax = (bp[0].q.rx_qmax * 7)/8; // ewma
1275 bp[0].q.prod_max_gap = (bp[0].q.prod_max_gap * 7)/8; // ewma
1277 D("exiting on abort");
1283 /* conversion factor for numbers.
1284 * Each entry has a set of characters and conversion factor,
1285 * the first entry should have an empty string and default factor,
1286 * the final entry has s = NULL.
1288 struct _sm { /* string and multiplier */
1294 * parse a generic value
1297 parse_gen(const char *arg, const struct _sm *conv, int *err)
1308 d = strtod(arg, &ep);
1309 if (ep == arg) { /* no value */
1310 ED("bad argument %s", arg);
1313 /* special case, no conversion */
1314 if (conv == NULL && *ep == '\0')
1316 ND("checking %s [%s]", arg, ep);
1317 for (;conv->s; conv++) {
1318 if (strchr(conv->s, *ep))
1322 *err = 1; /* unrecognised */
1327 ND("scale is %s %lf", conv->s, conv->m);
1328 d *= conv->m; /* apply default conversion */
1330 ND("returning %lf", d);
1334 #define U_PARSE_ERR ~(0ULL)
1336 /* returns a value in nanoseconds */
1338 parse_time(const char *arg)
1341 {"", 1000000000 /* seconds */},
1342 {"n", 1 /* nanoseconds */}, {"u", 1000 /* microseconds */},
1343 {"m", 1000000 /* milliseconds */}, {"s", 1000000000 /* seconds */},
1344 {NULL, 0 /* seconds */}
1347 uint64_t ret = (uint64_t)parse_gen(arg, a, &err);
1348 return err ? U_PARSE_ERR : ret;
1353 * parse a bandwidth, returns value in bps or U_PARSE_ERR if error.
1356 parse_bw(const char *arg)
1359 {"", 1}, {"kK", 1000}, {"mM", 1000000}, {"gG", 1000000000}, {NULL, 0}
1362 uint64_t ret = (uint64_t)parse_gen(arg, a, &err);
1363 return err ? U_PARSE_ERR : ret;
1368 * For some function we need random bits.
1369 * This is a wrapper to whatever function you want that returns
1370 * 24 useful random bits.
1373 #include <math.h> /* log, exp etc. */
1374 static inline uint64_t
1375 my_random24(void) /* 24 useful bits */
1377 return random() & ((1<<24) - 1);
1381 /*-------------- user-configuration -----------------*/
1383 #if 0 /* start of comment block */
1385 Here we place the functions to implement the various features
1386 of the system. For each feature one should define a struct _cfg
1387 (see at the beginning for definition) that refers a *_parse() function
1388 to extract values from the command line, and a *_run() function
1389 that is invoked on each packet to implement the desired function.
1391 Examples of the two functions are below. In general:
1393 - the *_parse() function takes argc/argv[], matches the function
1394 name in argv[0], extracts the operating parameters, allocates memory
1395 if needed, and stores them in the struct _cfg.
1396 Return value is 2 if argv[0] is not recosnised, 1 if there is an
1397 error in the arguments, 0 if all ok.
1399 On the command line, argv[] is a single, comma separated argument
1400 that follow the specific option eg -D constant,20ms
1402 struct _cfg has some preallocated space (e.g an array of uint64_t) so simple
1403 function can use that without having to allocate memory.
1405 - the *_run() function takes struct _q *q and struct _cfg *cfg as arguments.
1406 *q contains all the informatio that may be possibly needed, including
1407 those on the packet currently under processing.
1408 The basic values are the following:
1410 char * cur_pkt points to the current packet (linear buffer)
1411 uint32_t cur_len; length of the current packet
1412 the functions are not supposed to modify these values
1414 int cur_drop; true if current packet must be dropped.
1415 Must be set to non-zero by the loss emulation function
1417 uint64_t cur_delay; delay in nanoseconds for the current packet
1418 Must be set by the delay emulation function
1420 More sophisticated functions may need to access other fields in *q,
1421 see the structure description for that.
1423 When implementing a new function for a feature (e.g. for delay,
1424 bandwidth, loss...) the struct _cfg should be added to the array
1425 that contains all possible options.
1427 --- Specific notes ---
1429 DELAY emulation -D option_arguments
1431 If the option is not supplied, the system applies 0 extra delay
1433 The resolution for times is 1ns, the precision is load dependent and
1434 generally in the order of 20-50us.
1435 Times are in nanoseconds, can be followed by a character specifying
1436 a different unit e.g.
1443 Currently implemented options:
1445 constant,t constant delay equal to t
1447 uniform,tmin,tmax uniform delay between tmin and tmax
1449 exp,tavg,tmin exponential distribution with average tavg
1450 and minimum tmin (corresponds to an exponential
1451 distribution with argument 1/(tavg-tmin) )
1454 LOSS emulation -L option_arguments
1456 Loss is expressed as packet or bit error rate, which is an absolute
1457 number between 0 and 1 (typically small).
1459 Currently implemented options
1461 plr,p uniform packet loss rate p, independent
1464 burst,p,lmin,lmax burst loss with burst probability p and
1465 burst length uniformly distributed between
1468 ber,p uniformly distributed bit error rate p,
1469 so actual loss prob. depends on size.
1471 BANDWIDTH emulation -B option_arguments
1473 Bandwidths are expressed in bits per second, can be followed by a
1474 character specifying a different unit e.g.
1477 k/K kbits/s (10^3 bits/s)
1478 m/M mbits/s (10^6 bits/s)
1479 g/G gbits/s (10^9 bits/s)
1481 Currently implemented options
1483 const,b constant bw, excluding mac framing
1484 ether,b constant bw, including ethernet framing
1485 (20 bytes framing + 4 bytes crc)
1486 real,[scale] use real time, optionally with a scaling factor
1488 #endif /* end of comment block */
1491 * Configuration options for delay
1494 /* constant delay, also accepts just a number */
1496 const_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1501 if (strncmp(av[0], "const", 5) != 0 && ac > 1)
1502 return 2; /* unrecognised */
1504 return 1; /* error */
1505 delay = parse_time(av[ac - 1]);
1506 if (delay == U_PARSE_ERR)
1507 return 1; /* error */
1509 return 0; /* success */
1512 /* runtime function, store the delay into q->cur_delay */
1514 const_delay_run(struct _qs *q, struct _cfg *arg)
1516 q->cur_delay = arg->d[0]; /* the delay */
1521 uniform_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1523 uint64_t dmin, dmax;
1526 if (strcmp(av[0], "uniform") != 0)
1527 return 2; /* not recognised */
1529 return 1; /* error */
1530 dmin = parse_time(av[1]);
1531 dmax = parse_time(av[2]);
1532 if (dmin == U_PARSE_ERR || dmax == U_PARSE_ERR || dmin > dmax)
1534 D("dmin %ld dmax %ld", (_P64)dmin, (_P64)dmax);
1537 dst->d[2] = dmax - dmin;
1542 uniform_delay_run(struct _qs *q, struct _cfg *arg)
1544 uint64_t x = my_random24();
1545 q->cur_delay = arg->d[0] + ((arg->d[2] * x) >> 24);
1546 #if 0 /* COMPUTE_STATS */
1547 #endif /* COMPUTE_STATS */
1552 * exponential delay: Prob(delay = x) = exp(-x/d_av)
1553 * gives a delay between 0 and infinity with average d_av
1554 * The cumulative function is 1 - d_av exp(-x/d_av)
1556 * The inverse function generates a uniform random number p in 0..1
1557 * and generates delay = (d_av-d_min) * -ln(1-p) + d_min
1559 * To speed up behaviour at runtime we tabulate the values
1563 exp_delay_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1565 #define PTS_D_EXP 512
1566 uint64_t i, d_av, d_min, *t; /*table of values */
1569 if (strcmp(av[0], "exp") != 0)
1570 return 2; /* not recognised */
1572 return 1; /* error */
1573 d_av = parse_time(av[1]);
1574 d_min = parse_time(av[2]);
1575 if (d_av == U_PARSE_ERR || d_min == U_PARSE_ERR || d_av < d_min)
1576 return 1; /* error */
1578 dst->arg_len = PTS_D_EXP * sizeof(uint64_t);
1579 dst->arg = calloc(1, dst->arg_len);
1580 if (dst->arg == NULL)
1581 return 1; /* no memory */
1582 t = (uint64_t *)dst->arg;
1583 /* tabulate -ln(1-n)*delay for n in 0..1 */
1584 for (i = 0; i < PTS_D_EXP; i++) {
1585 double d = -log2 ((double)(PTS_D_EXP - i) / PTS_D_EXP) * d_av + d_min;
1587 ND(5, "%ld: %le", i, d);
1593 exp_delay_run(struct _qs *q, struct _cfg *arg)
1595 uint64_t *t = (uint64_t *)arg->arg;
1596 q->cur_delay = t[my_random24() & (PTS_D_EXP - 1)];
1597 RD(5, "delay %lu", (_P64)q->cur_delay);
1602 /* unused arguments in configuration */
1603 #define _CFG_END NULL, 0, {0}, {0}
1605 static struct _cfg delay_cfg[] = {
1606 { const_delay_parse, const_delay_run,
1607 "constant,delay", _CFG_END },
1608 { uniform_delay_parse, uniform_delay_run,
1609 "uniform,dmin,dmax # dmin <= dmax", _CFG_END },
1610 { exp_delay_parse, exp_delay_run,
1611 "exp,dmin,davg # dmin <= davg", _CFG_END },
1612 { NULL, NULL, NULL, _CFG_END }
1615 /* standard bandwidth, also accepts just a number */
1617 const_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1622 if (strncmp(av[0], "const", 5) != 0 && ac > 1)
1623 return 2; /* unrecognised */
1625 return 1; /* error */
1626 bw = parse_bw(av[ac - 1]);
1627 if (bw == U_PARSE_ERR) {
1628 return (ac == 2) ? 1 /* error */ : 2 /* unrecognised */;
1631 return 0; /* success */
1635 /* runtime function, store the delay into q->cur_delay */
1637 const_bw_run(struct _qs *q, struct _cfg *arg)
1639 uint64_t bps = arg->d[0];
1640 q->cur_tt = bps ? 8ULL* TIME_UNITS * q->cur_len / bps : 0 ;
1644 /* ethernet bandwidth, add 672 bits per packet */
1646 ether_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1651 if (strcmp(av[0], "ether") != 0)
1652 return 2; /* unrecognised */
1654 return 1; /* error */
1655 bw = parse_bw(av[ac - 1]);
1656 if (bw == U_PARSE_ERR)
1657 return 1; /* error */
1659 return 0; /* success */
1663 /* runtime function, add 20 bytes (framing) + 4 bytes (crc) */
1665 ether_bw_run(struct _qs *q, struct _cfg *arg)
1667 uint64_t bps = arg->d[0];
1668 q->cur_tt = bps ? 8ULL * TIME_UNITS * (q->cur_len + 24) / bps : 0 ;
1672 /* real bandwidth, plus scaling factor */
1674 real_bw_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1679 if (strcmp(av[0], "real") != 0)
1680 return 2; /* unrecognised */
1681 if (ac > 2) { /* second argument is optional */
1682 return 1; /* error */
1683 } else if (ac == 1) {
1687 scale = parse_gen(av[ac-1], NULL, &err);
1688 if (err || scale <= 0 || scale > 1000)
1691 ED("real -> scale is %.6f", scale);
1693 return 0; /* success */
1697 real_bw_run(struct _qs *q, struct _cfg *arg)
1699 q->cur_tt /= arg->f[0];
1703 static struct _cfg bw_cfg[] = {
1704 { const_bw_parse, const_bw_run,
1705 "constant,bps", _CFG_END },
1706 { ether_bw_parse, ether_bw_run,
1707 "ether,bps", _CFG_END },
1708 { real_bw_parse, real_bw_run,
1709 "real,scale", _CFG_END },
1710 { NULL, NULL, NULL, _CFG_END }
1717 const_plr_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1723 if (strcmp(av[0], "plr") != 0 && ac > 1)
1724 return 2; /* unrecognised */
1726 return 1; /* error */
1727 // XXX to be completed
1728 plr = parse_gen(av[ac-1], NULL, &err);
1729 if (err || plr < 0 || plr > 1)
1731 dst->d[0] = plr * (1<<24); /* scale is 16m */
1732 if (plr != 0 && dst->d[0] == 0)
1733 ED("WWW warning, rounding %le down to 0", plr);
1734 return 0; /* success */
1738 const_plr_run(struct _qs *q, struct _cfg *arg)
1741 uint64_t r = my_random24();
1742 q->cur_drop = r < arg->d[0];
1743 #if 1 /* keep stats */
1745 arg->d[2] += q->cur_drop;
1752 * For BER the loss is 1- (1-ber)**bit_len
1753 * The linear approximation is only good for small values, so we
1754 * tabulate (1-ber)**len for various sizes in bytes
1757 const_ber_parse(struct _qs *q, struct _cfg *dst, int ac, char *av[])
1759 double ber, ber8, cur;
1762 const uint32_t mask = (1<<24) - 1;
1765 if (strcmp(av[0], "ber") != 0)
1766 return 2; /* unrecognised */
1768 return 1; /* error */
1769 ber = parse_gen(av[ac-1], NULL, &err);
1770 if (err || ber < 0 || ber > 1)
1772 dst->arg_len = MAX_PKT * sizeof(uint32_t);
1773 plr = calloc(1, dst->arg_len);
1775 return 1; /* no memory */
1778 ber8 *= ber8; /* **2 */
1779 ber8 *= ber8; /* **4 */
1780 ber8 *= ber8; /* **8 */
1782 for (i=0; i < MAX_PKT; i++, cur *= ber8) {
1783 plr[i] = (mask + 1)*(1 - cur);
1787 if (i>= 60) // && plr[i] < mask/2)
1788 RD(50,"%4d: %le %ld", i, 1.0 - cur, (_P64)plr[i]);
1791 dst->d[0] = ber * (mask + 1);
1792 return 0; /* success */
1796 const_ber_run(struct _qs *q, struct _cfg *arg)
1799 uint64_t r = my_random24();
1800 uint32_t *plr = arg->arg;
1803 RD(5, "pkt len %d too large, trim to %d", l, MAX_PKT-1);
1806 q->cur_drop = r < plr[l];
1807 #if 1 /* keep stats */
1809 arg->d[2] += q->cur_drop;
1814 static struct _cfg loss_cfg[] = {
1815 { const_plr_parse, const_plr_run,
1816 "plr,prob # 0 <= prob <= 1", _CFG_END },
1817 { const_ber_parse, const_ber_run,
1818 "ber,prob # 0 <= prob <= 1", _CFG_END },
1819 { NULL, NULL, NULL, _CFG_END }