== OpenDataPlane (1.15.0.0) === New Features ODP v1.15.0.0 continues the preview of Tiger Moth, introducing new APIs and extensions, as well as numerous bug fixes and functional improvements. ==== Deprecation Framework To permit smoother evolution of the ODP API specification, a deprecation framework is introduced to permit controlled deprecation. When an ODP API or defined struct parameter is deprecated, ODP validation tests will be updated to no longer use that API and instead use the replacement API. By default, attempts to compile with the older API/feature will fail and applications wishing to move to the new ODP release should be updated to use the replacement API. To permit evaluation of new ODP releases in advance of such updating, however, ODP supports the `configure` option `--enable-deprecated`, which makes the obsolete APIs visible again. This feature will be used on a case-by-case basis and documented in the release notes for each release that introduces replacement API(s). In general the deprecated forms will not be maintained for more than a single release cycle. After that they will no longer be present in the API specification and the replacement forms must be used to compile with that level of the API specification. ==== APIs A number of new and refined APIs are introduced in crypto, packet parsing, and queue configuration: ===== Crypto Enhancements The ODP crypto APIs receive several enhancements in this release: ====== New Authentication Algorithms Additional enumerations added for HMAC-SHA-1 and HMAC-SHA-512 authentication. ====== Deprecated Cipher/Authentication Algorithms The following cipher/authentication algorithms have been deprecated in favor of newer replacement algorithms: * `ODP_CIPHER_ALG_AES128_CBC` is replaced by `ODP_CIPHER_ALG_AES_CBC` * `ODP_CIPHER_ALG_AES128_GCM` is replaced by `ODP_CIPHER_ALG_AES_GCM` * `ODP_AUTH_ALG_MD5_96` is replaced by `ODP_AUTH_ALG_MD5_HMAC` * `ODP_AUTH_ALG_SHA256_128` is replaced by `ODP_AUTH_ALG_SHA256_HMAC` * `ODP_AUTH_ALG_AES128_GCM1 is replaced by `ODP_AUTH_ALG_AES_GCM` ====== Deprecated Name for Crypto Parameter struct `odp_crypto_op_params_t` is deprecated in favor of `odp_crypto_op_param_t` for consistency with other ODP `param` structs. ====== Digest Length Session Parameter `odp_crypto_session_param_t` adds the field `auth_digest_len` to permit specification of the authentication digest length to be used for this session. The `odp_crypto_auth_capability()` API returns the list of supported digest lengths. ====== Additional Authentication Data (AAD) The `odp_crypto_op_param_t` struct adds an optional pointer and length for AAD information. This allows applications to specify AAD information from the list of supported lengths provided by `odp_crypto_auth_capability()`. ===== Packet Range Data The former `odp_crypto_data_range_t` type is deprecated and renamed to `odp_packet_data_range_t` since it can be used to specify ranges for other than crypto purposes. ===== Parser Configuration Applications may now specify the maximum packet layer of interest. For example, a router may not care about anything beyond ISO Layer 3 in packets. This can be used by ODP implementations to control the depth of packet parsing needed by the application and may allow greater efficiency, especially in software implementations. This is controlled by a new `odp_pktio_parser_layer_t` enum that is part of the new `odp_pktio_parser_config_t` struct that is added to the `odp_pktio_config_t` struct used by the `odp_pktio_config()` API. The supported parser layers are also returned in this struct as part of the `odp_pktio_capability_t` struct returned by the `odp_pktio_capability()` API. ===== Queue Size Parameter The `odp_queue_capability_t` struct returned by the `odp_queue_capability()` API is enhanced as follows: * The `max_queues` field is now defined to return the maximum number of event queues of any type. * New sub-structs (`plain` and `sched`) are added that detail the `max_num` of queues of that type supported as well as the new field `max_size` that specifies the maximum number of elements that each queue of this type can store. A value of zero for `max_num` indicates no fixed limit. In addition, the `odp_queue_param_t` passed to `odp_queue_create()` now adds a `size` field to allow applications to specify the minimum number of events that this queue should be able to store. A value of zero specified requests that the implementation default limits be used. The ODP examples have been updated to show this configuration, for example, the `l2fwd_simple` example does Layer 2 forwarding and hence doesn't need packets to be parsed beyond Layer 2. So prior to opening an interface via `odp_pktio_open()` the configuration processing now includes code of the form: [source,c] ----- odp_pktio_config_init(&config); config.parser.layer = ODP_PKTIO_PARSER_LAYER_L2; odp_pktio_config(pktio, &config); ----- This serves as a hint to the ODP implementation that parsing beyond Layer 2 is not required on this interface. ===== Removal of `odp_time_to_u64()` API The `odp_time_to_u64()` API is removed without deprecation in this release. This is redundant since the `odp_time_to_ns()` API already returns a `uint64_t` value for `odp_time_t` and can be used for the same purpose. ===== New `odp_sys_info_print()` API For debugging / diagnostic use, the `odp_sys_info_print()` API is added. This prints implementation defined information about the system and ODP environment and may contain information about CPUs, memory, and other hardware configuration. === Helpers ==== Linux Helpers ODP helper functions fall into two categories: system-independent, and those that rely on Linux. For backwards compatibility, these have been reorganized into a new `helper/linux` directory that is installed only when the `--enable-helper-linux` `configure` option is specified. === `odp-linux` Performance ==== Scheduler Improvements The default scheduler is streamlined by using precomputed weight tables and separated priority queues for different scheduling groups. This improves both latency and scalability. Also included in this change, the default number of scheduling groups is lowered from 256 to 32, which experience has shown is sufficient for most applications. The scheduler fairness checks are also enhanced to avoid low priority event starvation if `CONFIG_BURST_SIZE` is set to 1. === `odp_linux` Crypto Improvements * Errors in implicit packet copy operations performed during crypto operation are now handled properly. * If `odp_crypto_session_create()` fails, proper cleanup is now performed to avoid memory leaks. * The auth digest len is now used when calculating HMACs, and full-length digests are now added to supported SHA capabilities. * Numerous crypto functions have been rewritten to use the OpenSSL `EVP_` functions for improved efficiency and accuracy. === `odp-linux` Packet Improvements * The packet parser now recognizes ICMPv6 packets in addition to ICMPv4. === `odp-linux` PktIO Improvements * The `ethtool` and `socket` drivers add additional initializations to avoid valgrind warnings. * The `dpdk` driver is upgraded to DPDK 17.02 and is now also built with the `--whole-archive` option, which means that PMDs no longer need to be linked individually but are automatically included in builds that make use of DPDK pktio support. === `odp-linux` Time Improvements * The ODP Time APIs are now more efficiently handled by replacing the previous Linux timespec with simple nanoseconds (ns) and using native hardware time counters in x86 and ARM environments, when available. === `odp-linux` Traffic Manager Improvements * Weighting is now handled properly when weight=1 is specified. Previously this caused an overflow that distorted packet priorities. === Miscellaneous Fixes and Improvements ==== Native Clang build on ARMv8 ARMv8 compilation now works properly when using the clang compiler. ==== Test Improvements * The `odp_scheduling` performance test now handles dequeueing from potentially concurrent queues properly. * The traffic manager and time tests are now invoked via scripts to better account for load-sensitivity when running regressions in CI environments. * The l2fwd test now supports an additional parameter to specify the number of scheduling groups to use in the test. * The `odp_sched_latency` performance test now handles queue draining in a robust manner. * The crypto validation tests now properly check and validate message digests, and include negative tests to verify that incorrect digests are properly flagged. Note that this may expose omissions in other ODP implementations that had previously passed this validation test. * The crypto validation test now adds an explicit test for the NULL cipher, as well as HMAC-SHA-1 and HMAC-SHA-512. * The pktio_ipc test now properly cleans up only its own temp files. ==== Examples Improvements * The `odp_generator` example now properly honors stop criteria based on number of packets sent. * The `odp_generator` example now properly flushes output messages * The `odp_generator` example now supports port configuration. === Bug Fixes ==== https://bugs.linaro.org/show_bug.cgi?id=2416[Bug 2416] example/generator/odp_generator.c contains todo items ==== https://bugs.linaro.org/show_bug.cgi?id=2779[Bug 2779] Error handling issues (CHECKED_RETURN) ==== https://bugs.linaro.org/show_bug.cgi?id=2826[Bug 2826] Unchecked return in pool.c ==== https://bugs.linaro.org/show_bug.cgi?id=2831[Bug 2831] Unchecked return in mmap_unmap_sock() ==== https://bugs.linaro.org/show_bug.cgi?id=2852[Bug 2852] ODP_STATIC_ASSERT() fails when used by C++ ==== https://bugs.linaro.org/show_bug.cgi?id=2872[Bug 2872] odp_pktio_ordered_run.sh: line 34: integer expression expected ==== https://bugs.linaro.org/show_bug.cgi?id=2881[Bug 2881] load sensitive tests fail on CI ==== https://bugs.linaro.org/show_bug.cgi?id=2895[Bug 2895] The `odp_crypto_operation()` routine does not work with multi-segment packets. ==== https://bugs.linaro.org/show_bug.cgi?id=2908[Bug 2908] Packet validation test fails if implementation does not limit packet length ==== https://bugs.linaro.org/show_bug.cgi?id=2910[Bug 2910] odph_iplookup_table_put_value() uses overlapping pointer addresses ==== https://bugs.linaro.org/show_bug.cgi?id=2933[Bug 2933] Miss to call unlock if there are some errors happen in loopback_send() function ==== https://bugs.linaro.org/show_bug.cgi?id=2940[Bug 2940] `odp_packet_seg_t` fails ABI compatibility between odp-linux and odp-dpdk ==== https://bugs.linaro.org/show_bug.cgi?id=2942[Bug 2942] Compilation fails using clang 4.0.0 ==== https://bugs.linaro.org/show_bug.cgi?id=2952[Bug 2952] doxygen errors and travis does not catch them ==== https://bugs.linaro.org/show_bug.cgi?id=2969[Bug 2969] TM validation test does find traffic_mngr_main ==== https://bugs.linaro.org/show_bug.cgi?id=2974[Bug 2974] `odp_rwlock_read_trylock()` fails if lock is already held for read access ==== https://bugs.linaro.org/show_bug.cgi?id=3002[Bug 3002] Packet order lost when enqueuing to pktout queue ==== https://bugs.linaro.org/show_bug.cgi?id=3003[Bug 3003] AES-GCM returns 'valid' tag when checking invalid tag ==== https://bugs.linaro.org/show_bug.cgi?id=3013[Bug 3013] Various failures if CONFIG_PACKET_MAX_SEGS is set to 1 ==== https://bugs.linaro.org/show_bug.cgi?id=3017[Bug 3017] Travis: time main test out of boundaries ==== https://bugs.linaro.org/show_bug.cgi?id=3027[Bug 3027] Compilation failures using GCC 7 series ==== https://bugs.linaro.org/show_bug.cgi?id=3039[Bug 3039] Socket pktio recv fails on large number of packet === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=3024[Bug 3024] odp_traffic_mngr example is broken ==== https://bugs.linaro.org/show_bug.cgi?id=3026[Bug 3026] pktio_ips_run test can fail due to segfault == OpenDataPlane (1.14.0.0) === New Features ==== APIs ODP v1.14.0.0 represents another preview of the Tiger Moth release series and introduces new APIs and extensions. ===== Packet References Packet references are a lightweight mechanism to allow applications to create and manipulate different "views" of packets. These views consist of shared bytes common to all references created on the same `odp_packet_t`, possibly prefixed with unique headers that are private to each reference. Five new APIs are introduced to enable this feature: `odp_packet_ref_static()`:: Static references allow a single packet to have multiple "aliases", all of which must be treated as read only. This is useful, for example, to retain a reference to a packet being transmitted to support retransmit processing, since the actual storage represented by a packet is not released until all references to it have been freed via `odp_packet_free()` calls. `odp_packet_ref()`:: Dynamic references differ from static references is that they permit the individual `odp_packet_t` handles to have unique prefixes created via `odp_packet_push_head()` or `odp_packet_extend_head()` calls. This can be used, for example, to support multicasting packets to different destinations by creating packets that consist of unique headers followed by a common shared payload. `odp_packet_ref_pkt()`:: Similar to `odp_packet_ref()`, but creates a dynamic reference by prepending a preexisting header onto another packet. `odp_packet_has_ref()`:: Returns a boolean indicator of whether a given `odp_packet_t` has other references that share bytes with this packet. `odp_packet_unshared_len()`:: Returns the number of unshared bytes accessible through a given `odp_packet_t` handle. These are the only bytes that should be changed. All other bytes in the packet should be treated as read only as they are shared with other `odp_packet_t` handles. Note that while the packet reference APIs and associated validation tests are present in this release, the `odp-linux` reference implementation currently implements references via packet copying. A zero-copy implementation of packet references is planned to be part of the ODP v1.15.0.0 release. ==== ABI Specification ODP has supported an Application Binary Interface (ABI) that permits applications to be generated that are binary portable between select ODP implementations. This is now formalized with the addition of structures that permit ABI specifications to be defined that are shared between ODP implementations. ODP provides a default ABI specification that is the same as was provided before. This change means that additional ABIs may be defined that are optimized to collections of platforms that share an Instruction Set Architecture (ISA) and subscribe to them. ABI specifications live in the `include/odp/arch/...` directory. ==== Instance Query (iQuery) Scheduler Adding to the range of scheduler implementations supported by `odp-linux`, a new scheduler, the instance query scheduler, is available by specifying `--enable-schedule-iquery` at `configure` time. This scheduler uses sparse bitmaps and offers scalability advantages when dealing with large numbers of schedule queues. It otherwise offers performance comparable to the default ODP scheduler implementation. === Helpers Helpers have been reorganized to provide better independence from odp-linux and to make them more useful with other ODP implementations. These reorganizations are functionally transparent to ODP users but should simplifying packaging and porting to other ODP implementations. This includes adding the "umbrella" include file `odph_api.h` which can be used to include all helper API definitions in an application. === Classifier Improvements The `odp-linux` reference implementation now supports Pattern Matching Rules (PMRs) for IPv6 addresses, inner and outer VLAN IDs, and inner and outer Ethernet types. === Performance ==== Improved inlining for embedded applications The `odp-linux` reference implementation now offers improved inlining support for ODP APIs for applications compiled against ODP configured with the `--enable-abi-compat=no` option, meaning they wish to forego binary compatibility in exchange for improved performance. These applications remain source portable to other ODP implementations. ==== Native `odp_cpu_pause()` for ARM processors A native implementation of the `odp_cpu_pause()` API has been added for ARMv7 and ARMv8 processors. ==== New Microbenchmark The `odp_packet_bench` microbenchmark application has been added to the test performance directory to allow implementations to measure and calibrate the performance of individual ODP packet APIs. ==== Ordered PktIO Test The `odp_pktio_ordered` application has been added to the test performance directory to provide stress-testing of packet ordering features of ODP. === Documentation In addition to expanded documentation related to the new packet reference APIs, a section on applicatin portability has been added that discusses the types of portability offered by ODP and the tradeoffs that application writers should consider when using ODP. === Bug Fixes ==== https://bugs.linaro.org/show_bug.cgi?id=2806[Bug 2806] The `hello.c` application can now run properly if Core 0 is not available (any available core will be used). ==== https://bugs.linaro.org/show_bug.cgi?id=2827[Bug 2827] Provide proper return code checking within _ishm.c ==== https://bugs.linaro.org/show_bug.cgi?id=2829[Bug 2829] Remove unused variables in iplookuptable helper routine. ==== https://bugs.linaro.org/show_bug.cgi?id=2830[Bug 2830] Avoid memory leaks on error paths in the cuckoo table helper functions. ==== https://bugs.linaro.org/show_bug.cgi?id=2834[Bug 2834] Fixes a race condition in shared memory allocation. ==== https://bugs.linaro.org/show_bug.cgi?id=2842[Bug 2842] Provide proper fallback for shared memory when hugepages are not available. ==== https://bugs.linaro.org/show_bug.cgi?id=2862[Bug 2862] Avoid null pointer dereference in the iplookuptable helper routine. ==== https://bugs.linaro.org/show_bug.cgi?id=2865[Bug 2865] Missing doxygen documentation for helper table functions are added. === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=2852[Bug 2852] C++ programs fail to compile if they attempt to include the ODP helper APIs. ==== https://bugs.linaro.org/show_bug.cgi?id=2895[Bug 2895] The `odp_crypto_operation()` routine does not work with multi-segment packets. == OpenDataPlane (1.13.0.0) === New Features ==== APIs ODP v1.13.0.0 represents the initial preview of the Tiger Moth release series and as such introduces new APIs and extensions that will be built on as this release matures. ===== Crypto Parameter Normalization Many ODP APIs take parameter structs of type `odp_xxx_param_t`. The crypto APIs, for historical reasons, failed to follow this convention, using instead structs of type `odp_crypto_params_t`, etc. These pluralized names are now deprecated and their singular forms are introduced as the preferred names for these structs. The old names are retained (for now) to ease migration, however applications should convert to the new forms at their convenience as these deprecated forms will be removed in the final Tiger Moth release. The changes introduced for this include: * `odp_crypto_op_params_t` => `odp_crypto_op_param_t` * `odp_crypto_session_params_t` => `odp_crypto_session_param_t` ===== Crypto Decouple Key Length from Algorithm Specification To provide a more flexible programming for handling all possible key/digest/iv length combinations, the enums used for crypto specification are split to decouple lengths from algorithm names. The only exception is the SHA-2 family of hash routines, which have well-established naming conventions that incorporate digest lengths (SHA-224, SHA-256, etc.) Changes included with this restructure include: * The `odp_crypto_capability_t` structure returned by the `odp_crypto_capability()` API contains streamlined `odp_crypto_cipher_algos_t` and `odp_crypto_auth_algos_t` substructures. * A new `odp_crypto_cipher_capability()` API is added to return detailed information about available cipher capabilities. * A new `odp_crypto_auth_capability()` API is added to return detailed information about available authentication capabilities. ===== `odp_crypto_session_param_init()` API For completeness the `odp_crypto_session_param_init()` API is provided to enable platform-independent initialization of the `odp_crypto_session_param_t` structure used as input to `odp_crypto_session_create()`. ===== Bitfield and Byteorder Cleanup The `ODP_BITFIELD_ORDER` define is added to the ODP specification to parallel the existing `ODP_BYTEFIELD_ORDER` define. This will be set to the value `ODP_BIG_ENDIAN_BITFIELD` or `ODP_LITTLE_ENDIAN_BITFIELD`. This also addresses https://bugs.linaro.org/show_bug.cgi?id=2402[Bug 2402], however since fixing this required a small API change this was deferred until an API release boundary. ===== Improved Name Argument Definitions in `odp_xxx_create()` Functions The use of name arguments to the various resource creation APIs has been standardized and documentation improved to clarify that unique names are not required and that these may be specified as NULL for anonymous resource creation. When non-unique resource names are used, it is unspecified which of these are returned by a corresponding lookup API. ===== Pool Parameters for Packet Pools The `odp_pool_param_t` structure adds the new field `max_len` to be used in packet pools to advise the implementation of the maximum sized packet that the application will allocate with a single `odp_packet_alloc()` call. This may enable storage pool optimization. ===== Packet Clarifications API documentation for `odp_packet_concat()` and `odp_packet_copy_from_pkt()` is clarified to specify that the source and destination packets supplied to these APIs should not refer to the same packet. ===== Packet Allocation Length Clarification API documentation for `odp_packet_alloc()` is clarified to specify that the supplied length for requested packet allocation should be greater than zero. ===== Random API Changes The APIs provided for working with random data have been revised. The third parameter to `odp_random_data()` is now of type `odp_random_kind_t`, which is an `enum` that is used to specify the quality of random data required. The kinds of random data defined are: `ODP_RANDOM_BASIC`:: No specific quality guarantees. This is assumed to be pseudo-random data generated by software where speed of generation is more important than the quality of the results.This is the lowest kind of random. `ODP_RANDOM_CRYPTO`:: Random data suitable for use in cryptographic operations. `ODP_RANDOM_TRUE`:: True random data generated from a hardware entropy source. This is the highest kind of random. The `odp_random_max_kind()` API is provided that returns the highest kind of data available on this implementation. Requests for higher kinds than can be supplied will fail. For testing purposes it is often desirable to generate "random" sequences that are repeatable. To support this use case, the `odp_random_test_data()` API is introduced. This always returns BASIC random data but uses a user-supplied 64-byte seed parameter that is update for each call and can be used to repeat the same sequence as needed. ===== Shared Memory Improvements The `odp_shm_reserve()` API adds two new additional flags to support external memory. * `ODP_SHM_SINGLE_VA` guarantees that all ODP threads sharing this memory will see the block at the same virtual address regardless of whether threads are implemented as pthreads or processes and when `fork()` calls are made to create them. * `ODP_SHM_EXPORT` allows the memory block to be visible to other ODP instances. Other ODP instances can retrieve this block via the new `odp_shm_import()` API. ===== Classification Clarifications The relationship between classification and queue configuration in the `odp_pktin_queue_param_t` structure is clarified to emphasize that classification subsumes queue-based I/O processing. This is an API documentation change only. === Helpers New helper APIs are introduced for IP table lookup support for longest prefix matching as well as cuckoo hash tables. These are designed to provide analogs to functions available in DPDK to assist applications being ported to ODP. === Performance Improvements The odp-linux reference implementation includes a number of improvements to make it more suitable for production use on platforms that rely on software implementations of key ODP APIs. ==== Ring-based Pool Implementation Storage pools used for buffers and packets are now implemented via lockless ring structures that support burst mode read/writes to local caches for significantly improved multi-core scalability ==== Buffer/Packet Header Optimizations The layout of the structs used to support buffers and packets has been optimized to reduce cache footprint and minimize path lengths in packet manipulation. ==== Ordered Queue Improvements The implementation of ordered queues has been streamlined and made more scaleable in multi-core systems. ==== Packet Segmentation Improvements The more advance segmentation capabilities present in the new ODP packet implementation are used to streamline the implementation of APIs like `odp_packet_concat()` and the head/tail extend/trunc APIs. === Bug Fixes ==== https://bugs.linaro.org/show_bug.cgi?id=2405[Bug 2405] A number of "todos" were removed from the packet validation test suite. ==== https://bugs.linaro.org/show_bug.cgi?id=2472[Bug 2472] The CPU affinity is now correctly read from the cpuset. ==== https://bugs.linaro.org/show_bug.cgi?id=2496[Bug 2496] The PktIO validation test no longer uses invalid MAC addresses. ==== https://bugs.linaro.org/show_bug.cgi?id=2512[Bug 2512] The TCP checksum is now properly calculated for generated packets. ==== https://bugs.linaro.org/show_bug.cgi?id=2798[Bug 2798] The odp-linux reference implementation makes use of the OpenSSL library to support the `odp_random_xxx()` APIs and some crypto operations. To support OpenSSL versions prior to 1.1.0, which are not thread safe, support is added for OpenSSL locking callbacks that use ODP ticketlocks to provide OpenSSL thread safety. === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=2812[Bug 2812] Make check fails on a single core VM in the process mode helper test. == OpenDataPlane (1.12.0.0) === New Features ==== APIs ODP v1.12.0.0 has no API changes from previous v1.11.0 Monarch LTS. Version is increased in current development release to make room for Monarch updates numbers. ==== Application Binary Interface (ABI) Support Support is added to enable ODP applications to be binary compatible across different implementations of ODP sharing the same Instruction Set Architecture (ISA). This support introduces a new `configure` option: `no abi disable option`:: This is the default and specifies that the ODP library is to be built to support ABI compatibility mode. In this mode ODP APIs are never inlined. ABI compatibility ensures maximum application portability in cloud environments. `--disable-abi-compat`:: Specify this option to enable the inlining of ODP APIs. This may result in improved performance at the cost of ABI compatibility and is suitable for applications running in embedded environments. Note that ODP applications retain source code portability between ODP implementations regardless of the ABI mode chosen. To move to a different ODP application running on a different ISA, code need simply be recompiled against that target ODP implementation. ==== SCTP Parsing Support The ODP classifier adds support for recognizing Stream Control Transmission Protocol (SCTP) packets. The APIs for this were previously not implemented. === Packaging and Implementation Refinements ==== Remove dependency on Linux headers ODP no longer has a dependency on Linux headers. This will help make the odp-linux reference implementation more easily portable to non-Linux environments. ==== Remove dependency on helpers The odp-linux implementation has been made independent of the helper library to avoid circular dependency issues with packaging. Helper functions may use ODP APIs, however ODP implementations should not use helper functions. ==== Reorganization of `test` directory The `test` directory has been reorganized to better support a unified approach to ODP component testing. API tests now live in `test/common_plat/validation/api` instead of the former `test/validation`. With this change performance and validation tests, as well as common and platform-specific tests can all be part of a unified test hierarchy. The resulting test tree now looks like: .New `test` directory hierarchy ----- test ├── common_plat │   ├── common │   ├── m4 │   ├── miscellaneous │   ├── performance │   └── validation │   └── api │   ├── atomic │   ├── barrier │   ├── buffer │   ├── classification │   ├── cpumask │   ├── crypto │   ├── errno │   ├── hash │   ├── init │   ├── lock │   ├── packet │   ├── pktio │   ├── pool │   ├── queue │   ├── random │   ├── scheduler │   ├── shmem │   ├── std_clib │   ├── system │   ├── thread │   ├── time │   ├── timer │   └── traffic_mngr ├── linux-generic │   ├── m4 │   ├── mmap_vlan_ins │   ├── performance │   ├── pktio_ipc │   ├── ring │   └── validation │   └── api │   ├── pktio │   └── shmem └── m4 ----- ==== Pools The maximum number of pools that may be created in the odp-linux reference implementation has been raised from 16 to 64. ==== Upgrade to DPDK 16.07 The DPDK pktio support in odp-linux has been upgraded to work with DPDK 16.07. A number of miscellaneous fixes and performance improvements in this support are also present. ==== PktIO TAP Interface Classifier Support Packet I/O interfaces operating in TAP mode now can feed packets to the ODP classifier the same as other pktio modes can do. === Performance Improvements ==== Burst-mode buffer allocation The scheduler and pktio components have been reworked to use burst-mode buffer allocation/deallocation, yielding a measurable performance gain in almost all cases. ==== Burst-mode queue operations ODP queues internally now attempt to use burst-mode enq/deq operations to accelerate performance where applicable. ==== Ring-based Scheduler Priority Queues The ODP scheduler has been enhanced to use ring-based priority queues, resulting in significantly better scalability in many core environments. ==== GitHub Automation Support ODP now supports the Travis framework needed to trigger CI automation in conjunction with GitHub. This support is considered experimental for now. === Examples ==== New `l3fwd` Example A new example application is provided that illustrates use of ODP for simple Layer 3 forwarding across multiple interfaces. === Documentation ==== Pure API Documentation ODP now generates "pure" (implementation independent) doxygen documentation in addition to the specific documentation for the odp-linux implementation. The pure version is applicable to any ODP implementation as it simply describes the ODP API specification. Implementation-specific versions of this documentation describe both the APIs as well as specifics concerning typedefs, enums, etc. This should help clarify what aspects of ODP are platform independent. ==== Clarify ODP Thread Definition The definition of an ODP thread in odp-linux has been clarified to specify that for this implementation ODP threads are Linux pthreads or Linux processes. Currently threads as processes is considered experimental in odp-linux. === Bug Fixes Numerous refinements have been incorporated to make validation tests more robust in API coverage as well as correcting corner cases in the implementation of many ODP APIs. Notable fixes include: ==== https://bugs.linaro.org/show_bug.cgi?id=2316[Bug 2316] `ODP_TIMEOUT_INVALID` is now defined consistently with other pool elements so the restriction on using Pool 0 as a timer pool is removed. ==== https://bugs.linaro.org/show_bug.cgi?id=2310[Bug 2310] The `odp_packet_copy()` API now correctly handles user areas between pools that are configured with different sized per-packet user area definitions. ==== https://bugs.linaro.org/show_bug.cgi?id=2571[Bug 2571] Corrects the implementation of AES GCM decryption in the ODP crypto API. === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=2309[Bug 2309] The Timer validation test fails sporadically in environments with high core counts. == OpenDataPlane (1.11.0.0) ODP v1.11.0 is the base tag and branch for the Monarch LTS (Long Term Support) release of ODP. === New Features ==== APIs As part of the final Monarch LTS API set, a minor change to the `odp_tm_egress_t` struct was made to better reflect the capabilities of SoC platforms targeting Monarch support. This change adds the boolean `egress_fcn_supported` that indicates whether TM systems support an egress function. In addition, each TM system is now associated with a PktIO rather than a PktOUT queue. This struct is input to the `odp_tm_create()` API and output from the `odp_tm_find()` API. ==== Strict Priority (SP) Scheduler Building on the modular scheduler framework introduced in v1.10.1.0, An alternate Strict Priority (SP) scheduler is now available. The SP scheduler is selected when ODP is configured with the `--enable_schedule_sp` option. The SP scheduler is designed to favor low-latency processing of high priority work at the expense of throughput. This is considered experimental code at this point and should be treated as such by those wishing to use it. === Bug Fixes ==== Scheduler PktIO Cleanup The scheduler now properly cleans up PktIOs operating in SCHEDULE mode following `odp_pktio_close()` calls. This resolves https://bugs.linaro.org/show_bug.cgi?id=2301[Bug 2301]. ==== Chksum Routine C++ conformance The odph_chksum() helper routine is now C++ conformant. This resolves https://bugs.linaro.org/show_bug.cgi?id=2302[Bug 2302]. ==== User Area Copying The `odp_packet_copy()` API now copies the packet user area as part of its processing and the packet validation test has been enhanced to verify that this is done properly. This resolves https://bugs.linaro.org/show_bug.cgi?id=2310[Bug 2310]. ==== Use of Pool 0 as a Timeout Pool The internal definition of `ODP_TIMEOUT_INVALID` was changed in `odp-linux` to enable the use of Pool 0 as a timeout pool. This resolves https://bugs.linaro.org/show_bug.cgi?id=2316[Bug 2316]. === Packaging ==== libodphelper To facilitate API tracking, `libodphelper.so` has been split out from `libodp.so`. ==== Helper dependencies To avoid circular dependencies that cause issues when packaging ODP as a shared library, the `odp-linux` implementation no longer makes and use of the ODP helper library. === Performance Performance enhancements in the `odp-linux` reference implementation have been made in PktIO routines and the packet classifier. === General Cleanup General cleanup throughout has resulted in adding proper termination calls to ODP examples as well as miscellaneous Doxygen corrections. Additionally, the `odp-linux` code base has been cleaned up by removing "To Dos" as well as extraneous `#includes` for extra C headers and dependencies on linux headers for improved portability. === Validation ==== Queue Capability Test The Queue validation test now properly exercises the `odp_queue_capability()` API and attempts to create the maximum reported number of supported queues. ==== Platform Tests The platform-specific tests have been moved from `platform/linux-generic/test` to `test/platform/linux-generc` so that all tests are now found under a single `test` directory. === Examples The ODP `examples` directory has been cleaned up and numerous corrections to existing examples have been made to add proper termination paths, etc. In addition, a new "hello world" example (`odp_hello.c`) has been added that illustrates the basic startup and shutdown steps needed for all ODP applications. As a simple stand-alone application is is also a good initial build tests for new ODP implementations. === Documentation ==== Pure API Guide The Doxygen API guide has been split so that both a "pure" version that is platform-independent and retains unresolved ODP abstract types as well as an implementation-specific version (for `odp-linux`) that shows platform-specific `typedef` and `enum` values. ==== Implementation Guide Improvements The _ODP Implementer's Guide_ has been enhanced with a section on implementation considerations, including issues surrounding the definition of Application Binary Interfaces (ABIs). === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=2309[Bug 2309] The timer validation tests have seen occasional failures when run on systems containing a larger number of CPUs (typically 24 or more). ==== https://bugs.linaro.org/show_bug.cgi?id=2386[Bug 2386] ODP cannot be compiled using the -m32 option to generate 32-bit code on a 64-bit platform when using GCC 4.9 (the default GCC found in Ubuntu 15.04). This is due to a known bug in GCC 4.9 and is closed as a permanent restriction. ==== https://bugs.linaro.org/show_bug.cgi?id=2402[Bug 2402] Doxygen generates a warning for `ODP_BIG_ENDIAN_BITFIELD` when compiling on little endian systems. A similar warning for `ODP_LITTLE_ENDIAN_BITFIELD` is issued when compiling on big endian systems. ==== https://bugs.linaro.org/show_bug.cgi?id=2444[Bug 2444] The traffic manager cannot be used with two PktIOs simultaneously. That is, `odp-linux` does not properly support applications that create more than one TM system. This is a bug in the `odp-linux` implementation that will be corrected. It is not a limit of the architecture or other ODP implementations. ==== https://bugs.linaro.org/show_bug.cgi?id=2449[Bug 2449] Packet queue pool causes out-of-bounds accesses. This is closely related to https://bugs.linaro.org/show_bug.cgi?id=2444[Bug 2444] and reflects that `odp-linux` does not properly support multiple TM systems. This is scheduled for correction in the first maintenance update for this ODP implementation. == OpenDataPlane (1.10.1.0) === New Features ==== APIs ODP v1.10.1.0 is a maintenance release and as such introduces no new APIs or other changes that might result in application source incompatibility with v1.10.0.0. ==== Modular Scheduler The ODP scheduler included as part of the `odp-linux` reference implementation has been modularized to support a "pluggable" architecture that will permit the easy introduction of alternate scheduler implementations that permit both easy experimentation as well as alternate scheduling models that are tuned to specific application workloads (_i.e.,_ a strict priority scheduler for latency-sensitive workloads). Included in this release is the just the foundation and alternate schedulers are expected to be added in future ODP releases. === Packaging ==== Rename of `linux-generic` to `odp-linux` While the platform name within the ODP git repository remains `linux-generic`, the package name of this reference implementation has been changed to `odp-linux` to better reflect that this is an implementation of ODP that is dependent only on the Linux kernel and is intended to be runnable on any Linux distribution. All ODP documentation has been changed to reflect this name change. === Helpers ==== Introduction of "agnostic" threading support The current helper APIs for linux pthreads (`odph_linux_pthread_create()`, etc.) and processes (`odph_linux_process_fork()`, etc.) have been augmented with a new "agnostic" set of helper routines for general ODP thread management. `odph_odpthreads_create()` and `odph_odpthreads_join()` are now the preferred helpers to use for creating and joining threads that may be implemented as _either_ pthreads or Linux processes. Although currently ODP threads in Monarch are assumed to share the same (single) address space, this change is to permit evolution towards multi-address space (_i.e.,_ process oriented) threading models without requiring application and/or validation test changes. The various ODP examples and validation tests that make use of threading have all been changed to new these new helper APIs. ==== Thread affinity APIs As part of the new "agnostic" threading support, two additional helper APIs (`odph_odpthread_getaffinity()` and `odph_odpthread_setaffinity()`) have been added to permit easy management of thread affinity. The CUnit framework used by the ODP validation suite has been changed to set the affinity of the initial thread to the first available control CPU. This avoids inconsistencies in a number of timing tests. === Bug Fixes As a maintenance release, numerous bugs have been fixed in the `odp-linux` reference implementation in areas such as platform support (particularly on 32-bit systems), compiler support (clang), C++ compatibility, and other cleanup items. Highlights include: ==== 32-bit platform support The `configure` utility now correctly identifies and sets variables needed for proper compilation on 32-bit x86 systems. In addition the Traffic Manager now executes properly on 32-bit systems. ==== Timer improvements The `odp_timer_t` abstract type is now strongly typed for consistency with other ODP types, and the `odp_timer_to_u64()` and `odp_timer_pool_to_u64()` APIs are now properly implemented. In addition, an issue with compiling the timer routines on 32-bit systems using clang was resolved. ==== Scheduler fairness The default scheduler has been improved to avoid starvation and increase fairness when running with a limited number of threads or CPUs. ==== 128-bit atomics The `-mcx16` compiler option is now properly identified and used to support 128-bit atomics on systems that support these operations. This leads to increased efficiency in the implementation of both timers as well as other atomic operations. ==== Use of hugepages In systems that support multiple hugepage sizes, the default hugepage size is now reported properly by the `odp_sys_huge_page_size()` API. ==== Coverity and Valgrind issue cleanup Numerous issues identified by the Coverity scan tool have been cleaned up and resolved, leading to improved robustness in the `odp-linux` reference implementation. In addition, several memory leaks identified by the valgrind tool have been fixed. ==== Validation test resource checks The Traffic Manager validation test has certain sub-tests that require a minimum of 2 CPUs to operate properly. These tests are now skipped with a warning when run on uniprocessor systems. === Performance Performance enhancements in the `odp-linux` reference implementation have been made in packet processing, classification, and pktio, leading to increased observed throughput and packet handling rates. === Examples A new `l2fwd_simple` example has been added that does simple Layer 2 forwarding. === Documentation ==== Switch from AsciiDoc to AsciiDoctor To get better formatting capabilities and future extensibility the ODP user documentation system has been switched from http://asciidoc.org[AsciiDoc] to http://asciidoctor.org[AsciiDoctor]. There are a handful of notable changes as a result of this. Those submitting documentation patches should be aware of the following: * `monospace font` is now indicated by demarking the text with backticks (`) rather than plus signs (+). * Callouts are now indicated by C++-style double slash comments (// <1>) instead of C-style comments (/* <1> */). So, for example writing ----------------------------------------------- [source,c] ---- ...some great code deserving a callout // \<1> ---- <1> This is an example of a callout ----------------------------------------------- yields: ---- ...some great code deserving a callout // <1> ---- <1> This is an example of a callout Note that this change only affects user documentation. Code documentation still uses http://doxygen.org[Doxygen]. ==== Image Cleanup The images in the user guide have been trimmed to fit the page better. In addition, many new images have been added to better illustrate ODP API usage. ==== Additional User Documentation for Monarch APIs The *ODP User's Guide* has been updated to include new sections documenting the use of the full Monarch packet APIs as well as the Timer APIs. In addition, the crypto, classification, and traffic manager API documentation has been improved to cover all of the latest Monarch features, and an introductory section on overall ODP packet flow architecture has been added. ==== Helper Documentation The ODP Helper library now has its own document that describes these additional functions of use to ODP applications and validation tests. ==== Other documentation The Process Guide, FAQ, CONTRIBUTING, and CHANGELOG files have been reworked for the new AsciiDoctor structure, leading to a more uniform method of presenting ODP support documentation. In addition, an option for generating both a "pure" ODP API document that defines the APIs in their implementation-independent forms as well as their implementation-dependent forms for the `odp-linux` reference implementation is now available. === Known Issues ==== https://bugs.linaro.org/show_bug.cgi?id=2301[Bug 2301] The scheduler does not remove PKTIN queues following `odp_pktio_close()` ==== https://bugs.linaro.org/show_bug.cgi?id=2309[Bug 2309] The timer validation tests have seen occasional failures when run on systems containing a larger number of CPUs (typically 24 or more). == OpenDataPlane (1.10.0.0) === New Features ==== General * Move to capabilite structures: The classification, crypto, pktio, pool, queue, shared memory, and traffic manager areas all add new APIs to query implementation-specific capability limits for enhanced program portability. ==== Classification * Addtion of a structure that defines system level classification capability * Addition of range PMRs to complement the existing value PMRs to permit application to specifiy classification rules over a range of values. ==== Cryptography * Provides a way to get the available cipher and authentication algorithms. ==== Debug * Adds the ODP_STATIC_ASSERT() API to permit compile-time assertions. ==== Packet * Rename and add new packet copy and move functionality. * Add packet prefetch API for performance optimization. * New APIs to permit packet headroom and tailroom to be extended to additional segments or truncated as needed. * Align an area of packet data (e.g. IP/UDP headers) so that it is contiguous in memory and starts in a specified minimum alignment. * Add packet time stamp metadata support. * Add packet input index metadata support to allow application context to be anchored from the associated interface that received the packet. * Deprecation and removal of segment-level buffer APIs that are now superseded by additional packet-level manipulation APIs discussed above. ==== Packet io * Replaced config definition for maximum pktio entries with maximum packet IO index call * Added the classify_enable bit to the odp_pktin_queue_param_t that allows applications to explicity control which pktin queues are subject to full classifier support. * Addition of pktin configuration options to control packet timestamping and checksum validation processing. * Addition of pktout configuration options to control packet checksum offload processing. * Add the ability to query (via capabilties) whether a pktio interface supports operating in loopback mode and if so to enable/disable this mode of operation. * Round out the polling APIs be adding the ability to receive packets in poll mode from one or more pktin queues with timeout. * Add the ability to set the pktio interface index for ease of setting up application context areas associated with each pktio. * Add the ability to inqure the timestamp resolution associated with pktio interfaces that support packet timestamping. ==== Queue * Add a queue capability API to query system-wide queue capabilities and limits. * Extend queue context with an explicit data length parameter that serves as a performance hint for the amount of context to prefetch when the scheduler selects an event from a scheduled queue. ==== Scheduler * Add the ability to query information about a defined scheduler group ==== Shared Memory * Add a capability inquiry API to obtain implementation shared memory limits. ==== Traffic Manager * Add a capability inquiry API to obtain implementation traffic mngr limits. * Split TOS marking into two separate calls. * Add new APIs to support VLAN, ECN, and drop precedence marking. * Add destroy APIs for shapers, scheduler profiles, threshholds, WRED profiles, TM queues, and TM nodes for symmetry and completeness to allow applictions to terminate gracefully without resource leakage. * Add the ability to disconnect TM queues from their fanouts. * Add TM node contexts to permit applications to anchor user context areas to TM nodes. * Add the ability to query info about TM node fanins and TM queues. * Deprecate and remove the odp_tm_periodic_update() API ==== Utilities/Helpers * More complete and correct checksum implementation === Known Issues == OpenDataPlane (1.9.0.0) === New Features * A focus has been made on improving the packaging support of ODP for distributions such as Debian. * Improved creation of source tar ball and packaging scenarios moved to https://git.linaro.org/lng/odp-packaging.git * Renamed libodp to libodp-linux * Removed all internal functions from leaking through the libodp-linux === Known Issues Time and Traffic Manager validation tests sometimes fail on heavy loaded systems. This behaviour depends on time accuracy measurements, which depends on system load. //// opendataplane (1.8.0.0) * API: - api headers moved to include/odp/api/spec/ and apps should use include/odp_api.h now instead of odp.h - api/linux-generic/example: classification: add pmr create api - api: move include/odp.h to include/odp_api.h - api: odp.h to ease transition period - api: packet: add bcast/mcast parse documentation - api: packet: add detailed packet error flags - api: packet: added multicast flags - api: pktio: add pktout event queue - api: pktio: added pktio info structure - api: pktio: added supported set operations bit mask to pktio capability - api: pktio: changed odp_pktio_mtu() return value to uint32_t - api: pktio: define default pktio modes - api: pktio: define default queue configuration - api: pktio: remove old single queue API - api: pktio: rename pktio_recv_queue to pktin_recv - api: pktio: rename pktio_send_queue to pktout_send - api: pktio: specify when queue config is called - api: queue: remove queue type pktin and pktout - api: sched: define default sched param values - api: time: fix typo for cmp function - api: tm: add tm API definitions - api: tm: replace pktio with pktout_queue in odp_tm_egress_struct - doc: users: migrate TM from API to users doc - drv: creation of the driver interface (drv) * ODP docs: - doc: depend the docs on the images - doc: descr of structure for new interfaces - doc: drop using output dir for guides - doc: glossary: defining ODP thread more precisely - doc: images: add traffic manager svg - doc: implementers-guide: adding drv interface - doc: removing invalid characters - doc: update to latest ax_prog_doxygen.m4 - doc: use imagedir attribute for path - doc: user-guide documentation for classification - doc: user-guide: fixing other typos - doc: user-guide: shmem - doc: users: add TM example - doc: users: migrate TM from API to users doc - documentation: userguide: add images for packet processing - documentation: userguide: add packet processing description * Validation - linux-generic: version: added implementation name string - performance: crypto: add odp_crypto to .gitignore file - test: l2fwd: add event queue packet output - test: l2fwd: add option to give destination MAC - test: l2fwd: fix test getting stuck in DIRECT_RECV/POLL_QUEUE mode - test: l2fwd: utilize pktio param defaults - test: performance: crypto: measure crypto operation performance - test: pktio_perf: finalize port to use new pktio api - test: pktio_perf: port to use new pktio api - validataion: packet: add tests for broadcast and multicast flags - validation: classification: add test case for odp_cos_drop() function - validation: classifier: port to use new pktio api - validation: packet: test if user area is properly set - validation: pktio: add output event queue tests - validation: pktio: assign MAC address if one loop pktio is used - validation: pktio: check if configuring promisc mode is supported before testing - validation: pktio: fix pktio_test_recv_queue() crash - validation: pktio: fix type on defining pktiout mode - validation: pktio: port to use new pktio api - validation: pktio: replace pktio_test_jumbo() with pktio_test_recv_mtu() - validation: pktio: set packet mac addresses and checksum in statistics test - validation: scheduler: increase delay tolerance - validation: tm: add cunit test for traffic mngr - validation: tm: fix arm compilation - validation: tm: miscellaneous cleanup and fixes for tm cunit tests * General: - linux-generic: Makefile: fix broken include path - linux-generic: pktio: initial dpdk pktio implementation - linux-generic: dpdk: add dpdk_setup_port() - linux-generic: dpdk: add functions for fetching packet input/output queues - linux-generic: dpdk: add get/set functions for mtu, promisc mode, and capability - linux-generic: dpdk: add odp_pktio_input_queues_config() - linux-generic: dpdk: add odp_pktio_link_status() - linux-generic: dpdk: add odp_pktio_output_queues_config() - linux-generic: dpdk: add rx/tx locking - linux-generic: dpdk: close resources in odp_pktio_close() - linux-generic: dpdk: handle ixgbe_pmd minimum burst size - linux-generic: drv: creation of the driver interface (drv) - linux-generic: fix usage of function strncpy - linux-generic: loop: avoid packet table overflow - linux-generic: move CPU info dummy data to generic default file - linux-generic: netmap: add support for VALE and pipe virtual ports - linux-generic: netmap: bump up link wait timeout to 10 secs - linux-generic: netmap: improve single RX queue performance - linux-generic: netmap: increase maximum descriptor count - linux-generic: netmap: support 'netmap:' interface name prefix - linux-generic: packet: implement broadcast and multicast metadata flags - linux-generic: packet: implement parser extensions for broadcast and multicast - linux-generic: pktio: add dpdk pktio build support - linux-generic: pktio: add link_status handler for loop interfaces - linux-generic: pktio: add separate functions for global and local init - linux-generic: pktio: allow num queues request on disabled pktio - linux-generic: pktio: allow recv on stopped interface - linux-generic: pktio: pktout event queues - linux-generic: pktio: set pktio capability supported set operations flags - linux-generic: pktio: simplify callback interface - linux-generic: pktio: use unique names for pktin event queues - linux-generic: pool: implement user area init support - linux-generic: queue: simplify NULL param handling - linux-generic: return error for unsupported pktio calls - linux-generic: separate MIPS ODP_CACHE_LINE_SIZE to its arch file - linux-generic: separate PowerPC ODP_CACHE_LINE_SIZE to its arch file - linux-generic: separate x86 ODP_CACHE_LINE_SIZE to its arch file - linux-generic: sysinfo clean up for ARM - linux-generic: systemcpu(): use input parameter instead of global data - linux-generic: test: add tm unit test to list of tests to run - linux-generic: tm: Add missing name table initialization call. - linux-generic: tm: fix numerous bugs in timer wheel and main tm implementation - linux-generic: tm: implement traffic manager - linux-generic: tm: remove not used includes of odp_api.h - linux-generic: tm: use intermediate casts to avoid strict warnings - linux-generic: tm: use odp_hash_crc32c() api to avoid arch issues - linux-generic: use one uniform call systemcpu() - linux-generic: validation: add netmap test - linux-generic: version: added implementation name string * Helper: - helper: eth: added mac address parse - helper: ip: added ipv4 address parse - helper: linux: correct cpumask usage - helper: linux: remove unnecessary cpumask copy - helper: remove odp_ definitions - helper: remove ring code - helpers: remove odp_ prefix for tests source files - tests: use parse mac and ip address helpers opendataplane (1.7.0.0) * API: - api: atomic: add non-relaxed 64bit operations - api: atomic: added 32 bit acquire and release - api: atomic: added 32bit cas_rel and cas_acq_rel - api: atomic: added atomic min and max - api: atomic: added atomic_lock_free_u64 - api: atomic: added cas operations - api: atomic: added relaxed exchange operation - api: atomic: init functions are not atomic - api: atomic: rename release ordering - api: classifier: align enum type naming - api: cpu: add new API to get CPU max frequency - api: cpu: add new API to get per-CPU current frequency - api: cpu: add new API to get per-CPU max frequency - api: cpu: add new API to get per-CPU model string - api: cpu: added pause call - api: cpu: make frequency API return 0 on failure - api: cpumask: add new API odp_cpumask_all_available() - api: cpumask: documented string format - api: define pktio statistics api - api: endian: rename endian types with odp_ prefix - api: errno: any odp function can set errno - api: init: align enum type naming - api: init: removed platform_init struct definition - api: pktio: added direct queue receive - api: pktio: added direct send to pktio output queue - api: pktio: added link status - api: pktio: added multiple pktio input queues - api: pktio: added multiple pktio output queues - api: pktio: added pktio capability struct - api: pktio: refine multiqueue API spec - api: pktio: remove unused ODP_PKTIO_ANY - api: pktio: rename pktio modes - api: pool: allow per-thread caching - api: queue: define queue type as enum - api: queue: moved queue type into queue parameters - api: queue: rename QUEUE_TYPE_POLL to _PLAIN - api: sched: rename SCHED_SYNC_NONE to _PARALLEL - api: schedule: clarify scheduler API documentation - api: stdlib: added odp_memcmp - api: sysinfo: move CPU Hz API to cpu.h - api: sysinfo: move CPU model API to cpu.h - api: thrmask: documented string format - api: pktio: rename single_user param - api: pktio: renames for compact type and func names - api: queue: add enq and deq mode params * ODP docs: - doc/users-guide: add time API section - doc/users-guide: add cryptographic services section - doc: userguide: add application programming section - doc: process-guide: add release process - doc: images: replace overview with editable svg src - doc: guides: embed icons and images in html - doc: re-organize doxygen doc for synchronizer * Validation - test/performance: pktio: perform an initial warmup run - test: change l2fwd pool size - test: l2fwd: added poll queue mode - test: l2fwd: re-organize functions - test: l2fwd: use multi-queue API for scheduled queues - test: l2fwd: use multi-queue pktio in direct mode - test: l2fwd: use multiple queues in sched mode - test: perf: l2fwd detect missing odp_generator - test: update CPU Hz calling functions - tests: harmonize posix extensions level defines - validation: atomic: added cas test - validation: atomic: added lock free op test - validation: atomic: added max and min tests - validation: atomic: added non-relaxed test - validation: atomic: added xchg test - validation: classification: add additional PMR term - validation: classification: adds Test case for ODP_PMR_DIP_ADDR - validation: classification: remove double frees - validation: cls: adopt for supported l3 PMR - validation: cls: assign default CoS before creating chain - validation: cls: use correct MAC addresses - validation: define ODP_TEST_INACTIVE and ODP_TEST_ACTIVE - validation: implement pktio statistics counters - validation: pktio: don't continue if packet with > MTU is sent - validation: pktio: fix check of pktio_stop() called twice - validation: pktio: fix typo on setting in_mode - validation: pktio: reduce stdout noise - validation: pktio: test batch receive - validation: pktio: use odp_time_ns() instead own function - validation: pktio check for number of interfaces - validation: pktio: add test for odp_pktio_recv_queue() and odp_pktio_send_queue() - validation: pktio: add test for odp_pktout_queue_config() - validation: pktio: add test for odp_pktin_queue_config() - validation: possibility to inactive preconded test - validation: queue: add test for odp_queue_to_u64() - validation: remove remaining references synchronizers - validation: removing synchronizers tests - validation: scheduler: add timing tests for scheduled queue types - validation: shmem: sync threads with barrier - validation: stdlib: add odp_memcmp test - validation: synchro tests split into 3 groups - validation: system: add validation for new CPU APIs - validation: system: add validation tests for odp_cpu_cycles_ calls - validation: system: fix return code for checks - validation: system: make odp_cpu_hz optional in validation test - validation: system: make odp_cpu_hz_id conditional - validation: test odp_pktio_link_status() - validation: time: increase limit to check to 2 res - validation: time: round up resolution - validation: time: store local and global resolution - validation: timer: fix delay after loop - validation: timer: handle early exhaustion of pool * General: - linux-generic: add packet_io_stats.h to Makefile.am - linux-generic: arch: renamed cpu arch files - linux-generic: atomic: 32bit cas_rel and cas_acq_rel - linux-generic: atomic: implemented exchange - linux-generic: atomic: non-relaxed 64bit operations - linux-generic: barrier: use API memory barrier - linux-generic: classification: implement verify_pmr_dmac - linux-generic: cpu: implemented pause - linux-generic: define posix extension level once - linux-generic: init: handle local/global init/term cleanly - linux-generic: locks: replace internal atomics - linux-generic: netmap: add functions for fetching pktio queues - linux-generic: netmap: add initial multi queue support - linux-generic: netmap: add netmap_close_descriptors() function - linux-generic: netmap: add netmap_link_status() function - linux-generic: netmap: add odp_pktio_capability() - linux-generic: netmap: add odp_pktio_link_status() - linux-generic: netmap: add odp_pktio_start() - linux-generic: netmap: add scheduler multi-queue support - linux-generic: netmap: add start()/stop() functionality - linux-generic: netmap: disable debug prints - linux-generic: netmap: fix MTU size - linux-generic: netmap: fix netmap_mtu_get() - linux-generic: netmap: implement pktio statistics - linux-generic: netmap: map rings in netmap_start - linux-generic: netmap: odp_pktio_recv() from all pktin queues - linux-generic: netmap: use select() instead of poll() in recv - linux-generic: packet: hide frame_len behind accessor - linux-generic: packet_io: expose pktio_tbl and is_free() - linux-generic: packet_io: fix array indexing in pktin_deq_multi() - linux-generic: packet_io: separate locks for RX/TX - linux-generic: pcap: implement pktio statistics counters - linux-generic: pktio loop: implement statistics counters - linux-generic: pktio: add RSS helper functions - linux-generic: pktio: added poll type input queue - linux-generic: pktio: added scheduler multi-queue support - linux-generic: pktio: dummy multi-queue pktio - linux-generic: pktio: enable using PKTIO_MAX_QUEUES in pktio implementations - linux-generic: pktio: implement odp_pktio_link_status() - linux-generic: pktio: print out the name of pktio used - linux-generic: pktio: re-organize queue config code - linux-generic: pktio: remove unwanted initialisation - linux-generic: pktio: use multiqueue recv internally - linux-generic: pool: accelerate buffer allocation marking - linux-generic: pool: catch duplicate free errors in debug builds - linux-generic: queue: check invalid handle in odp_queue_destroy - linux-generic: remove direct include of endian.h from byteorder.h - linux-generic: remove direct include of stdint.h by atomic.h - linux-generic: remove direct include of stdlib.h by timer.h - linux-generic: removed spin_internal - linux-generic: scheduler: improve pktio polling - linux-generic: sockets: implement pktio statistics - linux-generic: sysinfo: apply per-CPU implementation to MIPS - linux-generic: sysinfo: apply per-CPU implementation to PowerPC - linux-generic: sysinfo: make the cpu_hz per-CPU data - linux-generic: sysinfo: make the model_str per-CPU data - linux-generic: sysinfo: move ARM system info codes to default arch file - linux-generic: sysinfo: move MIPS system info codes to its plarform file - linux-generic: sysinfo: move PowerPC system info codes to its plarform file - linux-generic: sysinfo: move cpu_arch_str to odp_system_info_t - linux-generic: sysinfo: move x86 system info codes to its plarform file - linux-generic: sysinfo: rename odp_cpu_hz_current with odp_ prefix - linux-generic: sysinfo: rename variable cpu_hz to cpu_hz_max - linux-generic: sysinfo: revise odp_cpu_hz() to return current frequency - linux-generic: sysinfo: set values for cpu_arch_str - linux-generic: sysinfo: update dummy function to pass validation - linux-generic: sysinfo: use uniform call odp_sysinfo_parser - linux-generic: timer use SIGEV_THREAD_ID - linux-generic: timer: limit notification about resolution incorrectness - linux-generic: timer use SIGEV_THREAD_ID - linux-generic: update CPU Hz calling functions opendataplane (1.6.0.0) * API: - api: atomic: clean atomic API documentation - api: clib: added standard c library api - api: hash: Added crc32 and crc32c hash functions - api/linux-generic: classification: rename odp_drop_e to odp_cls_drop_t - api/validation/linux-generic: classification: implement class of service create api - api: time: add global time API - api: time: add resolution and wait API calls - api: time: make odp_local_time to be monotonic wall time - api: init: allow implementation to use private ways for its own configuration - api: classification: add odp_cls_cos_pool_set() api - api: doc: re-organize doxygen doc for synchronizer - api: rwlock_recursive: added recursive rwlock - api: spinlock_recursive: added recursive spinlock - api: crypto: Add AES128-GCM support - api: thread: added THREAD_COUNT_MAX define - api: thrmask: correct specification error - api: pktio: add odp_pktio_print() API - api: version: added implementation name str - api: sync: removed odp_sync_stores - api: barrier: added memory barriers * ODP docs: - doc/users-guide: add time API section - doc/users-guide: add cryptographic services section - doc: userguide: add application programming section - doc: process-guide: add release process - doc: images: replace overview with editable svg src - doc: guides: embed icons and images in html - doc: re-organize doxygen doc for synchronizer * Validation - api/validation/linux-generic: classification: implement class of service create api - api: hash: Added crc32 and crc32c hash functions - classification: add odp_cls_cos_pool_set() api - classification: adds additional ASSERTS for stability - classification: check return value of pktio stop - classification: start pktio after setting inq and stop it before removing it - classification: stronger checks to avoid SEGV on pktio failure - crypto: add test for AES128-GCM - crypto: allow custom auth/cipher range - crypto: support validating both cipher and auth at the same time - performance: pktio_perf: use odp_time_wait_ns() function instead of looping - performance: sched: use ODP time API instead of clock_gettime - performance: set a packet rate pass threshold for l2fwd - pktio : Fix UDP checksum computation - pktio: ability to wait for external network - pktio: add customizable out mode for pktios - pktio: add test for start when started and stop when stopped() - pktio: add tests for rrecv() on WONLY, and send on RONLY pktios - pktio: initialize mac addresses for all packets - pktio: refactor error handling during sequence check - pktio: remove unneeded stop as interface is stopped after open() - pktio: stop interfaces before removing the default inq - pktio: test odp_pktio_print() - queue: refactor test to avoid coverity issues - sched: improve scheduler validation test to check sched time correctly - scheduler: use fail timeout when waiting on events in chaos - std_clib: added validation tests - synchronizers: add missing rwlock read lock functional test - synchronizers: add recursive lock tests - test/example: use local time API as wall time - test: performance: pktio: don't use direct arithmetic operations with odp_time_t - time: add test convertsion on 0 - time: add test for odp_time_local_res() and use resolution - time: add test for odp_time_wait_ns() and odp_time_wait_until() - time: don't assign int directly to odp_time_t - time: test time constants in ns - time: update to tes global time API - validation: time: align tests with current time API * General: - align with new wall time API - classification: add null check for pool assigned to CoS - classification: define pkt_addr as const - classification: implement class of service create api - classification: implements odp_cls_cos_pool_set() api - classification: rename odp_drop_e to odp_cls_drop_t - clib: added standard c library api - crypto: Add AES128-GCM support - fix tap compilation - hash: Added crc32 and crc32c hash functions - include netmap headers with -isystem - odp_time: don't use cpu cycle API to get time - packet: _odp_parse_common: arm build fix - pktio: add odp_pktio_print() API - pktio: add tap pktio type - pktio: add test for tap pktio - pktio: check for pktio_start when started and pktio_stop when stopped - pktio: check interface mode is compatible before receiving or sending - pktio: configuration functions check that interface is stopped - queue: fix memory corruption in reorder_enq() - rwlock_recursive: added recursive rwlock - schedule: set sched_local.pool correctly - schedule: use schedule time in ns - socket: set up __odp_errno on ioctl failures - spinlock_recursive: added recursive spinlock - thread: added THREAD_COUNT_MAX define - thread: removed internal max threads define - time: add global time API - time: add resolution and wait API calls - time: remove posix bleed through on odp_time_t - timer: include event_types instead of buffer_types - validation: pktio: report test as skipped when setup fails - validation: run config tests opendataplane (1.5.0.0) * API: - api: buffer: add functions to alloc/free multiple buffers at once - api: cpu: change order of arguments for diff function - api: crypto: add AES128-CBC encrypt/decrypt methods - api: crypto: add HMAC-SHA-256-128 support - api: crypto: move enums from platform types to odp and rename to fit the API format - api: packet: add functions to alloc/free multiple packets at once - api: queue: add odp_queue_info() function to retrieve queue information - api: time: change order of arguments for diff function - api: time: unbind CPU cycles from time API * ODP docs: - userguide: add baseline overview to document - images: add additional user guide images - implementers-guide: convert to ODP standard layout - implementers-guide: fix broken doxygen build from tarball - users-guide: move EXTRA_DIST down to its makefile - Makefile: add docs to the tarball - improve asciidoc presentation - users-guide convert to asciidoc - images: add resource_management.msc for users-guide - images: add svg for user-guide * Validation - performance: odp_pktio_perf: fix potential overflow in wait loop - test/example: avoid "cycle" word usage - ability to specify test install directory - buffer: add tests for buffer alloc/free multi functions - crypto: add test for AES128 CBC - crypto: add test for HMAC-SHA-256-128 - crypto: limit packet size to maximum supported by platform - packet: add tests for packet alloc/free multi functions - queue: api validation tests for odp_queue_info() - remove strict dependency on CUnit 2.1-3 - scheduler: add missing ticketlock unlock * General: - rpm packaging support - linux-generic: config: increase ODP_CONFIG_SCHED_GRPS to 256 - linux-generic: cpumask: warn that CPU0 is used by control and worker thread - linux-generic: packet: add implementation for packet alloc/free multi - linux-generic: pool: add buffer_alloc_multi function - linux-generic: pool: add implementation for buffer alloc/free multi - linux-generic: queue: add odp_queue_info() function - linux-generic: validation: add run-test script for post install testing - platform: move list of API files to Makefile.inc so it is common to all platforms opendataplane (1.4.1.0) * Validation - pktio: test transmit error recovery - schedule: add chaos test - check return code from odp_queue_lock_count() - scheduler: test ordered queue reorder processing - pktio: initialize queue parameters correctly - pktio: test for transmit error handling - pktio: add support for direct receive - pktio: pass interface index rather than name - pktio: fix start_stop test - test: l2fwd: separate rx and tx drop counters - test: l2fwd: increase burst size - test: l2fwd: optimize statistics usage - test: l2fwd: optimize queue mode - test: l2fwd: start pktios after worker thread create - test: l2fwd: added option to disable error check - example/ipsec: Increase ip_data_len for Tunnel mode - example: ipsec: check push_tail return code * General: - linux-generic: pktio: handle transmit errors correctly - pktio socket_mmap: recover from transmit errors but 1890 - pktio: increase MTU of loop interface - ordered queues: fix race condition during order release and out of order. - configure: move HAVE_PCAP AM_CONDITIONAL to configure.ac * ODP helper: - linux: checkpatch cleaning for helper/linux.c - linux: examine the cause for child process termination - linux: request SIGTERM if parent process dies opendataplane (1.4.0.0) * API: - ** Classification ** - odp_cos_set_queue() renamed to odp_cos_queue_set() - int odp_cos_set_drop renamed to odp_cos_drop_set() - new: odp_queue_t odp_cos_queue(odp_cos_t cos_id) - new: odp_drop_e odp_cos_drop(odp_cos_t cos_id) - ODP_PMR_CUSTOM_FRAME support in classification - odp_pmr_create() arguments passing change to use struct - odp_pmr_match_set_create() added id argument - ** Config ** - new: odp_config_...() API introduced instead of ODP_CONFIG_ defines - ** Cpu, Threads and Scheduler ** - new: uint64_t odp_cpu_cycles(void) - new: uint64_t odp_cpu_cycles_diff(uint64_t c1, uint64_t c2); - new: uint64_t odp_cpu_cycles_max(void); - new: uint64_t odp_cpu_cycles_resolution(void); - odp_cpumask_def_worker() renamed to odp_cpumask_default_worker() - odp_cpumask_def_control() renamed to odp_cpumask_default_control() - odp init extended with num worker and control threads - new: int odp_queue_lock_count(odp_queue_t queue); - refine api doc for scheduler and schedule orderd locks - argument of odp_schedule_order_lock() and odp_schedule_order_unlock changed to unsigned - new: int odp_thread_count_max(void) - ** Packet ** - new: uint32_t odp_packet_flow_hash(odp_packet_t pkt) - new: void odp_packet_flow_hash_set(odp_packet_t pkt, uint32_t flow_hash) - new: int odp_packet_has_flow_hash(odp_packet_t pkt); - new: void odp_packet_has_flow_hash_clr(odp_packet_t pkt); - ** Pktio ** - pktio can be configuread as receive or transmit only - pktio: refined api doc for start() and stop() - new: void odp_pktio_param_init(odp_pktio_param_t *param) * ODP docs: - implementers-guide: update names of test module libraries - implementers-guide: update section on skipping tests * Test framework - update README files - renaming module libs - add odp_cunit_update() to modify registered tests - add ability to mark tests inactive * Validation - ** Classification ** - Add fix for classification tests - remove redundant pool lookup function - remove redundant sequence number check - use tcp data offset field to calculate data offset - move destroy_inq() to common file - add odp_pktio_param_init() API - added additional suite to test individual PMRs - use a structure instead of many args for odp_pmr_create - Add init calls for queue parameters - syntax correction for CU_ASSERT - Add init calls for pool parameters - queue and drop policy API name change - Queue parameter init calls - ** Cpu, Threads and Scheduler ** - rename odp_cpumask_def to _default - schedule: revise definition of ordered locks - schedule: remove odp_schedule_order_lock_init() API - schedule: don't check schedule time on 0 - synchronizers: support a single worker - init: fix test when debug-print is disabled - ** Packet ** - packet: test flow hash - packet: test now handles pool that do not support segmentation - ** Pktio ** - pktio: don't call APIs with an invalid pktio handle - ** Config ** - config: removed ODP_CONFIG_MAX_THREADS - config: add CUnit tests for config APIs * Performance - l2fwd: add missing braces - l2fwd: add option to disable filling eth addresses - l2fwd: add support for using odd number of ports - l2fwd: fix crash when accuracy is set to 0 - l2fwd: add option to select scheduler queue type - l2fwd: add option to change destination eth addresses - l2fwd: obey -t in queue mode - l2fwd: fill correct source ethernet address - sched: update scheduling test to use cycle counts - odp_pktio_perf: fix potential overflow for burst_gap - odp_pktio_perf: fix potential overflow for send_duration * general: - classification: implement ODP_PMR_CUSTOM_FRAME matching - classification: queue and drop policy API name change - cpu: created arch dependent cpu_cycles files - cpu: fix cycle lost while cycle counter overflow - cpu: implementation for cycle count API - cpu: rename time_cycles to cpu_cycles - pktio: implemented pcap pktio - pktio: implemented netmap pktio - pktio: close all pktio when term is called - pktio: enable classifier only when needed - pktio: factor state management into packet_io - pktio: fill in L2 parse results by default - pktio: implement odp_pktio_param_init() API - packet: implement flow hash support - schedule: fix odp_schdule_wait_time - queue: change lock_index from uint32_t to unsigned to match API - queue: direct internal enqueues to target queue - queue: fix pktout_enqueue() logic - queue: remove obsolete prototypes - use cycles_diff for time API also opendataplane (1.3.0.0) * API: - codespell: correct spelling - event: change to odp_event_type_t - init: use const pointer types - packet_io: added odp_pktio_param_t - packet_io: added start and stop - packet_io: change word instance to interface - pktio: added output mode - pktio: rename pktio_input_mode enum - pool: add odp_pool_param_init prototype - pool: standardize description for odp_pool_param_init routine - queue: add odp_queue_param_init prototype - queue: clarify odp_queue_context_set() documentation - queue: rename queue context get/set for consistency - sched: added ordered context lock - sched: added release ordered - sched: added schedule group create and destroy - sched: added schedule prefetch - sched: added worker group - sched: add additional scheduler group APIs - sched: clarified synchronization context - sched: clarify usage of PRIO_DEFAULT - sched: moved scheduler types into new file - sched: removed GROUP_DEFAULT - sched: removed SYNC_DEFAULT - sched: rename order lock APIs and typedef - sched: schedule param - sched: config: add configuration for scheduler groups - schedule: fix comment typo - spelling fixes - style: init api: documentation clean up * ODP docs: - doc: implementers-guide: add validation description - doc: publish contributing text * ODP helper: - fix installation path for includes - linux: catch possible undefined - test: chksum: catch errors in scan_ip * test: * validation: - add test on unused retvals - use _CU_TEST_INFO() macro - system: fix uninitialised variable - schedule: add param init calls - schedule: test scheduler groups - test odp_pktio_start and odp_pktio_stop - fix build from tar source - kill odp_generator - removing current dir from -I * performance: - Makefile: add scripts to EXTRA_DIST - l2fwd: fix race condition between thread init and stat counter - l2fwd: capture test fails - odp_pktio_perf: use real MAC addresses while packet creation - odp_scheduling: remove redundant var inits - use odp_pool_param_init routine - use odp_queue_param_init routine * general: - Makefile.am: fix basename conflicts - Makefile: add all arch to the tarball - fix logic for calling pktio init and term functions - install missing headers - move default cpumask functions to separate file - move openssl checks inside linux-generic - move pthread checks inside linux-generic - add pktio_start and pktio_stop - pktio: add global init and term function for pktios - pktio: always test loop interface - pktio: handle segmented packet in socket mode - pktio: remove basic socket implementation - pktio: store errno correctly in setup - pool: add odp_pool_type_t enum - pool: implement odp_pool_param_init - queue: implement odp_queue_param_init routine - queue: implement ordered queues - remove linux-generic makefile generation from common configure.ac - schedule pktin_poll: account pktio stop state - schedule: implement scheduler groups - schedule: implement odp_schedule_prefetch() - schedule: implement ordered locks - Makefile.am: fix aclocal warning when building from tarball - m4: pthread: fix warning with Wextra - scripts/git_hash: change repo to CUSTOM_STR - scripts/git_hash: fix build from tar source - scripts: Makefile: add odp_version.sh to the tarball opendataplane (1.2.0.0) * API: - docs: doxygen grouping clean up and remove excess references to ODP - pool: remove shm paramter from odp_pool_create() - packet_io: clarify what happens when not all packets are sent - cpumask: added default masks and cpumask_setall - thrmask: added thread mask - thread: added thread type * ODP helper: - helper: convert to a library - remove helper dependence on ODP internals - helper: linux: check pthread_join return code - test checksum - helpers: fix udp checksum computation - test: helper: add process and thread tests - deleted odph_linux_cpumask_default * test: * validation: - tests execution moved to platfrom side - test: pktio_perf: add missing atomic init - test: synchronizers: use thread_id instead of cpu_id to detect slow threa - validation: pktio: do not dequeue from scheduled queue - test: pktio_perf: fix pthread_t offset for tx threads - packet_io: release unsent packets after odp_pktio_send() - validation: new module errno - test: pktio_perf: add missing ns to cycle conversion for busy loop - validation: classification: fix ODP_PMR_IPPROTO capability check - validation: scheduler: fix race condition in pause test - test: do not use negative array index - thread and cpumask validation suites - example:ipsec: Fix for Polled queues - scheduler: use number of workers - example: classifier: fix string overflow * general: - linux-generic: put pktio types to separate files with common interface. - configure: use stricter warnings - linux-generic: timer: use timer handles as buffer handles - linux-generic: buffer: remove unneeded division/module when mapping within the first segment - linux-generic: pool: use ODP_CONFIG_PACKET_SEG_LEN_MIN correctly - queue: handle return value of odp_queue_enq() - linux-generic: classification: add support for ODP_PMR_IPSEC_SPI - add {EXEEXT} suffix to binaries - event: implement odp_event_free() - packet_socket: do not release packets in odp_pktio_send - linux-generic: packet: fix byte order in IPv6 header parsing - linux-generic: schedule: fix double free - linux-generic: buffers: correct segment length calculation for packets - linux-generic: timer: set timer queue to ODP_QUEUE_INVALID on init - linux-generic: buffer: reduce field size and reorder for better packing - linux-generic: crypto: eliminate buffer type hack for completions - linux-generic: pool: remove double init - linux-generic: pool: group and document pool statistics - platform: Makefile.inc: use `` instead of != for compatibility with older versions of Make - linux-generic: packet: Add lazy parsing support - linux-generic: buffer: init all the odp_buffer_bits_t struct to avoid valgrind warnings opendataplane (1.1.0.0) * API: - style: moved pool type first in pool_param - style: pool_param doxygen comments - api: packet: removed odp_packet_user_u64 - api: packet: rename user_data to user_area - api: pktio: Clarify doc on default pool usage on odp_pktio_open - timer: Add missing platform handles to u64 conversion functions - api/linux-generic/example/validation: remove odp_pmr_create_range() function definition - api: packet: relax return code to use non-zero for true - api: packet/pool: proposed APIs for packet user metadata * test: * validation: - validation: packet: add user metadata tests - test: pktio: add missing atomic init - test: use CU_ASSERT_FATAL in case odp_buffer_alloc failed to avoid segfaults - validation: pktio: fix polling tests - validation: tests for module odp_ver_abt_log_dbg - validation: rename executable to match modules * general: - linux-generic/odp_impl: add implementation version details - linux-generic: support running with restricted cpu set - linux-generic: packet: add user metadata support - linux-generic: pool: add user metadata support - linux-generic: buffer: restructure user mdatadata fields - linux-generic: use inttypes defines to print (u)int32_t values opendataplane (1.0.4) * test: * validation: - synchronizers: fix init of custom barrier atomic - pktio: don't pass invalid handles - use PRIu32 instead of %u to print uint32_t variables - thread: add odp_thread sunnyday tests - classification: add missing init of atomic variable - api_test: remove odp_shm_test * performance: - pktio: fix check for pktio_tx - pktio: test return value of odp_pktio_close() - pktio: add throughput test * example: - ODP classifier example * bugs: - example: timer: clean up prescheduled events * general: - api: time: force time defines as ULL to avoid computation overflows on 32bits systems - linux-generic: packet_io: init l2 and l3 cos table spinlocks - linux-generic: pool: initialize atomics during odp_pool_init_global - linux-generic: pool: fix initialization of odp_buffer_hdr ref_count - doc: api_guide_lines: add guidance on ODP_DEPRECATED opendataplane (1.0.3) * test: * validation: - validation: add new test l2fwd_run - validation: sched: add missing copyright - validation: move l2fwd from example to performance tests - validation: implement platform env - validation: crypto: combine sync and async tests - validation: crypto: handle synchronous operations in async test - test: enable valgrind check - test/README: explain what's the intention with test/validation - validation: classification: un-checked return - validation: pktio: support arbitrary length packets - validation: pktio: fix memory corruption - validation: common: catch odp_term_local/global failures - validation: common: print odp_init failures to stderr - validation: schedule: exit schedule loop - validation: schedule: added queue destroy test * bugs: - linux-generic: pool: fix missing increment of blkallocs stat - example: odp_generator: use odp_timer - configure.ac: include configure.m4 if platform explicitly selected * general: - doxygen cleanups - scheduler: restructured queue and pktio integration - linux-generic: schedule: terminate - linux-generic: debug_internal: assert prints condition - linux-generic: pool: check for NULL params before dereference - linux-generic: pktio: fix SEGV after odp_pktio_inq_remdef() - linux-generic: system_info: use global data struct - linux-generic: use arch optimisations - examples: odp_ipsec: runtime select multiple vs single deq - examples: odp_ipsec: runtime select scheduled vs poll queues - examples: odp_ipsec: handle alloc_pkt_ctx failure - scripts: odp_check: remove astyle - linux-generic: odp_linux: migrate helpers to helper dir opendataplane (1.0.2) * API: - api files were touched with override patches but no api changes were actually made. * test: * validation: - fix memory allocation in odp_synchronizers - fixed memory leak in odp_cpumask.c - timer: use unused attribute - pktio: add support for VPATH builds - added odp_cpumask test - timer: free malloced memory - timer: use ODP_SHM_NULL - timer: added cancel test - pktio: prevent race when using veth pair - test: debug: replace example with test - test: debug: add unused attribute MACRO - performance: odp_atomic: move atomic test from api_test to performance - performance: scheduling: add support for VPATH builds - performance: scheduling: catch exit codes * general: - barrier: allow platform to override odp_barrier_t - ticketlock: allow platform to override odp_ticketlock_t - rwlock: allow platform to override odp_rwlock_t - spinlock: allow platform to override odp_spinlock_t - doc: move api guidelines to API doc - linux-generic: strongtypes: add dummy struct var to keep c++ happy - linux-generic: queue: fix potential queue leak - linux-generic: strongtypes: use named structs for C++ - example: l2fwd print packets per second - linux-generic: linux: destroy used pthread attr * bugs: - validation: packet: use non-zero as true indicato - linux-generic: pktio check for NULL entry - linux-generic: fix incorrect pmr_term_value update in odp_pmr_create_xxx() function - replace strtok_r with strtok and fix leaks - schedule: free queues and pool opendataplane (1.0.1) * test: * validation: - pktio: disable arp on virtual interfaces - pktio check return code for pool_destroy - schedule: code clean up - odp_scheduling: limit worker thread count - odp_timer: cleanup for clean termination - common: prevent masking test failures - shm: abort on null pointer - crypto: add packet free to sync test - crypto: add common test cleanup - common: add support for test term - crypto: split crypto and random tests - add unit tests for strong type display functions * general: - linux-generic: only print errors to stderr - linux-generic: linux: remove explicit buffer cache flush * bugs: - linux-generic: odp_timer: set user_ptr for cancelled timeout - validation: odp_timer: cleanup for clean termination - example: odp_packet uncomment polling queues - linux-generic: mmap: jumbo frames support - linux-generic: thread: reuse thread ids - classification: destroy pktio default inqueue during teardown - classification: pktio skip value set to zero opendataplane (1.0.0) * API: - crypto, cpumask, packet_io, random: replace ssize_t with int32_t - crypto: add session destroy function - crypto: add error code for invalid IV - classification: Add documentation for missing macros - hints: add printf format attribute - errno: add api to public api - init: add missing documentation - packet_io: remove specific errno value * test: * validation: - Makefile.am: restructure - pktio: free unexpected packets/events - pktio: destroy interface specific pools - pktio: destroy pktio input queues - pktio: fix odp_errno usage - buffer: split pool, buffer and packet tests - init: include stdlib.h for abort() - crypto: verify session_destroy - crypto: verify odp_crypto_operation() return code - queue: destroy created ODP resources - errno: add sunnyday test * miscellaneous: - Add CPP test * bugs: - odp_init_log: fix clang format string error - buffers: remove obsolete debugging code - classification: fix unchecked return value - classification: fix incorrect ipv4 checksum update - example: generator: add missing doxygen documentation - pools: switch to simple locks for buf/blk synchronization - performance: fix c99 warnings as errors - crypto: handle copy error - system: read hugepage size for all architectures - queue: fix PKTIN queue destroy * general: - add -std=c99 gcc flag by default, fix all warnings - handle copy error in odp_crypto_operation - fix all doxygen warnings - configured defines changed ODP_CONFIG_ and moved to config.h opendataplane (0.11.0) * API: - update return descriptions - add strong types - thread, rename functions - cpu, rename functions - errno added - classification, remove pmr count - init, allow the abort function to be overridden - hints, add ODP_NORETURN - packet_flag, remove odp_packet_override_l4_checksum * validation: - init, add tests for override the abort function * bugs: - timer, avoid cunit warnings for late timeouts - version, fix odp_version_api_str (1194, 1207) - fix clang (1203, 1023) - validation: init: fix unitalized data in struct (1206) - linux-generic: setup_pktio_entry() null terminate pkio name (1055) - validation: odp_timer.c: (1048, 1056) opendataplane (0.10.0) * API: - Allow init_global logging - Add events - Add Crypto Completion event - Classification API cleanup - Move header files out of linux-generic * validation: - Classification tests * bugs: - l2fwd: fix incorrect cpumask used when spawning threads - shared memory * general: - move headers into namespace the odp/helper opendataplane (0.9.0) * Initial release ////