forked from MatiasElo/odp
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathCHANGELOG
4538 lines (3712 loc) · 194 KB
/
CHANGELOG
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
== OpenDataPlane (1.24.0.0)
=== Summary of Changes
This release introduces a new stash API module. The other main API additions are
pool buffer caching configuration and packet IO link information. The release
also includes several smaller API improvements and clarifications.
=== API
==== Common
* Added missing const qualifiers
Some API calls missed const qualifiers on read-only data pointers.
* Improved Doxygen module descriptions
* Use param_init functions for parameter defaults
When available, parameter init functions must be used to initialize parameters
into their default values.
=== Align
* Added `ODP_CACHE_LINE_ROUNDUP` macro
Added macro for rounding up a value to the next multiple of cache line size.
This round up is needed e.g. when selecting buffer sizes so that false sharing
is avoided.
==== CPU
* Make supporting CPU frequency and cycle counter optional
CPU frequencies or CPU cycle counter may not be available on all HW/SW
platforms. Zero is returned if those cannot be read.
==== Feature
* Added feature bits `stash` and `compress` into `odp_feature_t`.
==== Packet
* Clarify packet length function argument definitions
Modify documentations of functions, which decrease packet length, to clearly
state what are the allowed values for length argument. This is done to avoid
creating zero length packets which are not allowed by the packet API.
* Added `odp_packet_input_set()` function
An application may use this for testing or other purposes, when perception of
the packet input interface need to be changed.
==== Packet I/O
* Added `odp_pktio_link_info()` function for reading link status information
** Autonegotiation mode (unknown/enabled/disabled)
** Duplex mode (unknown/half duplex/full duplex)
** Flow control (unknown/on/off)
** Link status (unknown/up/down)
** Media (media type as string)
** Speed (unknown/Mbps)
* Modified `odp_pktio_link_status()` to return `odp_pktio_link_status_t` enum
(backward compatible values)
==== Pool
* Added `cache_size` parameters to `odp_pool_capability_t` and `odp_pool_param_t`
Added thread local cache size parameter and capability. This allows application
to control thread local caching and prepare large enough pool when
implementation caches events per thread. The default value is implementation
specific for backwards compatibility.
* Removed default value of packet `max_len` from `odp_pool_param_t`
The default value is implementation specific and may not be equal to the maximum
capability.
* Added packet data `align` parameter to `odp_pool_param_t`
Added packet pool parameter to request minimum data alignment for user allocated
packets. When user allocates a new packet and fills in protocol headers, it's
convenient that data alignment does not need to be checked (and tuned) on each
allocated packet.
==== Queue
* Unify `max_size capa` specification for all plain queue types
Specify queue maximum size capability the same way for all non-blocking levels
(`ODP_BLOCKING`, `ODP_NONBLOCKING_LF` and `ODP_NONBLOCKING_WF`). Max_size value
of zero means that there is no size limit.
* Clarify that queue operations include memory barriers
Clarify that queue enqueue operations include memory barrier of release
semantics and queue dequeue operations include acquire semantics.
==== Random
* Clarify how much data `odp_random_data()` and `odp_random_test_data()` output on success.
It may not be possible for random generator functions to return requested number
of bytes. Clarify that implementation is not required to loop until `len` bytes
are available. Instead application should contain such logic.
==== Scheduler
* Clarify synchronization of store operations during atomic context
Stores performed while holding an atomic scheduling context are seen correctly
by other thread when they hold the same context later on. This is guaranteed
also when queue enqueue is not used in between.
* Clarify that schedule operations include memory barriers
Clarify that event schedule operations include memory barrier of acquire
semantics.
==== Shared Memory
* Add `ODP_SHM_HW_ACCESS` flag
This can be used to memory allocations where both CPUs and HW accelerators
access the same memory area. These HW accelerators may be programmed outside of
ODP APIs, but the memory is reserved and shared normally inside/between ODP
applications.
==== Stash
* Added new stash API module
Application needs often store object handles for later usage. From current APIs,
e.g. buffers and queues could be used to store these handles, but buffers
consume more memory than is necessary and event queues are not needed for this
simple use case. This new API maybe implemented e.g. as a ring of object handles
in memory, or with a HW buffer manager.
==== Time
* Added `odp_time_local_ns()` and `odp_time_global_ns()` functions for acquiring
current time stamp in nanoseconds
Added functions to get the current local/global
time stamp directly in nanoseconds. For example, `odp_time_local_ns()` is
equivalent of calling `odp_time_to_ns(odp_time_local())`. This simplifies use
cases where time will be always converted to nanoseconds. However, when time API
performance is important conversions to nanoseconds should be avoided or
minimized.
==== Timer
* Clarify that `odp_timeout_tick()` returns original expiration time
Specification was open if returned expiration time is the original or actual
expiration time. HW based implementations will not likely modify timeout event
with actual expiration time. Also original expiration time is more valuable to
an application as it can be used to calculate e.g. the next period.
* Add resolution in hertz parameter `res_hz` into `odp_timer_pool_param_t`
Added option to specify timer pool resolution in hertz. High resolution values
in nanoseconds result small numbers and thus poor granularity. Hertz offers
better granularity with high resolution values. User gives resolution either in
nanoseconds or hertz, and sets the other parameter to zero.
==== Traffic Manager
* Add missing handle debug functions
Traffic Manager API defines all types as platform specific, yet unit tests
expect to be able to print them. Therefore introduce u64 debug print conversion
functions for all TM types: `odp_tm_to_u64()`, `odp_tm_queue_to_u64()`,
`odp_tm_node_to_u64()`, `odp_tm_shaper_to_u64()`, `odp_tm_sched_to_u64()`,
`odp_tm_threshold_to_u64()`, `odp_tm_wred_to_u64()`
* Info structures are written only on success
Clarify that info structures (`odp_tm_node_info_t`, `odp_tm_node_fanin_info_t`,
`odp_tm_queue_info_t`, `odp_tm_query_info_t`) are written only on success.
==== Version
* Added `ODP_VERSION_API` define and `ODP_VERSION_API_NUM` macro
Added a macro and version number defines for easier comparison of API version
numbers.
=== Validation Tests
==== Buffer
* Rewrote buffer tests for improved coverage
* Allow allocated buffer size to be larger than requested
==== Classification
* Fix duplicate global variable definition
* Use `odp_schedule_wait_time()` correctly
==== Crypto
* Fix var len array scope
==== Init
* Add tests for new `compress` and `stash` feature bits
* Improved log prints
==== IPSec
* Fixed invalid allocation of zero length test packet
* Fixed invalid test for user pointer value
==== Packet
* Add max pools test
* Add packet alloc align test
* Fix max_num expectations
* Prevent test trying to allocate zero length packets
* Remove pools from suite init
* Remove reset test packet from suite init
* Rename default pool
* Use common pool capability
==== Packet I/O
* Check parser flags on receive
* Check pktio index
* Decrease timeout in `odp_pktin_recv_tmo()` test
* Make `pktio_check_start_stop()` test conditional
* Remove unnecessary test start-up input flushes
* Test `odp_packet_input_set()`
* Test user pointer on receive
* Do no attempt to continue with invalid queue handle
==== Pool
* Add pool cache size tests
* Add test for packet pool seg_len parameter
==== Queue
* Lockfree queue max_size may be zero
==== Scheduler
* Add new stress test
* Fix plain+sched test
* Test `odp_schedule_group_create()` with non-zero mask
==== Shared Memory
* Add reserve flag tests
* Fix printf format types for pointers
==== Stash
* Add tests for the new API
==== System
* Add test for `ODP_CACHE_LINE_ROUNDUP`
* Add version macro test
* Call version string functions
* Cpu cycle counter may not be supported
* Make `odp_cpu_hz_max()` tests conditional
==== Timer
* Timeout tick equals requested tick
* Always initialize `odp_timer_pool_param_t` contents
==== Traffic Manager
* Fix shaper profile parameter check
* Init structs between tests
=== Example Applications
==== Bench_packet
* Added tests for missing packet functions
==== Hello
* Removed `-c` command line option
==== L2fwd
* Added number of packets option `-n`
* Added packet copy option `-p`
* Added pool per interface option `-y`
==== Packet_dump
* Added VLAN support
==== Packet_gen
* Added new simple packet generator test application
==== Sched_latency
* Added option for selecting event forwarding mode `-f`
* Increased the number of warm-up and scheduling rounds
==== Sched_perf
* Added data touch options `-n` and `-m`
* Added queue context data touch options `-k` and `-l`
* Improved test reliability
==== Switch
* Added 5 minute aging time to MAC table entries
* Added signal handler for SIGINT
* Added support for detecting invalid and broadcast ethernet addresses
* Improved packet drop statistics printing
==== Timer_accuracy
* Added burst gap option `-g`
* Added mode option `-m`
* Added option `-e` to retry on too early error
* Added output file option `-o`
* Added timer burst option `-b`
=== Implementation Improvements
==== GCC 10 support
Fixed issues reported by GCC 10. The code base builds now with GCC 10
also when LTO is enabled.
==== Add configure option for setting path to the default config file
Added `--with-config-file=FILE` configuration option for setting path to the
default configuration file. The default configuration file has to include all
configuration options.
=== Bug Fixes
==== Numbered Bugs / Issues
* Fixed: https://github.com/OpenDataPlane/odp/issues/796[Issue 796]
seg[0].data MUST return to its initial value on odp_packet_reset
* Fixed: https://github.com/OpenDataPlane/odp/issues/826[Issue 826]
max_size requires clarification for ODP_NONBLOCKING_LF and ODP_NONBLOCKING_WF
* Fixed: https://github.com/OpenDataPlane/odp/issues/915[Issue 915]
SIGSEGV: example/sysinfo (raspberry Pi 3B+, arm7, odp-linux, gcc 8.2.0)
* Fixed: https://github.com/OpenDataPlane/odp/issues/930[Issue 930]
Build failing with GCC 9.2
* Fixed: https://github.com/OpenDataPlane/odp/issues/959[Issue 959]
ODP build fails with GCC 10.1
==== Unnumbered Bugs / Issues
* Fixed: crypto: fix session allocation when out of sessions
* Fixed: dpdk: DPDK renamed protocol structs
* Fixed: dpdk: fix rx/tx checksum offload
* Fixed: fix print failures on 32-bit systems
* Fixed: pool: fix overflow when creating a huge packet pool
* Fixed: pool: rename pool global variable
* Fixed: sched scalable: fix pktio ingress queue polling dead lock
* Fixed: test: fix global variables that are defined multiple times
* Fixed: timer: fix timer pool create sync with inline timer scan
== OpenDataPlane (1.23.0.0)
=== Summary of Changes
The ODP API changes in this release are related to the classifier module.
The implementation changes include bug fixes (classifier, socket pktio),
configurability improvements (inline timer), new packet segmentation
implementation, and performance improvements (pool).
=== API
==== Classifier
The PMR term documentation was not explicit about endianness of value and mask
fields. Most terms assumed CPU endian, but terms with larger data sizes assumed
big endian (MAC, IPv6 address and custom).
Term specification was harmonized so that all terms expect value/mask data to be
in big-endian format, have fixed size, and allow free memory alignment. Packet
length term is an exception to this as it does not represent a field in a
packet.
Added new `ODP_PMR_CUSTOM_L3` term to match custom layer 3 protocol fields. PMR
offset refers to the start of layer 3 in the packet. Other PMR rules (e.g. L2
classification rules) may precede custom L3 rules.
=== Helper
Duplicate `ODPH_UNUSED` macro has been removed. `ODP_UNUSED` should be used
instead.
=== Validation Tests
==== Common
Improved test result output when some tests are inactive (skipped due to missing
capability). Now inactive tests are listed by default in the test suite results.
==== Classifier
Cleaned up validation test code. Classifier implementation missed reporting some
capabilities, tests didn't check those capabilities and they were tested. Source
IPv4 term test was missing.
Added serial PMR test, which tests series of PMR and CoS:
* From default CoS to dest IPv4 CoS
* From dest IPv4 CoS to dest UDP CoS
Added parallel PMR test, which test serial and parallel PMR and CoS:
* From default CoS to dest IPv4 CoS
* From dest IPv4 CoS to a parallel UDP CoS per destination port number
==== Scheduler
Added new validation tests to verify that packet order is maintained when events
are enqueued and dequeued to/from a plain queue while maintaining atomic/ordered
scheduling context.
==== Timer
Added private timer pool test, which creates a timer pool with the `priv` flag
set. The same thread calls schedule / queue_deq that created the pool.
=== Example Applications
==== timer_perf
Added new test application to measure schedule call CPU cycle consumption with
various timer pool parameter combinations. This measurement is mostly
interesting with software-based timer implementations, where timers may be
polled from the schedule call.
==== New odp_ping application
This application replies to IPv4 ping requests. It can be used to test
connectivity with standard ping utility. ARP table needs to be setup manually on
the sender side as the application does not reply to ARP requests.
==== odp_classifier
Added source CoS name into the parameter list of `-p` option. This enables
linking classification rules together. When a source CoS is not defined, the
default CoS is used as the source CoS.
Option `-p` parameter list format is now:
<term>:<xxx>:<yyy>:<src_cos>:<dst_cos>
Where `<src_cos>` is optional and number of "xxx", "yyy", etc. parameters is
term depend.
Added `-v` option which prints received packet with CoS queue
name. This can be used for debugging classification rules.
Added support for `ODP_PMR_VLAN_ID_0`, `ODP_PMR_ETHTYPE_0`, `ODP_PMR_CUSTOM_L3`,
`ODP_PMR_ETHTYPE_X`, `ODP_PMR_VLAN_ID_X`, `ODP_PMR_UDP_DPORT`,
`ODP_PMR_UDP_SPORT`, `ODP_PMR_TCP_DPORT`, and `ODP_PMR_TCP_SPORT` rules.
==== timer_accuracy
Fix bug in timer start offset calculation. Test results were offset by current
local time value.
Added delay and extra schedule calls to ensure that (software) timer
implementation has passed its initial state before setting up timers.
Added `-f` option to control offset to the first timer. This can be used e.g. to
avoid best/worst case synchronization of timers to timer tick boundaries /
resolution.
==== packet_dump
Added ICMP support. Print ICMP offset and ICMPv4 type/code. This helps to verify
that ping requests are received.
==== bench_packet
Added missing tests for the following packet functions:
* `odp_packet_data_seg_len()`
* `odp_packet_free_sp()`
* `odp_packet_from_event_multi()`
* `odp_packet_to_event_multi()`
* `odp_packet_subtype()`
* `odp_packet_parse()`
* `odp_packet_parse_multi()`
=== Implementation
==== Classifier
Cleaned up implementation. Fixed endianness.
==== Inline Timer
Cleaned up code. Fixed accuracy issue with high resolution (<100us) timer pools.
Added configuration option `inline_poll_interval_nsec` to select default poll
interval in nsec.
Added configure file option for inline timer (`inline_thread_type`) to select if
control threads poll shared timer pools or not. Control threads still poll their
private pools. With this user can configure control and worker threads to use
separate timer pools.
==== Packet I/O
Enable explicit pktio type definition. The pktio type is selected by adding
pktio_type prefix in front of device name separated by a colon
(<pktio_type>:<if_name>).
The socket mmsg pktio implementation has been refactored and performance has
been improved.
The IPC pktio implementation has been modified to use standard ODP internal
`ring_ptr_t` rings to implement IPC rings. This enables removing the duplicate
`_ring_t` implementation.
==== Pool
Packet segmentation has been reimplemented using a linked list. The new
implementation is simpler and has the added benefit of greatly reducing
packet and buffer header sizes.
=== Bug Fixes
==== Unnumbered Bugs / Issues
* Fixed socket mmap pktio throughput collapse under heavy traffic
* Fixed missing config header in install directory
* Include only ODP defines in autogenerated header files
* Fixed GCC 9 `address-of-packed-member` warnings
* Disable building static test applications without static ODP lib
* Fixed a segfault in `odp_pktin_recv_mq_tmo()` implementation
* Fixed classifier vlan match bugs and tests
* Fixed classifier matching of parallel PMRs
== OpenDataPlane (1.22.0.0)
=== Summary of Changes
ODP v1.22.0.0 adds several smaller API changes mainly related to API
clarification.
=== API Changes
==== Added `odp_queue_order_t` parameter to `odp_queue_param_t`
Added a parameter to control if a destination queue does not require event
re-ordering. By default, event order is maintained for all destination queues as
before. Application may use `ODP_QUEUE_ORDER_IGNORE` for those queues that are
used under ordered queue context, but do not require re-ordering and/or do need
to avoid extra re-ordering delays.
==== Added `ODP_SHM_HP` flag for `odp_shm_reserve()`
When set, this flag guarantees that the memory reserved by `odp_shm_reserve()`
is allocated from huge pages. If enough huge page memory is not available the
call will fail.
==== Improved initialization and termination specification
Improve specification of initialization and termination steps. Explicitly list
those functions that may be used before global init (those that are needed for
setting up parameters). No changes to functionality.
==== Improved queue context specification
Highlight that queue context default value is NULL. This was defined already in
`odp_queue_param_t` specification.
==== New Crypto Algorithm Support
Support for new crypto algorithms is added by defining symbols for:
* `ODP_CIPHER_ALG_3DES_ECB`
* `ODP_CIPHER_ALG_AES_ECB`
* `ODP_CIPHER_ALG_AES_CFB128`
* `ODP_CIPHER_ALG_AES_XTS`
* `ODP_CIPHER_ALG_AES_EEA2`
Support for new crypto authentication algorithms is added by defining symbols
for:
* `ODP_AUTH_ALG_SHA224_HMAC`
* `ODP_AUTH_ALG_AES_EIA2`
Added enumeration for digest (unkeyed) algorithms. They are added as auth
algorithms with empty key required.
* `ODP_AUTH_ALG_MD5`
* `ODP_AUTH_ALG_SHA1`
* `ODP_AUTH_ALG_SHA224`
* `ODP_AUTH_ALG_SHA256`
* `ODP_AUTH_ALG_SHA384`
* `ODP_AUTH_ALG_SHA512`
==== Crypto specification improvements / fixes
Correct documentation for `ODP_AUTH_ALG_SNOW3G_UIA2` to reference 128-EIA1
instead of 128-EEA1.
Clarify IV data format and point to proper documents for 3GPP algorithms.
==== Timer specification clarification
Timer API intention has always been to allow any event type to be used as
timeout events. Application should use `ODP_EVENT_TIMEOUT` type events
(`odp_timeout_t`) by default, but also other event types may be used. Also,
clarified timer set/reset functionality of `odp_timer_set_abs()` and
`odp_timer_set_rel()` functions.
API functionality not changed, just wording updated.
==== Added timer resolution capability
Typically, timer implementation needs to trade-off between highest resolution
and longest timeout. Add new capability information
(`odp_timer_res_capability_t`) and function to check limits between resolution
and maximum timeout length.
`odp_timer_res_capability()`::
This function fills in capability limits for timer pool resolution and min/max
timeout values, based on either resolution or maximum timeout.
==== Added defines for minute and hour
Defines for a minute and an hour are useful e.g. when setting timers for a bit
longer (background, session lifetime, etc.) timeouts.
* `ODP_TIME_MIN_IN_NS`
* `ODP_TIME_HOUR_IN_NS`
=== Helper Changes
==== Added helper library version
Added helper library version defines, so that application can track helper
version independent of ODP API version:
* `ODPH_VERSION_GENERATION`
* `ODPH_VERSION_MAJOR`
* `ODPH_VERSION_MINOR`
Also, added a function for generating easy printout of the versions number.
`odph_version_str()`::
The version string defines the helper library version the following format:
`<generation>.<major>.<minor>`
==== Added new thread create and join functions
Defined new versions of thread create and join calls. The new calls explicitly
support thread create and join in multiple steps. Also, per thread
(`odph_thread_param_t`) and common parameters (`odph_thread_common_param_t`)
have been improved.
`odph_thread_create()`::
Create and pin threads (as Linux pthreads or processes)
`odph_thread_join()`::
Wait previously launched threads to exit
Old functions `odph_odpthreads_create()` and `odph_odpthreads_join()`
have been deprecated.
==== Added helper debug defines
Added debug defines/macros into helper API and configure options to
enable/disable helper debugging. These defines may be used both in helper and
application code:
* `ODPH_DEBUG` is 1 when helper debugging is enabled (`--enable-helper-debug`)
* `ODPH_DEBUG_PRINT` is 1 when helper debug printing is enabled (`--enable-helper-debug-print`)
* `ODPH_ASSERT()` generates assertion code when helper debugging is enabled
=== Validation Test Improvements
==== Timer Test Improvements
Enables passing tests on high core count devices.
Test min/max timeouts with the highest resolution and longest timeout
parameters.
==== Scheduler Test Fixes
The group test would fail if `odp_schedule(ODP_SCHED_NO_WAIT)` wouldn't return
any events on the first call.
`scheduler_test_pause_resume()` would get stuck if all events were not
successfully enqueued.
Fixed a number of synchronization problems revealed by a scheduler
implementation doing pre-scheduling. Makes sure scheduling context is always
properly released.
==== Classification Test Fixes
Some of the test array elements may have not been set if the number of supported
scheduling priorities was low.
==== Pktio Test Improvements
Added more debug information on magic number misses.
==== Initialization Test Improvements / Fixes
Added missing local init/term calls to all test cases.
Added test case to set num_worker and num_control parameters.
Added test case to set not used features flags in init parameters.
==== Buffer Test Fixes
Test suite missed to output the return value of `odp_cunit_run()`.
==== Queue Test Improvements
Check that queue context pointer value is NULL by default.
==== IPsec Test Fixes
Check pktio level inline IPsec support before running tests.
==== Crypto Test Improvements
Added support for AES-194-GMAC and AES-256-GMAC algorithms.
Added more AES-CBC and AES-CTR test vectors.
=== Example Changes
==== Added new pipeline example application
The application receives packets from one interface and passes them through 0-N
worker stages before outputting them from a second network interface. The RX,
worker, and TX stages are connected using plain queues and each stage is run on
a separate CPU thread. Optionally, the worker stages calculate CRC-32C over
packet data.
==== Time example fixes
Fix single worker deadlock and run the application as part of `make check`.
==== IPsec example fixes
Fixed a number of issues in IPsec example applications and run them during
`make check`.
==== New command line options
===== l2fwd
* added `-b` option to control maximum packet receive burst size
===== pool_perf
* added `-n` option to allocate multiple event bursts before freeing those
* added `-t` option to select between buffer or packet pool types
* added `-s` option to select data size
===== sched_perf
* added `-w` option to simulate application work
* added `-g` and `-j` options to test scheduling with a number of schedule groups
=== Implementation Improvements
==== Pool Implementation Improvements
Refactor local buffer caching into separate functions and optimize
implementation by caching buffer header pointers instead of indices.
New configuration options have been added for local cache
(`pool:local_cache_size`) and burst sizes (`pool:burst_size`).
Pool implementation has been modified to store buffer headers instead of
indices to reduce type conversion overhead.
==== Timer Implementation Improvements
Added warm up period into POSIX timer pool startup to avoid the first timeout
to slip. Otherwise, timer pthread receives the first signal after about 15ms and
first timeout of the pool slips.
==== DPDK Packet I/O Improvements
The zero-copy DPDK pktio implementation has been cleaned up resulting a small
performance improvement. Linking to DPDK library has also been simplified.
=== Miscellaneous
* ODP project has been moved from Linaro to OpenFastPath Foundation. Project
documentation and domain addresses have been updated to reflect this change.
* Added `--without-pcap` configuration option to explicitly build ODP without
PCAP pktio regardless of if the library is available on the build host.
* Added `--enable-lto` configuration option to build ODP with link time
optimization (`-flto` flag).
* Travis default distribution is updated to Ubuntu Xenial.
* Added `-O3`, `-O0`, and LTO build tests to Travis
* Supported Netmap version has been bumped to v13.0
=== Bug Fixes
==== Numbered Bugs / Issues
* Fixed: https://github.com/OpenDataPlane/odp/issues/827[Issue 827]
API doc links are not working
* Fixed: https://github.com/OpenDataPlane/odp/issues/817[Issue 817]
ODP fails to compile with latest OpenSSL
* Fixed: https://github.com/OpenDataPlane/odp/issues/784[Issue 784]
Bus error
==== Unnumbered Bugs / Issues
* Fixed build problems on Debian 8
* Fixed AES-GMAC with OpenSSL 1.1.1b and later
* Fixed out-of-tree build
* Fixed pcapng pipe read permissions and made possible to capture traffic from
multiple interfaces
== OpenDataPlane (1.21.0.0)
=== Summary of Changes
ODP v1.21.0.0 adds two new API families as well as several small improvements.
==== APIs
===== Compression Support
A new family of APIs is added that provides for session-oriented support for
packet data compression and decompression. Compression sessions define the
parameters used to control compression operations and their associated
integrity hashes. Once created, sessions are input parameters to the new
`odp_comp_op()` and `odp_comp_op_enq()` APIs that provide access to
synchronous and asynchronous compression services on packets.
Associated with the completion of asynchronous compression operations, a new
packet subtype, `ODP_EVENT_PACKET_COMP` is defined. This subtype indicates
that the packet includes additional metadata (retrievable via
`odp_comp_result()`) that provides the result of the requested operation.
A number of different compression and associated hash algorithms are defined,
which are communicated with three new capability APIs:
`odp_comp_capability()`::
Provides information about general compression related capabilities
offered by this implementation
`odp_comp_alg_capability()`::
Provides details about the capabilities of individual compression algorithms
supported.
`odp_comp_hash_alg_capability()`::
Provides details about the capabilities of individual hash algorithms
supported for use with compression.
===== Flow Aware Scheduler Support
A new capability for flow aware scheduling is added. As part of this, the
scheduler now supports capabilities and configurability. As a result, the
initialization sequence for applications that make use of the ODP scheduler
has changed slightly. The new API call sequence is:
[source,c]
-----
odp_schedule_capability()
odp_schedule_config_init()
odp_schedule_config()
odp_schedule()
-----
It is a programming error to call `odp_schedule()` (or its variants) without
having first initialized the scheduler with an `odp_schedule_config()` call.
This call may only be issued once per ODP instance as scheduler configuration
is global.
By default the scheduler operates as before. When configured to operate in
flow aware mode, the scheduler will now respect event flow ids (managed by the
new `odp_event_flow_id()` and `odp_event_flow_id_set()` APIs) when making
scheduling decisions. This means that flow identification is a combination of
event flow id and queue id. For example, when operating in flow aware mode the
scheduler may dispatch events from an atomic queue to multiple threads
concurrently, as long as those events have different flow ids. For
applications that process large numbers of lightweight flows that have limited
context needs, this can lead to throughput improvements as well as reduced
implementation memory footprint.
==== DPDK v18.11 Support
The latest LTS release of DPDK (v18.11) is now supported by ODP. Support for
the previous LTS release (v17.11) is retained. Prior versions of DPDK are
no longer supported.
==== Queue Capabilities Moved to Scheduler
As part of the introduction of flow-aware scheduling, capabilities associated
with `SCHED` queues have been moved from the `odp_queue_capabilities_t` struct
returned by `odp_queue_capabilities()` to the new `odp_sched_capabilities_t`
struct returned by `odp_sched_capabilities()`.
Capabilities moved include `max_ordered_locks`, `max_sched_groups`, and
`sched_prios`. The `max_sched_groups` capability is renamed `max_groups`. In
addition, `max_queues`, `max_queue_size`, and the support capabilities for
lock free and wait free non blocking queues is now part of the scheduler
capabilities.
In support of flow aware scheduling mode, the `max_flows` scheduler capability
is renamed `max_flow_id`. A value of 0 indicates that flow aware mode
scheduling is not available in this ODP implementation.
=== Test/Validation Improvements
==== Travis readability improvement
The "BUILD_ONLY` environment variable has been renamed `CHECK` for improved
output readability.
==== Flow aware scheduler testing
As part of flow aware mode, scheduler validation tests will now test this mode
if `odp_schedule_capability()` indicates that flow-aware mode is supported.
=== Bug Fixes
==== Unnumbered Bugs/Issues
* Latest version of netmap `nm_ring_empty()` implementation has changed.
PktIO netmap support updated to support this as well as previous releases.
* Improved compatibility of PktIO socket support with latest versions
of the clang compiler.
* Add match pattern for missing DPDK PMD drivers for improved compatibility.
== OpenDataPlane (1.20.0.0)
=== Summary of Changes
ODP v1.20.0.0 is a refresh of ODP, incorporating significant configurability
and performance improvements as well as new APIs and API restructures.
==== APIs
===== Symbol `ODP_SHM_NULL` Removed.
An invalid `odp_shm_t` has the value `ODP_SHM_INVALID`, consistent with other
ODP types. The legacy synonym `ODP_SHM_NULL` is now removed for consistency.
===== New 3GPP Crypto Algorithm Support
New support for 3GPP crypto algorithms is added by defining symbols for
* `ODP_CIPHER_ALG_KASUMI_F8`
* `ODP_CIPHER_ALG_SNOW3G_UEA2`
* `ODP_CIPHER_ALG_ZUC_EEA3`
In addition new authentication algorithm symbols are defined for
* `ODP_AUTH_ALG_KASUMI_F9`
* `ODP_AUTH_ALG_SNOW3G_UIA2`
* `ODP_AUTH_ALG_ZUC_EIA3`
These values are returned as ODP capabilities as well as being accepted in
crypto session creation for implementations that indicate support for them.
===== Crypto Capability for Bitwise Operation
The new `bit_mode` capability Boolean is added to the
`odp_crypto_cipher_capability_t` struct to indicate that an implementation
supports operating in bit mode. When operating in bit
mode, field offsets and lengths are expressed in terms of bits rather than
bytes. However, such lengths must always be specified in multiples of 8.
===== Improved Crypto Spec Documentation
The ODP crypto API specification is tightened to specify default values for
cipher and authentication algorithms. Also documented when key and IV
parameters need to be set.
===== IPsec Extensions
IPsec requires "salt" (extra keying material) when the GMAC authentication
algorithm is used. To accommodate this the `auth_key_extra` field is added to
the `odp_ipsec_crypto_param_t` struct and documentation is added clarifying
when this field is needed and how it should be used.
===== Classifier Type Rename
The `odp_pmr_t` type name for an invalid value is renamed from `ODP_PMR_INVAL`
to `ODP_PMR_INVALID` for consistency with the rest of ODP type names. The old
symbol is still available when ODP is configured with
`--enable-deprecated`.
===== New API for Packet Event Subtypes
The `odp_packet_subtype()` API is added that returns the subtype of a packet
event directly.
===== Streamlined Packet Parsing Results
The `odp_packet_parse_result()` API is added that returns the result of
packet parsing as a single `odp_packet_parse_result_t` struct. This can
offer efficiency improvements for applications that need all parse results
rather than making individual parse result calls.
===== PktIO Extensions to Support per-Queue Configuration
PktIO interfaces support multiple input queues to enable increased parallelism
in I/O processing. Previously, all of these input queues were required to
belong to the same scheduler group. The `odp_pktin_queue_param_t` struct is
now extended with an optional `odp_pktin_queue_param_ovr_t` struct that
permits individual pktin queues to be assigned to separate scheduler groups.
This may permit improved performance for advanced application use cases.
===== Timer Pool Capabilities
The `odp_timer_capability_t` struct is extended to return three additional
pieces of information:
`max_pools_combined`::
The total number of timer pools that can be created combining different
clock sources
`max_pools`::
The maximum number of timer pools for a given clock source.
`max_timers`::
The maximum number of timers in a single pool. A zero value means number is
limited only by available memory.
===== Add Scheduler mix/max/default Priority Functions
Three new APIs: `odp_schedule_max_prio()`, `odp_schedule_min_prio()`, and
`odp_schedule_default_prio()` are added that return the min, max, and default
values specified for the `prio` field in the `odp_schedule_param_t` struct.
With the introduction of these scheduling priority functions the previously
defined macros (`ODP_SCHED_PRIO_HIGHEST`, `ODP_SCHED_PRIO_NORMAL`, and
`ODP_SCHED_PRIO_LOWEST`) are now deprecated and should no longer be used.
===== Specification of `odp_schedule_prio_t` as an `int`
Previously, the `odp_schedule_prio_t` type definition was left to each
implementation. With the addition of explicit schedule priority ranges, this
type is now specified to be an `int` to permit efficient implementation
(including inlining) of these functions.
====== New Scheduler APIs
The new scheduler APIs `odp_schedule_multi_wait()` and
`odp_schedule_multi_no_wait()` are added to provide more efficiently
implementable versions of these functions. The existing scheduler APIs remain
unchanged. These new APIs can simply provide a fastpath for some
applications/implementations as an alternative to specifying a parameter on
`odp_schedule_multi()`.
===== Memory Model in `odp_init_global()`
The `odp_init_t` parameter passed to `odp_init_global()` is extended to
add the `mem_model` field. This field is defined by the new `odp_mem_model_t`
struct and is used to specify whether the application will be using a
thread (`ODP_MEM_MODEL_THREAD`) or process (`ODP_MEM_MODEL_PROCESS`)
memory model. The default is a thread model is used for compatibility with
previous levels of ODP.
==== ABI Changes
A number of changes to the ODP ABI have also been made in this release to
improve application binary portability.
===== Strong Typing for Timer Pools
The `odp_timer_pool_t` is now strongly typed.
===== Consistent Initialization
The values of the various `ODP_xxx_INVALID` symbols for ODP abstract types in
the `odp-linux` reference implementation are now consistently zeros. This
reduces errors and improves portability.
=== Implementation Improvements
==== Configuration File
A new configuration file mechanism is introduced that makes use of
https://www.hyperrealm.com/libconfig/libconfig_manual.html[libconfig] to
enable various runtime ODP parameters to be specified dynamically.
Default configuration values for the `odp-linux` reference implementation are
contained in the `config/odp-linux-generic.conf` file. Users may override
these default values by supplying their own configuration file. At
`odp_init_global()` time, if the `ODP_CONFIG_FILE` environment variable is set,
this is used to locate the path to the override configuration file.
==== Process Mode Support
The `odp-linux` reference implementation now supports applications that run in
process mode (`mem_model` = `ODP_MEM_MODEL_PROCESS`) as well as the default
thread mode. This support only applies within a single ODP instance, so any
`fork()` calls must be done only _after_ `odp_init_global()` has been called
to initialize ODP on a root process.
==== Removal of `iQuery` Scheduler
The `iQuery` scheduler is removed from the `odp-linux` reference
implementation, as it offers no performance advantages and has not seen
application use.
==== Number of CPUs
The `odp-linux` reference implementation now supports up to 256 CPUs by
default (increased from 128).
==== Support for Large Burst Sizes