[COMMIT] branch next updated. v1.13.0.0-81-gd56c775
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, next has been updated
via d56c7755dce115f3c1692fa358e58b1b46cf2234 (commit)
via 724db2bdabcafb5438fe02d01e8f4b60a1ab37e1 (commit)
via ca58e1a62911ed25abddf2a899a1bee678f6d305 (commit)
via a19875674436996ec38e83371fb0a91427dfe3e0 (commit)
via 3fee187e801a1a6ac0d7699486451f2bfe30ecd1 (commit)
via 6ec758bd738b86c48b5ae7ba01759aeb95c18e01 (commit)
via 3e399ed202522790efa552666aa04dbfd9e06da4 (commit)
via 31498a7a8bd19de593f6b862cb39d484b99c9bf8 (commit)
from 53d71e1a9e543e8da738fbf4b9d028e750939147 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit d56c7755dce115f3c1692fa358e58b1b46cf2234
Author: Yi He <yi.he(a)linaro.org>
Date: Tue Feb 7 02:35:17 2017 +0000
linux-gen: fix odp_schedule.m4
Fixed configure script when enables schedule option
schedule-iquery=yes or schedule-sp=yes: command not found
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/m4/odp_schedule.m4 b/platform/linux-generic/m4/odp_schedule.m4
index 2dcc9a7..91c19f2 100644
--- a/platform/linux-generic/m4/odp_schedule.m4
+++ b/platform/linux-generic/m4/odp_schedule.m4
@@ -1,13 +1,13 @@
AC_ARG_ENABLE([schedule-sp],
[ --enable-schedule-sp enable strict priority scheduler],
[if test x$enableval = xyes; then
- schedule-sp=yes
+ schedule_sp_enabled=yes
ODP_CFLAGS="$ODP_CFLAGS -DODP_SCHEDULE_SP"
fi])
AC_ARG_ENABLE([schedule-iquery],
[ --enable-schedule-iquery enable interests query (sparse bitmap) scheduler],
[if test x$enableval = xyes; then
- schedule-iquery=yes
+ schedule_iquery_enabled=yes
ODP_CFLAGS="$ODP_CFLAGS -DODP_SCHEDULE_IQUERY"
fi])
commit 724db2bdabcafb5438fe02d01e8f4b60a1ab37e1
Author: Christophe Milard <christophe.milard(a)linaro.org>
Date: Thu Jul 21 14:06:11 2016 +0200
linux-generic: cosmetic changes on byteorder files
To please check-patch before the copy to the drv interface.
Signed-off-by: Christophe Milard <christophe.milard(a)linaro.org>
Reviewed-and-tested-by: Mike Holmes <mike.holmes(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/byteorder.h b/include/odp/api/spec/byteorder.h
index 2899adb..38c0bdb 100644
--- a/include/odp/api/spec/byteorder.h
+++ b/include/odp/api/spec/byteorder.h
@@ -4,7 +4,6 @@
* SPDX-License-Identifier: BSD-3-Clause
*/
-
/**
* @file
*
@@ -95,7 +94,6 @@ uint32_t odp_be_to_cpu_32(odp_u32be_t be32);
*/
uint64_t odp_be_to_cpu_64(odp_u64be_t be64);
-
/*
* CPU byte order -> Big Endian:
*/
@@ -121,7 +119,6 @@ odp_u32be_t odp_cpu_to_be_32(uint32_t cpu32);
*/
odp_u64be_t odp_cpu_to_be_64(uint64_t cpu64);
-
/*
* Little Endian -> CPU byte order:
*/
@@ -147,7 +144,6 @@ uint32_t odp_le_to_cpu_32(odp_u32le_t le32);
*/
uint64_t odp_le_to_cpu_64(odp_u64le_t le64);
-
/*
* CPU byte order -> Little Endian:
*/
diff --git a/platform/linux-generic/include/odp/api/plat/byteorder_types.h b/platform/linux-generic/include/odp/api/plat/byteorder_types.h
index 09235b5..20d52bf 100644
--- a/platform/linux-generic/include/odp/api/plat/byteorder_types.h
+++ b/platform/linux-generic/include/odp/api/plat/byteorder_types.h
@@ -4,7 +4,6 @@
* SPDX-License-Identifier: BSD-3-Clause
*/
-
/**
* @file
*
@@ -30,7 +29,6 @@ extern "C" {
#error __LITTLE_ENDIAN not defined!
#endif
-
/* for use with type checkers such as sparse */
#ifdef __CHECKER__
/** @internal bitwise attribute */
@@ -44,7 +42,6 @@ extern "C" {
#define __odp_force
#endif
-
/** @addtogroup odp_compiler_optim
* @{
*/
commit ca58e1a62911ed25abddf2a899a1bee678f6d305
Author: Bill Fischofer <bill.fischofer(a)linaro.org>
Date: Mon Jan 30 14:38:14 2017 -0600
doc: userguide: add section on application portability
Add a section to the ODP User Guide discussing application portability
considerations and the use of source and binary portability options
provided by ODP.
Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Reviewed-by: Mike Holmes <mike.holmes(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/doc/users-guide/users-guide.adoc b/doc/users-guide/users-guide.adoc
index 41c57d1..ead8da5 100755
--- a/doc/users-guide/users-guide.adoc
+++ b/doc/users-guide/users-guide.adoc
@@ -589,6 +589,126 @@ lookup. The lookup function is particularly useful to allow an ODP application
that is divided into multiple processes to obtain the handle for the common
resource.
+== Application Portability Considerations
+ODP is designed to support the creation of portable data plane applications
+that can easily be run on multiple target platforms while at the same time
+fully exploit hardware acceleration capabilities native to whatever platform
+it is running on. This section discusses tradeoffs that application writers
+should consider when using ODP.
+
+First, it should be noted that portability is not an absolute good nor is it a
+single-valued attribute (application is portable or is not portable). While
+any application can be ported from one platform to another the real question
+is: _at what cost?_ Costs can be measured in two dimensions: The level of
+effort needed to port, and the resulting performance differences seen due to
+the port. Ideally an application should be portable between platforms with
+minimal effort and equally minimal performance impact. While ODP is designed
+to support this ideal, each application must assess what its goals are in this
+area and how best to use ODP to achieve these goals.
+
+=== Portability and Coexistence
+Because ODP offers a programming _framework_ rather than a programming
+_environment_, it is designed to be able to work alongside APIs offered by
+other frameworks with minimual interference. Therefore when we speak of
+portability in an ODP context, we of necessity speak of portability of those
+portions of the application that make use of ODP APIs. If an application uses
+non-ODP APIs then those must be taken into consideration as well when
+assessing the portability of the entire application. For many applications, it
+suffices to isolate certain non-portable code to a few areas of the application
+with the result that the application is significantly more portable than it
+would be without using ODP. Especially when dealing with existing applications
+that run in production environments, ODP may well be introduced in an
+incremental manner with the result being that the application becomes more
+portable only over time.
+
+=== Source vs. Binary Portability
+ODP has been designed to support both source and binary portability. Source
+portability is intrinsic to the ODP API specification itself. Any application
+written to the ODP API specification will be source portable between any
+conforming ODP implementation with at most a recompile. This is because ODP
+APIs do not expose implementation details or internal structures that may vary
+from platform to platform.
+
+For platforms that share a common Instruction Set Architecture (ISA), ODP can
+also offer binary portability via the specification of an Application Binary
+Interface (ABI). This is especially useful in a Network Function
+Virtualization (NFV) environment where a data plane application may be
+developed and compiled on one platform for distribution and then deployed on
+many different platforms by an NFV Orchestrator function.
+
+=== ODP Application Profiles
+To assist in meeting these needs, ODP offers two distinct _application
+profiles_ that are designed to characterize the needs of different types of
+data plane applications: the _Embedded Profile_ and the _Cloud Profile_.
+
+==== Embedded Profile
+The ODP Embedded Profile is designed to support applications that wish to
+target a specific platform and achieve optimal performance on that platform
+and where source code portability is sufficient. If such applications need to
+support more than one platform then they simply need to be recompiled against
+the ODP implementation for that platform.
+
+Embedded applications will typically work with a copy of ODP downloaded from
+a git repository so that it can be configured for the application's precise
+needs. To specify that the application wishes to use the embedded profile:
+
+`./configure --enable-abi-compat=no ...`
+
+should be used as part of the ODP configuration options. This allows
+applications to use inline forms of ODP APIs to give optimal performance
+on this platform, and may include additional optimizations that preclude
+binary portability to other platforms. The result is a binary that will achieve
+maximum performance on a given target platform and that can be ported to
+other platforms with a recompile.
+
+==== Cloud Profile
+By contrast, the ODP Cloud Profile is designed to support applications that
+wish to be platform-agnostic and be binary compatible across all platforms
+sharing this ABI. Any ODP implementation included in a Linux distribution will
+be configured for the cloud profile, so no additional action is required on
+the part of applications when compiling against a distributed copy of ODP (one
+that is installed via `sudo apt-get install` or equivalent command).
+
+When using a copy of ODP downloaded from a repository, the cloud profile is
+selected at configure time:
+
+`./configure --enable-abi-compat=yes ...`
+
+Note that `--enable-abi-compat=yes` is the default, so this need not be
+specified. Unless `no` is specified for this option, the result will be
+applications designed to run in the cloud profile.
+
+=== ABI Characteristics
+An ABI consists of several conventions that ensure that a program compiled
+against one ODP implementation can run unchanged on another platform that
+has a possibly very different ODP implementation without requiring
+recompilation. These include:
+
+* A set of function calling conventions that define how functions call other
+functions, pass parameters, and receive returned results. These are typically
+specified by the Operating System (_e.g.,_ Linux) and are independent of ODP.
+
+* Avoiding the use of inline expansions for any ODP API. This ensures that
+differing ODP implementations can maintain their different internals without
+these differences being visible to the application.
+
+* Agreement as to the size and alignment of ODP abstract datatypes used by all
+ODP implementations sharing this ABI definition. This means that, for example,
+the size of an `odp_packet_t` handle is the same across all members of the
+ABI. Since these handles are opaque, it doesn't matter if their structure
+differs between ODP implementations since applications never reference these
+possibly different internals.
+
+Note that an ABI definition exists within a specific Instruction Set
+Architecture (ISA), such as x86-64 or AArch64. Binaries cannot directly port
+between ISAs--that requires a recompilation.
+
+Each ODP implementation will identify which ABI definition it supports, if any.
+When compiling against an ODP implementation in ABI compabitilty mode, the
+resulting binary is automatically binary compatible with all other ODP
+implementations that share this ABI. For example, for the x86-64 ISA, both
+the `odp-linux` and `odp-dpdk` implemtations are a common ABI.
+
== Shared memory
=== Allocating shared memory
Blocks of shared memory can be created using the `odp_shm_reserve()` API
commit a19875674436996ec38e83371fb0a91427dfe3e0
Author: Bill Fischofer <bill.fischofer(a)linaro.org>
Date: Tue Jan 10 20:35:49 2017 -0600
doc: userguide: add user documentation for packet references
Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Reviewed-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/doc/users-guide/users-guide-packet.adoc b/doc/users-guide/users-guide-packet.adoc
index e3be23c..d5f2ff1 100644
--- a/doc/users-guide/users-guide-packet.adoc
+++ b/doc/users-guide/users-guide-packet.adoc
@@ -246,7 +246,7 @@ packet pool as the original packet.
The opposite operation is performed by the `odp_packet_concat()` API. This API
takes a destination and source packet as arguments and the result is that
the source packet is concatenated to the destination packet and ceases to
-have any separete identity. Note that it is legal to concatenate a packet to
+have any separate identity. Note that it is legal to concatenate a packet to
itself, in which case the result is a packet with double the length of the
original packet.
@@ -282,3 +282,240 @@ larger than the underlying segment size. The call may also fail if the
requested alignment is too high. Alignment limits will vary among different ODP
implementations, however ODP requires that all implementations support
requested alignments of at least 32 bytes.
+
+=== Packet References
+To support efficient multicast, retransmit, and related processing, ODP
+supports two additional types of packet manipulation: static and dynamic
+_references_. A reference is a lightweight mechanism for
+creating aliases to packets as well as to create packets that share data bytes
+with other packets to avoid unnecessary data copying.
+
+==== Static References
+The simplest type of reference is the _static reference_. A static reference is
+created by the call:
+
+[source,c]
+-----
+ref_pkt = odp_packet_ref_static(pkt);
+-----
+
+If the reference fails, `ODP_PACKET_INVALID` is returned and `pkt`
+remains unchanged.
+
+The effect of this call is shown below:
+
+.Static Packet Reference
+image::refstatic.svg[align="center"]
+
+A static reference provides a simple and efficient means of creating an alias
+for a packet handle that prevents the packet itself from being freed until all
+references to it have been released via `odp_packet_free()` calls. This is
+useful, for example, to support retransmission processing, since as part of
+packet TX processing, `odp_pktout_send()` or `odp_tm_enq()` will free
+the packet after it has been transmitted.
+
+`odp_packet_ref_static()` might be used in a transmit routine wrapper
+function like:
+
+[source,c]
+-----
+int xmit_pkt(odp_pktout_queue_t queue, odp_packet_t pkt)
+{
+ odp_packet_t ref = odp_packet_ref_static(pkt);
+ return ref == ODP_PACKET_INVALID ? -1 : odp_pktout_send(queue, ref, 1);
+}
+-----
+
+This transmits a reference to `pkt` so that `pkt` is retained by the caller,
+which means that the caller is free to retransmit it if needed at a later
+time. When a higher level protocol (_e.g.,_ receipt of a TCP ACK packet)
+confirms that the transmission was successful, `pkt` can then be discarded via
+an `odp_packet_free()` call.
+
+The key characteristic of a static reference is that because there are
+multiple independent handles that refer to the same packet, the caller should
+treat the packet as read only following the creation of a static reference
+until all other references to it are freed. This is because all static
+references are simply aliases of the same packet, so if multiple threads were
+independently manipulating the packet this would lead to unpredictable race
+conditions.
+
+To assist in determining whether there are other references to a packet, ODP
+provides the API:
+
+[source,c]
+-----
+int odp_packet_has_ref(odp_packet_t pkt);
+-----
+
+that indicates whether other packets exist that share bytes with this
+packet. If this routine returns 0 then the caller can be assured that it is
+safe to modify it as this handle is the only reference to the packet.
+
+==== Dynamic References
+While static references are convenient and efficient, they are limited by the
+need to be treated as read only. For example, consider an application that
+needs to _multicast_ a packet. Here the same packet needs to be sent to two or
+more different destinations. While the packet payload may be the same, each
+sent copy of the packet requires its own unique header to specify the
+destination that is to receive the packet.
+
+To address this need, ODP provides _dynamic references_. These are created
+by the call:
+
+[source,c]
+-----
+ref_pkt = odp_packet_ref(pkt, offset);
+-----
+
+The `offset` parameter specifies the byte offset into `pkt` at which the
+reference is to begin. This must be in the range
+0..`odp_packet_len(pkt)`-1. As before, if the reference is unable to be
+created `ODP_PACKET_INVALID` is returned and `pkt` is unchanged, otherwise the
+result is as shown below:
+
+.Dynamic Packet Reference
+image::ref.svg[align="center"]
+
+Following a successful reference creation, the bytes of `pkt` beginning at
+offset `offset` are shared with the created reference. These bytes should be
+treated as read only since multiple references point to them. Each reference,
+however still retains its own individual headroom and metadata that is not
+shared with any other reference. This allows unique headers to be created by
+calling `odp_packet_push_head()` or `odp_packet_extend_head()` on either
+handle. This allows multiple references to the same packet to prefix unique
+headers onto common shared data it so that they can be properly multicast
+using code such as:
+
+[source,c]
+-----
+int pkt_fanout(odp_packet_t payload, odp_queue_t fanout_queue[], int num_queues)
+{
+ int i;
+
+ for (i = 0, i < num_queues, i++)
+ odp_queue_enq(fanout_queue[i], odp_packet_ref(payload, 0));
+}
+-----
+
+Receiver worker threads can then operate on each reference to the packet in
+parallel to prefix a unique transmit header onto it and send it out.
+
+==== Dynamic References with Headers
+The dynamic references discussed so far have one drawback in that the headers
+needed to make each reference unique must be constructed individually after
+the reference is created. To address this problem, ODP allows these headers
+to be created in advance and then simply prefixed to a base packet as part
+of reference creation:
+
+[source,c]
+-----
+ref_pkt = odp_packet_ref_pkt(pkt, offset, hdr_pkt);
+-----
+
+Here rather than creating a reference with a null header, a _header packet_
+is supplied that is prefixed onto the reference. The result looks like this:
+
+.Packet Reference using a Header Packet
+image::refpktsingle.svg[align="center"]
+
+So now multicasting can be more efficient using code such as:
+
+[source,c]
+-----
+int pkt_fanout_hdr(odp_packet_t payload, odp_queue_q fanout_queue[],
+ odp_packet_t hdr[], int num_queues)
+{
+ int i;
+
+ for (i = 0; i < num_queues, i++)
+ odp_queue_enq(fanout_queue[i],
+ odp_packet_ref_pkt(payload, 0, hdr[i]));
+}
+-----
+
+Now each individual reference has its own header already prefixed to
+it ready for transmission.
+
+Note that when multiple references like this are made they can each have
+their own offset. So if the following code is executed:
+
+[source,c]
+-----
+ref_pkt1 = odp_packet_ref_pkt(pkt, offset1, hdr_pkt1);
+ref_pkt2 = odp_packet_ref_pkt(pkt, offset2, hdr_pkt2);
+-----
+
+the result will look like:
+
+image::refpkt1.svg[align="center"]
+image::refpktmulti.svg[align="center"]
+.Multiple Packet References with Different Offsets
+image::refpkt2.svg[align="center"]
+
+Here two separate header packets are prefixed onto the same shared packet, each
+at their own specified offset, which may or may not be the same. The result is
+three packets visible to the application:
+
+* The original `pkt`, which can still be accessed and manipulated directly.
+* The first reference, which consists of `hdr_pkt1` followed by bytes
+contained in `pkt` starting at `offset1`.
+* The second reference, which consists of `hdr_pkt2` followed by bytes
+contained in `pkt` starting at `offset2`.
+
+Only a single copy of the bytes in `pkt` that are common to the
+references exist.
+
+===== Data Sharing with References
+Because a `pkt` is a shared object when referenced, applications must observe
+certain disciplines when working with them. For best portability and
+reliability, the shared data contained in any packet referred to by references
+should be treated as read only once it has been successfully referenced until
+it is known that all references to it have been freed.
+
+To assist applications in working with references, ODP provides two additional
+APIs:
+
+[source,c]
+-----
+int odp_packet_has_ref(odp_packet_t pkt);
+
+uint32_t odp_packet_unshared_len(odp_packet_t pkt);
+-----
+The `odp_packet_has_ref()` API says whether any other packets
+exist that share any bytes with this packet.
+
+Because references and referenced packets consist of an unshared
+prefix, that is modifiable, followed by a shared body that should not be
+modified, the `odp_packet_unshared_len()` API is available that operates as
+shown here:
+
+.Packet Reference Lengths
+image::reflen.svg[align="center"]
+
+`odp_packet_unshared_len()` returns the same value as `odp_packet_len()` when
+`odp_packet_has_ref()` returns 0, but for packets for which
+`odp_packet_has_ref()` returns 1, only returns the number of unshared bytes
+prefixed to them. To ensure portability and reliability, only offsets
+0..`odp_packet_unshared_len()`-1 should be modified by the caller.
+
+===== Compound References
+Note that architecturally ODP does not limit referencing and so it is possible
+that a reference may be used as a basis for creating another reference. The
+result is a _compound reference_ that should still behave as any other
+reference.
+
+As noted earlier, the intent behind references is that they are lightweight
+objects that can be implemented without requiring data copies. The existence
+of compound references may complicate this goal for some implementations. As a
+result, implementations are always free to perform partial or full copies of
+packets as part of any reference creation call. The
+`odp_packet_unshared_len()` API will always provide an authoritative answer to
+the question of how many bytes of a packet may safely be modified in any
+context, so whether or not copies have been performed applications can be
+assured of portability across all conforming ODP implementations.
+
+Note also that a packet may not reference itself, nor may circular reference
+relationships be formed, _e.g.,_ packet A is used as a header for a reference
+to packet B and B is used as a header for a reference to packet A. Results
+are undefined if such circular references are attempted.
commit 3fee187e801a1a6ac0d7699486451f2bfe30ecd1
Author: Yi He <yi.he(a)linaro.org>
Date: Wed Jan 11 07:50:33 2017 +0000
linux-gen: add interests query (iquery) scheduler
Add this interests query (iquery) scheduler as an
alternate choice of ODP-linux scheduler component
for performance optimization especially in lower
queue counts use cases.
It includes a new core algorithm, but adopted the
ring-based pktio poll algorithm from default scheduler,
and still uses the old ordered queue implementation.
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index ba47d0b..78a0cf3 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -192,6 +192,7 @@ __LIB__libodp_linux_la_SOURCES = \
odp_schedule.c \
odp_schedule_if.c \
odp_schedule_sp.c \
+ odp_schedule_iquery.c \
odp_shared_memory.c \
odp_sorted_list.c \
odp_spinlock.c \
diff --git a/platform/linux-generic/m4/odp_schedule.m4 b/platform/linux-generic/m4/odp_schedule.m4
index bc70c1f..2dcc9a7 100644
--- a/platform/linux-generic/m4/odp_schedule.m4
+++ b/platform/linux-generic/m4/odp_schedule.m4
@@ -4,3 +4,10 @@ AC_ARG_ENABLE([schedule-sp],
schedule-sp=yes
ODP_CFLAGS="$ODP_CFLAGS -DODP_SCHEDULE_SP"
fi])
+
+AC_ARG_ENABLE([schedule-iquery],
+ [ --enable-schedule-iquery enable interests query (sparse bitmap) scheduler],
+ [if test x$enableval = xyes; then
+ schedule-iquery=yes
+ ODP_CFLAGS="$ODP_CFLAGS -DODP_SCHEDULE_IQUERY"
+ fi])
diff --git a/platform/linux-generic/odp_schedule_if.c b/platform/linux-generic/odp_schedule_if.c
index daf6c98..a9ede98 100644
--- a/platform/linux-generic/odp_schedule_if.c
+++ b/platform/linux-generic/odp_schedule_if.c
@@ -12,9 +12,15 @@ extern const schedule_api_t schedule_sp_api;
extern const schedule_fn_t schedule_default_fn;
extern const schedule_api_t schedule_default_api;
+extern const schedule_fn_t schedule_iquery_fn;
+extern const schedule_api_t schedule_iquery_api;
+
#ifdef ODP_SCHEDULE_SP
const schedule_fn_t *sched_fn = &schedule_sp_fn;
const schedule_api_t *sched_api = &schedule_sp_api;
+#elif defined(ODP_SCHEDULE_IQUERY)
+const schedule_fn_t *sched_fn = &schedule_iquery_fn;
+const schedule_api_t *sched_api = &schedule_iquery_api;
#else
const schedule_fn_t *sched_fn = &schedule_default_fn;
const schedule_api_t *sched_api = &schedule_default_api;
diff --git a/platform/linux-generic/odp_schedule_iquery.c b/platform/linux-generic/odp_schedule_iquery.c
new file mode 100644
index 0000000..b692457
--- /dev/null
+++ b/platform/linux-generic/odp_schedule_iquery.c
@@ -0,0 +1,1521 @@
+/* Copyright (c) 2016, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <odp/api/schedule.h>
+#include <odp_schedule_if.h>
+#include <odp/api/align.h>
+#include <odp/api/queue.h>
+#include <odp/api/shared_memory.h>
+#include <odp_internal.h>
+#include <odp_debug_internal.h>
+#include <odp_ring_internal.h>
+#include <odp_queue_internal.h>
+#include <odp_buffer_internal.h>
+#include <odp_bitmap_internal.h>
+#include <odp/api/thread.h>
+#include <odp/api/time.h>
+#include <odp/api/rwlock.h>
+#include <odp/api/hints.h>
+#include <odp/api/cpu.h>
+#include <odp/api/thrmask.h>
+#include <odp_config_internal.h>
+
+/* Number of priority levels */
+#define NUM_SCHED_PRIO 8
+
+ODP_STATIC_ASSERT(ODP_SCHED_PRIO_LOWEST == (NUM_SCHED_PRIO - 1),
+ "lowest_prio_does_not_match_with_num_prios");
+
+ODP_STATIC_ASSERT((ODP_SCHED_PRIO_NORMAL > 0) &&
+ (ODP_SCHED_PRIO_NORMAL < (NUM_SCHED_PRIO - 1)),
+ "normal_prio_is_not_between_highest_and_lowest");
+
+/* Number of scheduling groups */
+#define NUM_SCHED_GRPS 256
+
+/* Start of named groups in group mask arrays */
+#define SCHED_GROUP_NAMED (ODP_SCHED_GROUP_CONTROL + 1)
+
+/* Instantiate a WAPL bitmap to be used as queue index bitmap */
+typedef WAPL_BITMAP(ODP_CONFIG_QUEUES) queue_index_bitmap_t;
+
+typedef struct {
+ odp_rwlock_t lock;
+ queue_index_bitmap_t queues; /* queues in this priority level */
+} sched_prio_t;
+
+typedef struct {
+ odp_rwlock_t lock;
+ bool allocated;
+ odp_thrmask_t threads; /* threads subscribe to this group */
+ queue_index_bitmap_t queues; /* queues in this group */
+ char name[ODP_SCHED_GROUP_NAME_LEN];
+} sched_group_t;
+
+/* Packet input poll command queues */
+#define PKTIO_CMD_QUEUES 4
+
+/* Maximum number of packet input queues per command */
+#define MAX_PKTIN 16
+
+/* Maximum number of packet IO interfaces */
+#define NUM_PKTIO ODP_CONFIG_PKTIO_ENTRIES
+
+/* Maximum number of pktio poll commands */
+#define NUM_PKTIO_CMD (MAX_PKTIN * NUM_PKTIO)
+
+/* Pktio command is free */
+#define PKTIO_CMD_FREE ((uint32_t)-1)
+
+/* Packet IO poll queue ring size. In worst case, all pktios
+ * have all pktins enabled and one poll command is created per
+ * pktin queue. The ring size must be larger than or equal to
+ * NUM_PKTIO_CMD / PKTIO_CMD_QUEUES, so that it can hold all
+ * poll commands in the worst case.
+ */
+#define PKTIO_RING_SIZE (NUM_PKTIO_CMD / PKTIO_CMD_QUEUES)
+
+/* Mask for wrapping around pktio poll command index */
+#define PKTIO_RING_MASK (PKTIO_RING_SIZE - 1)
+
+/* Maximum number of dequeues */
+#define MAX_DEQ CONFIG_BURST_SIZE
+
+/* Instantiate a RING data structure as pktio command queue */
+typedef struct {
+ /* Ring header */
+ ring_t ring;
+
+ /* Ring data: pktio poll command indexes */
+ uint32_t cmd_index[PKTIO_RING_SIZE];
+} pktio_cmd_queue_t ODP_ALIGNED_CACHE;
+
+/* Packet IO poll command */
+typedef struct {
+ int pktio;
+ int count;
+ int pktin[MAX_PKTIN];
+ uint32_t index;
+} pktio_cmd_t;
+
+/* Collect the pktio poll resources */
+typedef struct {
+ odp_rwlock_t lock;
+ /* count active commands per pktio interface */
+ int actives[NUM_PKTIO];
+ pktio_cmd_t commands[NUM_PKTIO_CMD];
+ pktio_cmd_queue_t queues[PKTIO_CMD_QUEUES];
+} pktio_poll_t;
+
+/* Forward declaration */
+typedef struct sched_thread_local sched_thread_local_t;
+
+typedef struct {
+ odp_shm_t selfie;
+
+ /* Schedule priorities */
+ sched_prio_t prios[NUM_SCHED_PRIO];
+
+ /* Schedule groups */
+ sched_group_t groups[NUM_SCHED_GRPS];
+
+ /* Cache queue parameters for easy reference */
+ odp_schedule_param_t queues[ODP_CONFIG_QUEUES];
+
+ /* Poll pktio inputs in spare time */
+ pktio_poll_t pktio_poll;
+
+ /* Queues send or unwind their availability indications
+ * for scheduling, the bool value also serves as a focal
+ * point for atomic competition. */
+ bool availables[ODP_CONFIG_QUEUES];
+
+ /* Quick reference to per thread context */
+ sched_thread_local_t *threads[ODP_THREAD_COUNT_MAX];
+} sched_global_t;
+
+/* Per thread events cache */
+typedef struct {
+ int count;
+ odp_queue_t queue;
+ odp_event_t stash[MAX_DEQ], *top;
+} event_cache_t;
+
+/* Maximum number of ordered locks per queue */
+#define MAX_ORDERED_LOCKS_PER_QUEUE 2
+
+ODP_STATIC_ASSERT(MAX_ORDERED_LOCKS_PER_QUEUE <= CONFIG_QUEUE_MAX_ORD_LOCKS,
+ "Too_many_ordered_locks");
+
+/* Ordered stash size */
+#define MAX_ORDERED_STASH 512
+
+/* Storage for stashed enqueue operation arguments */
+typedef struct {
+ odp_buffer_hdr_t *buf_hdr[QUEUE_MULTI_MAX];
+ queue_entry_t *queue;
+ int num;
+} ordered_stash_t;
+
+/* Ordered lock states */
+typedef union {
+ uint8_t u8[CONFIG_QUEUE_MAX_ORD_LOCKS];
+ uint32_t all;
+} lock_called_t;
+
+ODP_STATIC_ASSERT(sizeof(lock_called_t) == sizeof(uint32_t),
+ "Lock_called_values_do_not_fit_in_uint32");
+
+/* Instantiate a sparse bitmap to store thread's interested
+ * queue indexes per priority.
+ */
+typedef SPARSE_BITMAP(ODP_CONFIG_QUEUES) queue_index_sparse_t;
+
+struct sched_thread_local {
+ int thread;
+ bool pause;
+
+ /* Cache events only for atomic queue */
+ event_cache_t cache;
+
+ /* Saved atomic context */
+ bool *atomic;
+
+ /* Record the pktio polls have done */
+ uint16_t pktin_polls;
+
+ /* Interested queue indexes to be checked by thread
+ * at each priority level for scheduling, and a round
+ * robin iterator to improve fairness between queues
+ * in the same priority level.
+ */
+ odp_rwlock_t lock;
+ queue_index_sparse_t indexes[NUM_SCHED_PRIO];
+ sparse_bitmap_iterator_t iterators[NUM_SCHED_PRIO];
+
+ struct {
+ queue_entry_t *src_queue; /**< Source queue entry */
+ uint64_t ctx; /**< Ordered context id */
+ int stash_num; /**< Number of stashed enqueue operations */
+ uint8_t in_order; /**< Order status */
+ lock_called_t lock_called; /**< States of ordered locks */
+ /** Storage for stashed enqueue operations */
+ ordered_stash_t stash[MAX_ORDERED_STASH];
+ } ordered;
+};
+
+/* Global scheduler context */
+static sched_global_t *sched;
+
+/* Thread local scheduler context */
+__thread sched_thread_local_t thread_local;
+
+static int schedule_init_global(void)
+{
+ odp_shm_t shm;
+ int i, k, prio, group;
+
+ ODP_DBG("Schedule[iquery] init ... ");
+
+ shm = odp_shm_reserve("odp_scheduler_iquery",
+ sizeof(sched_global_t),
+ ODP_CACHE_LINE_SIZE, 0);
+
+ sched = odp_shm_addr(shm);
+
+ if (sched == NULL) {
+ ODP_ERR("Schedule[iquery] "
+ "init: shm reserve.\n");
+ return -1;
+ }
+
+ memset(sched, 0, sizeof(sched_global_t));
+
+ sched->selfie = shm;
+
+ for (prio = 0; prio < NUM_SCHED_PRIO; prio++)
+ odp_rwlock_init(&sched->prios[prio].lock);
+
+ for (group = 0; group < NUM_SCHED_GRPS; group++) {
+ sched->groups[group].allocated = false;
+ odp_rwlock_init(&sched->groups[group].lock);
+ }
+
+ odp_rwlock_init(&sched->pktio_poll.lock);
+
+ for (i = 0; i < PKTIO_CMD_QUEUES; i++) {
+ pktio_cmd_queue_t *queue =
+ &sched->pktio_poll.queues[i];
+
+ ring_init(&queue->ring);
+
+ for (k = 0; k < PKTIO_RING_SIZE; k++)
+ queue->cmd_index[k] = RING_EMPTY;
+ }
+
+ for (i = 0; i < NUM_PKTIO_CMD; i++)
+ sched->pktio_poll.commands[i].index = PKTIO_CMD_FREE;
+
+ ODP_DBG("done\n");
+ return 0;
+}
+
+static int schedule_term_global(void)
+{
+ uint32_t i;
+ odp_shm_t shm = sched->selfie;
+
+ for (i = 0; i < ODP_CONFIG_QUEUES; i++) {
+ int count = 0;
+ odp_event_t events[1];
+
+ if (sched->availables[i])
+ count = sched_cb_queue_deq_multi(i, events, 1);
+
+ if (count < 0)
+ sched_cb_queue_destroy_finalize(i);
+ else if (count > 0)
+ ODP_ERR("Queue (%d) not empty\n", i);
+ }
+
+ memset(sched, 0, sizeof(sched_global_t));
+
+ if (odp_shm_free(shm) < 0) {
+ ODP_ERR("Schedule[iquery] "
+ "term: shm release.\n");
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ * These APIs are used to manipulate thread's interests.
+ */
+static void thread_set_interest(sched_thread_local_t *thread,
+ unsigned int queue_index, int prio);
+
+static void thread_clear_interest(sched_thread_local_t *thread,
+ unsigned int queue_index, int prio);
+
+static void thread_set_interests(sched_thread_local_t *thread,
+ queue_index_bitmap_t *set);
+
+static void thread_clear_interests(sched_thread_local_t *thread,
+ queue_index_bitmap_t *clear);
+
+static void sched_thread_local_reset(void)
+{
+ int prio;
+ queue_index_sparse_t *index;
+ sparse_bitmap_iterator_t *iterator;
+
+ memset(&thread_local, 0, sizeof(sched_thread_local_t));
+
+ thread_local.thread = odp_thread_id();
+ thread_local.cache.queue = ODP_QUEUE_INVALID;
+
+ odp_rwlock_init(&thread_local.lock);
+
+ for (prio = 0; prio < NUM_SCHED_PRIO; prio++) {
+ index = &thread_local.indexes[prio];
+ iterator = &thread_local.iterators[prio];
+
+ sparse_bitmap_zero(index);
+ sparse_bitmap_iterator(iterator, index);
+ }
+}
+
+static int schedule_init_local(void)
+{
+ int group;
+ sched_group_t *G;
+ queue_index_bitmap_t collect;
+
+ wapl_bitmap_zero(&collect);
+ sched_thread_local_reset();
+
+ /* Collect all queue indexes of the schedule groups
+ * which this thread has subscribed
+ */
+ for (group = 0; group < NUM_SCHED_GRPS; group++) {
+ G = &sched->groups[group];
+ odp_rwlock_read_lock(&G->lock);
+
+ if ((group < SCHED_GROUP_NAMED || G->allocated) &&
+ odp_thrmask_isset(&G->threads, thread_local.thread))
+ wapl_bitmap_or(&collect, &collect, &G->queues);
+
+ odp_rwlock_read_unlock(&G->lock);
+ }
+
+ /* Distribute the above collected queue indexes into
+ * thread local interests per priority level.
+ */
+ thread_set_interests(&thread_local, &collect);
+
+ /* "Night gathers, and now my watch begins..." */
+ sched->threads[thread_local.thread] = &thread_local;
+ return 0;
+}
+
+static inline void schedule_release_context(void);
+
+static int schedule_term_local(void)
+{
+ int group;
+ sched_group_t *G;
+
+ if (thread_local.cache.count) {
+ ODP_ERR("Locally pre-scheduled events exist.\n");
+ return -1;
+ }
+
+ schedule_release_context();
+
+ /* Unsubscribe all named schedule groups */
+ for (group = SCHED_GROUP_NAMED;
+ group < NUM_SCHED_GRPS; group++) {
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ if (G->allocated && odp_thrmask_isset(
+ &G->threads, thread_local.thread))
+ odp_thrmask_clr(&G->threads, thread_local.thread);
+
+ odp_rwlock_write_unlock(&G->lock);
+ }
+
+ /* "...for this night and all the nights to come." */
+ sched->threads[thread_local.thread] = NULL;
+ sched_thread_local_reset();
+ return 0;
+}
+
+static int init_sched_queue(uint32_t queue_index,
+ const odp_schedule_param_t *sched_param)
+{
+ int prio, group, thread;
+ sched_prio_t *P;
+ sched_group_t *G;
+ sched_thread_local_t *local;
+
+ prio = sched_param->prio;
+ group = sched_param->group;
+
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ /* Named schedule group must be created prior
+ * to queue creation to this group.
+ */
+ if (group >= SCHED_GROUP_NAMED && !G->allocated) {
+ odp_rwlock_write_unlock(&G->lock);
+ return -1;
+ }
+
+ /* Record the queue in its priority level globally */
+ P = &sched->prios[prio];
+
+ odp_rwlock_write_lock(&P->lock);
+ wapl_bitmap_set(&P->queues, queue_index);
+ odp_rwlock_write_unlock(&P->lock);
+
+ /* Record the queue in its schedule group */
+ wapl_bitmap_set(&G->queues, queue_index);
+
+ /* Cache queue parameters for easy reference */
+ memcpy(&sched->queues[queue_index],
+ sched_param, sizeof(odp_schedule_param_t));
+
+ /* Update all threads in this schedule group to
+ * start check this queue index upon scheduling.
+ */
+ thread = odp_thrmask_first(&G->threads);
+ while (thread >= 0) {
+ local = sched->threads[thread];
+ thread_set_interest(local, queue_index, prio);
+ thread = odp_thrmask_next(&G->threads, thread);
+ }
+
+ odp_rwlock_write_unlock(&G->lock);
+ return 0;
+}
+
+/*
+ * Must be called with schedule group's rwlock held.
+ * This is also being used in destroy_schedule_group()
+ * to destroy all orphan queues while destroying a whole
+ * schedule group.
+ */
+static void __destroy_sched_queue(
+ sched_group_t *G, uint32_t queue_index)
+{
+ int prio, thread;
+ sched_prio_t *P;
+ sched_thread_local_t *local;
+
+ prio = sched->queues[queue_index].prio;
+
+ /* Forget the queue in its schedule group */
+ wapl_bitmap_clear(&G->queues, queue_index);
+
+ /* Forget queue schedule parameters */
+ memset(&sched->queues[queue_index],
+ 0, sizeof(odp_schedule_param_t));
+
+ /* Update all threads in this schedule group to
+ * stop check this queue index upon scheduling.
+ */
+ thread = odp_thrmask_first(&G->threads);
+ while (thread >= 0) {
+ local = sched->threads[thread];
+ thread_clear_interest(local, queue_index, prio);
+ thread = odp_thrmask_next(&G->threads, thread);
+ }
+
+ /* Forget the queue in its priority level globally */
+ P = &sched->prios[prio];
+
+ odp_rwlock_write_lock(&P->lock);
+ wapl_bitmap_clear(&P->queues, queue_index);
+ odp_rwlock_write_unlock(&P->lock);
+}
+
+static void destroy_sched_queue(uint32_t queue_index)
+{
+ int group;
+ sched_group_t *G;
+
+ group = sched->queues[queue_index].group;
+
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ /* Named schedule group could have been destroyed
+ * earlier and left these orphan queues.
+ */
+ if (group >= SCHED_GROUP_NAMED && !G->allocated) {
+ odp_rwlock_write_unlock(&G->lock);
+ return;
+ }
+
+ __destroy_sched_queue(G, queue_index);
+ odp_rwlock_write_unlock(&G->lock);
+}
+
+static int pktio_cmd_queue_hash(int pktio, int pktin)
+{
+ return (pktio ^ pktin) % PKTIO_CMD_QUEUES;
+}
+
+static inline pktio_cmd_t *alloc_pktio_cmd(void)
+{
+ int i;
+ pktio_cmd_t *cmd = NULL;
+
+ odp_rwlock_write_lock(&sched->pktio_poll.lock);
+
+ /* Find next free command */
+ for (i = 0; i < NUM_PKTIO_CMD; i++) {
+ if (sched->pktio_poll.commands[i].index
+ == PKTIO_CMD_FREE) {
+ cmd = &sched->pktio_poll.commands[i];
+ cmd->index = i;
+ break;
+ }
+ }
+
+ odp_rwlock_write_unlock(&sched->pktio_poll.lock);
+ return cmd;
+}
+
+static inline void free_pktio_cmd(pktio_cmd_t *cmd)
+{
+ odp_rwlock_write_lock(&sched->pktio_poll.lock);
+
+ cmd->index = PKTIO_CMD_FREE;
+
+ odp_rwlock_write_unlock(&sched->pktio_poll.lock);
+}
+
+static void schedule_pktio_start(int pktio, int count, int pktin[])
+{
+ int i, index;
+ pktio_cmd_t *cmd;
+
+ if (count > MAX_PKTIN)
+ ODP_ABORT("Too many input queues for scheduler\n");
+
+ /* Record the active commands count per pktio interface */
+ sched->pktio_poll.actives[pktio] = count;
+
+ /* Create a pktio poll command per pktin */
+ for (i = 0; i < count; i++) {
+ cmd = alloc_pktio_cmd();
+
+ if (cmd == NULL)
+ ODP_ABORT("Scheduler out of pktio commands\n");
+
+ index = pktio_cmd_queue_hash(pktio, pktin[i]);
+
+ cmd->pktio = pktio;
+ cmd->count = 1;
+ cmd->pktin[0] = pktin[i];
+ ring_enq(&sched->pktio_poll.queues[index].ring,
+ PKTIO_RING_MASK, cmd->index);
+ }
+}
+
+static int schedule_pktio_stop(int pktio, int pktin ODP_UNUSED)
+{
+ int remains;
+
+ odp_rwlock_write_lock(&sched->pktio_poll.lock);
+
+ sched->pktio_poll.actives[pktio]--;
+ remains = sched->pktio_poll.actives[pktio];
+
+ odp_rwlock_write_unlock(&sched->pktio_poll.lock);
+ return remains;
+}
+
+#define DO_SCHED_LOCK() odp_rwlock_read_lock(&thread_local.lock)
+#define DO_SCHED_UNLOCK() odp_rwlock_read_unlock(&thread_local.lock)
+
+static inline bool do_schedule_prio(int prio);
+
+static inline int pop_cache_events(odp_event_t ev[], unsigned int max)
+{
+ int k = 0;
+ event_cache_t *cache;
+
+ cache = &thread_local.cache;
+ while (cache->count && max) {
+ ev[k] = *cache->top++;
+ k++;
+ max--;
+ cache->count--;
+ }
+
+ return k;
+}
+
+static inline void assign_queue_handle(odp_queue_t *handle)
+{
+ if (handle)
+ *handle = thread_local.cache.queue;
+}
+
+static inline void pktio_poll_input(void)
+{
+ int i, hash;
+ uint32_t index;
+
+ ring_t *ring;
+ pktio_cmd_t *cmd;
+
+ /*
+ * Each thread starts the search for a poll command
+ * from the hash(threadID) queue to mitigate contentions.
+ * If the queue is empty, it moves to other queues.
+ *
+ * Most of the times, the search stops on the first
+ * command found to optimize multi-threaded performance.
+ * A small portion of polls have to do full iteration to
+ * avoid packet input starvation when there are less
+ * threads than command queues.
+ */
+ hash = thread_local.thread % PKTIO_CMD_QUEUES;
+
+ for (i = 0; i < PKTIO_CMD_QUEUES; i++,
+ hash = (hash + 1) % PKTIO_CMD_QUEUES) {
+ ring = &sched->pktio_poll.queues[hash].ring;
+ index = ring_deq(ring, PKTIO_RING_MASK);
+
+ if (odp_unlikely(index == RING_EMPTY))
+ continue;
+
+ cmd = &sched->pktio_poll.commands[index];
+
+ /* Poll packet input */
+ if (odp_unlikely(sched_cb_pktin_poll(cmd->pktio,
+ cmd->count,
+ cmd->pktin))) {
+ /* Pktio stopped or closed. Remove poll
+ * command and call stop_finalize when all
+ * commands of the pktio has been removed.
+ */
+ if (schedule_pktio_stop(cmd->pktio,
+ cmd->pktin[0]) == 0)
+ sched_cb_pktio_stop_finalize(cmd->pktio);
+
+ free_pktio_cmd(cmd);
+ } else {
+ /* Continue scheduling the pktio */
+ ring_enq(ring, PKTIO_RING_MASK, index);
+
+ /* Do not iterate through all pktin poll
+ * command queues every time.
+ */
+ if (odp_likely(thread_local.pktin_polls & 0xF))
+ break;
+ }
+ }
+
+ thread_local.pktin_polls++;
+}
+
+/*
+ * Schedule queues
+ */
+static int do_schedule(odp_queue_t *out_queue,
+ odp_event_t out_ev[], unsigned int max_num)
+{
+ int prio, count;
+
+ /* Consume locally cached events */
+ count = pop_cache_events(out_ev, max_num);
+ if (count > 0) {
+ assign_queue_handle(out_queue);
+ return count;
+ }
+
+ schedule_release_context();
+
+ if (odp_unlikely(thread_local.pause))
+ return count;
+
+ DO_SCHED_LOCK();
+ /* Schedule events */
+ for (prio = 0; prio < NUM_SCHED_PRIO; prio++) {
+ /* Round robin iterate the interested queue
+ * indexes in this priority level to compete
+ * and consume available queues
+ */
+ if (!do_schedule_prio(prio))
+ continue;
+
+ count = pop_cache_events(out_ev, max_num);
+ assign_queue_handle(out_queue);
+ DO_SCHED_UNLOCK();
+ return count;
+ }
+
+ DO_SCHED_UNLOCK();
+
+ /* Poll packet input when there are no events */
+ pktio_poll_input();
+ return 0;
+}
+
+static int schedule_loop(odp_queue_t *out_queue, uint64_t wait,
+ odp_event_t out_ev[], unsigned int max_num)
+{
+ int count, first = 1;
+ odp_time_t next, wtime;
+
+ while (1) {
+ count = do_schedule(out_queue, out_ev, max_num);
+
+ if (count)
+ break;
+
+ if (wait == ODP_SCHED_WAIT)
+ continue;
+
+ if (wait == ODP_SCHED_NO_WAIT)
+ break;
+
+ if (first) {
+ wtime = odp_time_local_from_ns(wait);
+ next = odp_time_sum(odp_time_local(), wtime);
+ first = 0;
+ continue;
+ }
+
+ if (odp_time_cmp(next, odp_time_local()) < 0)
+ break;
+ }
+
+ return count;
+}
+
+static odp_event_t schedule(odp_queue_t *out_queue, uint64_t wait)
+{
+ odp_event_t ev;
+
+ ev = ODP_EVENT_INVALID;
+
+ schedule_loop(out_queue, wait, &ev, 1);
+
+ return ev;
+}
+
+static int schedule_multi(odp_queue_t *out_queue, uint64_t wait,
+ odp_event_t events[], int num)
+{
+ return schedule_loop(out_queue, wait, events, num);
+}
+
+static void schedule_pause(void)
+{
+ thread_local.pause = 1;
+}
+
+static void schedule_resume(void)
+{
+ thread_local.pause = 0;
+}
+
+static uint64_t schedule_wait_time(uint64_t ns)
+{
+ return ns;
+}
+
+static int number_of_priorites(void)
+{
+ return NUM_SCHED_PRIO;
+}
+
+/*
+ * Create a named schedule group with pre-defined
+ * set of subscription threads.
+ *
+ * Sched queues belonging to this group must be
+ * created after the group creation. Upon creation
+ * the group holds 0 sched queues.
+ */
+static odp_schedule_group_t schedule_group_create(
+ const char *name, const odp_thrmask_t *mask)
+{
+ int group;
+ sched_group_t *G;
+
+ for (group = SCHED_GROUP_NAMED;
+ group < NUM_SCHED_GRPS; group++) {
+ G = &sched->groups[group];
+
+ odp_rwlock_write_lock(&G->lock);
+ if (!G->allocated) {
+ strncpy(G->name, name ? name : "",
+ ODP_SCHED_GROUP_NAME_LEN - 1);
+ odp_thrmask_copy(&G->threads, mask);
+ wapl_bitmap_zero(&G->queues);
+
+ G->allocated = true;
+ odp_rwlock_write_unlock(&G->lock);
+ return (odp_schedule_group_t)group;
+ }
+ odp_rwlock_write_unlock(&G->lock);
+ }
+
+ return ODP_SCHED_GROUP_INVALID;
+}
+
+static inline void __destroy_group_queues(sched_group_t *group)
+{
+ unsigned int index;
+ queue_index_bitmap_t queues;
+ wapl_bitmap_iterator_t it;
+
+ /* Constructor */
+ wapl_bitmap_zero(&queues);
+ wapl_bitmap_copy(&queues, &group->queues);
+ wapl_bitmap_iterator(&it, &queues);
+
+ /* Walk through the queue index bitmap */
+ for (it.start(&it); it.has_next(&it);) {
+ index = it.next(&it);
+ __destroy_sched_queue(group, index);
+ }
+}
+
+/*
+ * Destroy a named schedule group.
+ */
+static int schedule_group_destroy(odp_schedule_group_t group)
+{
+ int done = -1;
+ sched_group_t *G;
+
+ if (group < SCHED_GROUP_NAMED ||
+ group >= NUM_SCHED_GRPS)
+ return -1;
+
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ if (G->allocated) {
+ /* Destroy all queues in this schedule group
+ * and leave no orphan queues.
+ */
+ __destroy_group_queues(G);
+
+ done = 0;
+ G->allocated = false;
+ wapl_bitmap_zero(&G->queues);
+ odp_thrmask_zero(&G->threads);
+ memset(G->name, 0, ODP_SCHED_GROUP_NAME_LEN);
+ }
+
+ odp_rwlock_write_unlock(&G->lock);
+ return done;
+}
+
+static odp_schedule_group_t schedule_group_lookup(const char *name)
+{
+ int group;
+ sched_group_t *G;
+
+ for (group = SCHED_GROUP_NAMED;
+ group < NUM_SCHED_GRPS; group++) {
+ G = &sched->groups[group];
+
+ odp_rwlock_read_lock(&G->lock);
+ if (strcmp(name, G->name) == 0) {
+ odp_rwlock_read_unlock(&G->lock);
+ return (odp_schedule_group_t)group;
+ }
+ odp_rwlock_read_unlock(&G->lock);
+ }
+
+ return ODP_SCHED_GROUP_INVALID;
+}
+
+static int schedule_group_join(odp_schedule_group_t group,
+ const odp_thrmask_t *mask)
+{
+ int done = -1, thread;
+ sched_group_t *G;
+ sched_thread_local_t *local;
+
+ /* Named schedule group only */
+ if (group < SCHED_GROUP_NAMED ||
+ group >= NUM_SCHED_GRPS)
+ return done;
+
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ if (G->allocated) {
+ /* Make new joined threads to start check
+ * queue indexes in this schedule group
+ */
+ thread = odp_thrmask_first(mask);
+ while (thread >= 0) {
+ local = sched->threads[thread];
+ thread_set_interests(local, &G->queues);
+
+ odp_thrmask_set(&G->threads, thread);
+ thread = odp_thrmask_next(mask, thread);
+ }
+ done = 0;
+ }
+
+ odp_rwlock_write_unlock(&G->lock);
+ return done;
+}
+
+static int schedule_group_leave(odp_schedule_group_t group,
+ const odp_thrmask_t *mask)
+{
+ int done = -1, thread;
+ sched_group_t *G;
+ sched_thread_local_t *local;
+
+ /* Named schedule group only */
+ if (group < SCHED_GROUP_NAMED ||
+ group >= NUM_SCHED_GRPS)
+ return done;
+
+ G = &sched->groups[group];
+ odp_rwlock_write_lock(&G->lock);
+
+ if (G->allocated) {
+ /* Make leaving threads to stop check
+ * queue indexes in this schedule group
+ */
+ thread = odp_thrmask_first(mask);
+ while (thread >= 0) {
+ local = sched->threads[thread];
+ thread_clear_interests(local, &G->queues);
+
+ odp_thrmask_clr(&G->threads, thread);
+ thread = odp_thrmask_next(mask, thread);
+ }
+ done = 0;
+ }
+
+ odp_rwlock_write_unlock(&G->lock);
+ return done;
+}
+
+static int schedule_group_thrmask(odp_schedule_group_t group,
+ odp_thrmask_t *thrmask)
+{
+ int done = -1;
+ sched_group_t *G;
+
+ /* Named schedule group only */
+ if (group < SCHED_GROUP_NAMED ||
+ group >= NUM_SCHED_GRPS)
+ return done;
+
+ G = &sched->groups[group];
+ odp_rwlock_read_lock(&G->lock);
+
+ if (G->allocated && thrmask != NULL) {
+ done = 0;
+ odp_thrmask_copy(thrmask, &G->threads);
+ }
+
+ odp_rwlock_read_unlock(&G->lock);
+ return done;
+}
+
+static int schedule_group_info(odp_schedule_group_t group,
+ odp_schedule_group_info_t *info)
+{
+ int done = -1;
+ sched_group_t *G;
+
+ /* Named schedule group only */
+ if (group < SCHED_GROUP_NAMED ||
+ group >= NUM_SCHED_GRPS)
+ return done;
+
+ G = &sched->groups[group];
+ odp_rwlock_read_lock(&G->lock);
+
+ if (G->allocated && info != NULL) {
+ done = 0;
+ info->name = G->name;
+ odp_thrmask_copy(&info->thrmask, &G->threads);
+ }
+
+ odp_rwlock_read_unlock(&G->lock);
+ return done;
+}
+
+/* This function is a no-op */
+static void schedule_prefetch(int num ODP_UNUSED)
+{
+}
+
+/*
+ * Limited to join and leave pre-defined schedule groups
+ * before and after thread local initialization or termination.
+ */
+static int group_add_thread(odp_schedule_group_t group, int thread)
+{
+ sched_group_t *G;
+
+ if (group < 0 || group >= SCHED_GROUP_NAMED)
+ return -1;
+
+ G = &sched->groups[group];
+
+ odp_rwlock_write_lock(&G->lock);
+ odp_thrmask_set(&G->threads, thread);
+ odp_rwlock_write_unlock(&G->lock);
+ return 0;
+}
+
+static int group_remove_thread(odp_schedule_group_t group, int thread)
+{
+ sched_group_t *G;
+
+ if (group < 0 || group >= SCHED_GROUP_NAMED)
+ return -1;
+
+ G = &sched->groups[group];
+
+ odp_rwlock_write_lock(&G->lock);
+ odp_thrmask_clr(&G->threads, thread);
+ odp_rwlock_write_unlock(&G->lock);
+ return 0;
+}
+
+static int number_of_groups(void)
+{
+ return NUM_SCHED_GRPS;
+}
+
+static int schedule_sched_queue(uint32_t queue_index)
+{
+ /* Set available indications globally */
+ sched->availables[queue_index] = true;
+ return 0;
+}
+
+static int schedule_unsched_queue(uint32_t queue_index)
+{
+ /* Clear available indications globally */
+ sched->availables[queue_index] = false;
+ return 0;
+}
+
+static void schedule_release_atomic(void)
+{
+ unsigned int queue_index;
+
+ if ((thread_local.atomic != NULL) &&
+ (thread_local.cache.count == 0)) {
+ queue_index = thread_local.atomic - sched->availables;
+ thread_local.atomic = NULL;
+ sched->availables[queue_index] = true;
+ }
+}
+
+static inline int ordered_own_turn(queue_entry_t *queue)
+{
+ uint64_t ctx;
+
+ ctx = odp_atomic_load_acq_u64(&queue->s.ordered.ctx);
+
+ return ctx == thread_local.ordered.ctx;
+}
+
+static inline void wait_for_order(queue_entry_t *queue)
+{
+ /* Busy loop to synchronize ordered processing */
+ while (1) {
+ if (ordered_own_turn(queue))
+ break;
+ odp_cpu_pause();
+ }
+}
+
+/**
+ * Perform stashed enqueue operations
+ *
+ * Should be called only when already in order.
+ */
+static inline void ordered_stash_release(void)
+{
+ int i;
+
+ for (i = 0; i < thread_local.ordered.stash_num; i++) {
+ queue_entry_t *queue;
+ odp_buffer_hdr_t **buf_hdr;
+ int num;
+
+ queue = thread_local.ordered.stash[i].queue;
+ buf_hdr = thread_local.ordered.stash[i].buf_hdr;
+ num = thread_local.ordered.stash[i].num;
+
+ queue_enq_multi(queue, buf_hdr, num);
+ }
+ thread_local.ordered.stash_num = 0;
+}
+
+static inline void release_ordered(void)
+{
+ unsigned i;
+ queue_entry_t *queue;
+
+ queue = thread_local.ordered.src_queue;
+
+ wait_for_order(queue);
+
+ /* Release all ordered locks */
+ for (i = 0; i < queue->s.param.sched.lock_count; i++) {
+ if (!thread_local.ordered.lock_called.u8[i])
+ odp_atomic_store_rel_u64(&queue->s.ordered.lock[i],
+ thread_local.ordered.ctx + 1);
+ }
+
+ thread_local.ordered.lock_called.all = 0;
+ thread_local.ordered.src_queue = NULL;
+ thread_local.ordered.in_order = 0;
+
+ ordered_stash_release();
+
+ /* Next thread can continue processing */
+ odp_atomic_add_rel_u64(&queue->s.ordered.ctx, 1);
+}
+
+static void schedule_release_ordered(void)
+{
+ queue_entry_t *queue;
+
+ queue = thread_local.ordered.src_queue;
+
+ if (odp_unlikely(!queue || thread_local.cache.count))
+ return;
+
+ release_ordered();
+}
+
+static inline void schedule_release_context(void)
+{
+ if (thread_local.ordered.src_queue != NULL)
+ release_ordered();
+ else
+ schedule_release_atomic();
+}
+
+static int schedule_ord_enq_multi(uint32_t queue_index, void *buf_hdr[],
+ int num, int *ret)
+{
+ int i;
+ uint32_t stash_num = thread_local.ordered.stash_num;
+ queue_entry_t *dst_queue = get_qentry(queue_index);
+ queue_entry_t *src_queue = thread_local.ordered.src_queue;
+
+ if (!thread_local.ordered.src_queue || thread_local.ordered.in_order)
+ return 0;
+
+ if (ordered_own_turn(src_queue)) {
+ /* Own turn, so can do enqueue directly. */
+ thread_local.ordered.in_order = 1;
+ ordered_stash_release();
+ return 0;
+ }
+
+ if (odp_unlikely(stash_num >= MAX_ORDERED_STASH)) {
+ /* If the local stash is full, wait until it is our turn and
+ * then release the stash and do enqueue directly. */
+ wait_for_order(src_queue);
+
+ thread_local.ordered.in_order = 1;
+
+ ordered_stash_release();
+ return 0;
+ }
+
+ thread_local.ordered.stash[stash_num].queue = dst_queue;
+ thread_local.ordered.stash[stash_num].num = num;
+ for (i = 0; i < num; i++)
+ thread_local.ordered.stash[stash_num].buf_hdr[i] = buf_hdr[i];
+
+ thread_local.ordered.stash_num++;
+
+ *ret = num;
+ return 1;
+}
+
+static void order_lock(void)
+{
+ queue_entry_t *queue;
+
+ queue = thread_local.ordered.src_queue;
+
+ if (!queue)
+ return;
+
+ wait_for_order(queue);
+}
+
+static void order_unlock(void)
+{
+}
+
+static void schedule_order_lock(unsigned lock_index)
+{
+ odp_atomic_u64_t *ord_lock;
+ queue_entry_t *queue;
+
+ queue = thread_local.ordered.src_queue;
+
+ ODP_ASSERT(queue && lock_index <= queue->s.param.sched.lock_count &&
+ !thread_local.ordered.lock_called.u8[lock_index]);
+
+ ord_lock = &queue->s.ordered.lock[lock_index];
+
+ /* Busy loop to synchronize ordered processing */
+ while (1) {
+ uint64_t lock_seq;
+
+ lock_seq = odp_atomic_load_acq_u64(ord_lock);
+
+ if (lock_seq == thread_local.ordered.ctx) {
+ thread_local.ordered.lock_called.u8[lock_index] = 1;
+ return;
+ }
+ odp_cpu_pause();
+ }
+}
+
+static void schedule_order_unlock(unsigned lock_index)
+{
+ odp_atomic_u64_t *ord_lock;
+ queue_entry_t *queue;
+
+ queue = thread_local.ordered.src_queue;
+
+ ODP_ASSERT(queue && lock_index <= queue->s.param.sched.lock_count);
+
+ ord_lock = &queue->s.ordered.lock[lock_index];
+
+ ODP_ASSERT(thread_local.ordered.ctx == odp_atomic_load_u64(ord_lock));
+
+ odp_atomic_store_rel_u64(ord_lock, thread_local.ordered.ctx + 1);
+}
+
+static unsigned schedule_max_ordered_locks(void)
+{
+ return MAX_ORDERED_LOCKS_PER_QUEUE;
+}
+
+static void schedule_save_context(queue_entry_t *queue)
+{
+ if (queue->s.param.sched.sync == ODP_SCHED_SYNC_ATOMIC) {
+ thread_local.atomic = &sched->availables[queue->s.index];
+ } else if (queue->s.param.sched.sync == ODP_SCHED_SYNC_ORDERED) {
+ uint64_t ctx;
+ odp_atomic_u64_t *next_ctx;
+
+ next_ctx = &queue->s.ordered.next_ctx;
+ ctx = odp_atomic_fetch_inc_u64(next_ctx);
+
+ thread_local.ordered.ctx = ctx;
+ thread_local.ordered.src_queue = queue;
+ }
+}
+
+/* Fill in scheduler interface */
+const schedule_fn_t schedule_iquery_fn = {
+ .pktio_start = schedule_pktio_start,
+ .thr_add = group_add_thread,
+ .thr_rem = group_remove_thread,
+ .num_grps = number_of_groups,
+ .init_queue = init_sched_queue,
+ .destroy_queue = destroy_sched_queue,
+ .sched_queue = schedule_sched_queue,
+ .unsched_queue = schedule_unsched_queue,
+ .ord_enq_multi = schedule_ord_enq_multi,
+ .init_global = schedule_init_global,
+ .term_global = schedule_term_global,
+ .init_local = schedule_init_local,
+ .term_local = schedule_term_local,
+ .order_lock = order_lock,
+ .order_unlock = order_unlock,
+ .max_ordered_locks = schedule_max_ordered_locks,
+ .save_context = schedule_save_context,
+};
+
+/* Fill in scheduler API calls */
+const schedule_api_t schedule_iquery_api = {
+ .schedule_wait_time = schedule_wait_time,
+ .schedule = schedule,
+ .schedule_multi = schedule_multi,
+ .schedule_pause = schedule_pause,
+ .schedule_resume = schedule_resume,
+ .schedule_release_atomic = schedule_release_atomic,
+ .schedule_release_ordered = schedule_release_ordered,
+ .schedule_prefetch = schedule_prefetch,
+ .schedule_num_prio = number_of_priorites,
+ .schedule_group_create = schedule_group_create,
+ .schedule_group_destroy = schedule_group_destroy,
+ .schedule_group_lookup = schedule_group_lookup,
+ .schedule_group_join = schedule_group_join,
+ .schedule_group_leave = schedule_group_leave,
+ .schedule_group_thrmask = schedule_group_thrmask,
+ .schedule_group_info = schedule_group_info,
+ .schedule_order_lock = schedule_order_lock,
+ .schedule_order_unlock = schedule_order_unlock
+};
+
+static void thread_set_interest(sched_thread_local_t *thread,
+ unsigned int queue_index, int prio)
+{
+ queue_index_sparse_t *index;
+
+ if (thread == NULL)
+ return;
+
+ if (prio >= NUM_SCHED_PRIO)
+ return;
+
+ index = &thread->indexes[prio];
+
+ odp_rwlock_write_lock(&thread->lock);
+ sparse_bitmap_set(index, queue_index);
+ odp_rwlock_write_unlock(&thread->lock);
+}
+
+static void thread_clear_interest(sched_thread_local_t *thread,
+ unsigned int queue_index, int prio)
+{
+ queue_index_sparse_t *index;
+
+ if (thread == NULL)
+ return;
+
+ if (prio >= NUM_SCHED_PRIO)
+ return;
+
+ index = &thread->indexes[prio];
+
+ odp_rwlock_write_lock(&thread->lock);
+ sparse_bitmap_clear(index, queue_index);
+ odp_rwlock_write_unlock(&thread->lock);
+}
+
+static void thread_set_interests(sched_thread_local_t *thread,
+ queue_index_bitmap_t *set)
+{
+ int prio;
+ sched_prio_t *P;
+ unsigned int queue_index;
+ queue_index_bitmap_t subset;
+ wapl_bitmap_iterator_t it;
+
+ if (thread == NULL || set == NULL)
+ return;
+
+ for (prio = 0; prio < NUM_SCHED_PRIO; prio++) {
+ P = &sched->prios[prio];
+ odp_rwlock_read_lock(&P->lock);
+
+ /* The collection of queue indexes in 'set'
+ * may belong to several priority levels.
+ */
+ wapl_bitmap_zero(&subset);
+ wapl_bitmap_and(&subset, &P->queues, set);
+
+ odp_rwlock_read_unlock(&P->lock);
+
+ /* Add the subset to local indexes */
+ wapl_bitmap_iterator(&it, &subset);
+ for (it.start(&it); it.has_next(&it);) {
+ queue_index = it.next(&it);
+ thread_set_interest(thread, queue_index, prio);
+ }
+ }
+}
+
+static void thread_clear_interests(sched_thread_local_t *thread,
+ queue_index_bitmap_t *clear)
+{
+ int prio;
+ sched_prio_t *P;
+ unsigned int queue_index;
+ queue_index_bitmap_t subset;
+ wapl_bitmap_iterator_t it;
+
+ if (thread == NULL || clear == NULL)
+ return;
+
+ for (prio = 0; prio < NUM_SCHED_PRIO; prio++) {
+ P = &sched->prios[prio];
+ odp_rwlock_read_lock(&P->lock);
+
+ /* The collection of queue indexes in 'clear'
+ * may belong to several priority levels.
+ */
+ wapl_bitmap_zero(&subset);
+ wapl_bitmap_and(&subset, &P->queues, clear);
+
+ odp_rwlock_read_unlock(&P->lock);
+
+ /* Remove the subset from local indexes */
+ wapl_bitmap_iterator(&it, &subset);
+ for (it.start(&it); it.has_next(&it);) {
+ queue_index = it.next(&it);
+ thread_clear_interest(thread, queue_index, prio);
+ }
+ }
+}
+
+static inline bool is_atomic_queue(unsigned int queue_index)
+{
+ return (sched->queues[queue_index].sync
+ == ODP_SCHED_SYNC_ATOMIC);
+}
+
+static inline bool is_ordered_queue(unsigned int queue_index)
+{
+ return (sched->queues[queue_index].sync
+ == ODP_SCHED_SYNC_ORDERED);
+}
+
+static inline bool compete_atomic_queue(unsigned int queue_index)
+{
+ bool expected = sched->availables[queue_index];
+
+ if (expected && is_atomic_queue(queue_index)) {
+ expected = __atomic_compare_exchange_n(
+ &sched->availables[queue_index],
+ &expected, false, 0,
+ __ATOMIC_RELEASE, __ATOMIC_RELAXED);
+ }
+
+ return expected;
+}
+
+static inline int consume_queue(int prio, unsigned int queue_index)
+{
+ int count;
+ unsigned int max = MAX_DEQ;
+ event_cache_t *cache = &thread_local.cache;
+
+ /* Low priorities have smaller batch size to limit
+ * head of line blocking latency.
+ */
+ if (odp_unlikely(prio > ODP_SCHED_PRIO_DEFAULT))
+ max = MAX_DEQ / 2;
+
+ /* For ordered queues we want consecutive events to
+ * be dispatched to separate threads, so do not cache
+ * them locally.
+ */
+ if (is_ordered_queue(queue_index))
+ max = 1;
+
+ count = sched_cb_queue_deq_multi(
+ queue_index, cache->stash, max);
+
+ if (count < 0) {
+ DO_SCHED_UNLOCK();
+ sched_cb_queue_destroy_finalize(queue_index);
+ DO_SCHED_LOCK();
+ return 0;
+ }
+
+ if (count == 0)
+ return 0;
+
+ cache->top = &cache->stash[0];
+ cache->count = count;
+ cache->queue = sched_cb_queue_handle(queue_index);
+ return count;
+}
+
+static inline bool do_schedule_prio(int prio)
+{
+ int nbits, next, end;
+ unsigned int queue_index;
+ sparse_bitmap_iterator_t *it;
+
+ it = &thread_local.iterators[prio];
+ nbits = (int)*it->_base.last;
+
+ /* No interests at all! */
+ if (nbits <= 0)
+ return false;
+
+ /* In critical path, cannot afford iterator calls,
+ * do it manually with internal knowledge
+ */
+ it->_start = (it->_start + 1) % nbits;
+ end = it->_start + nbits;
+
+ for (next = it->_start; next < end; next++) {
+ queue_index = it->_base.il[next % nbits];
+
+ if (!compete_atomic_queue(queue_index))
+ continue;
+
+ if (!consume_queue(prio, queue_index))
+ continue;
+
+ return true;
+ }
+
+ return false;
+}
commit 6ec758bd738b86c48b5ae7ba01759aeb95c18e01
Author: Yi He <yi.he(a)linaro.org>
Date: Wed Jan 11 07:50:32 2017 +0000
linux-gen: add generic bitmaps and iterators
Add C++ template alike bitmap<size> to allow
instantiate bitmap data structure of any size,
and provide iterators to help walking through
the bitmap objects.
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index bfcbb5a..ba47d0b 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -111,6 +111,7 @@ noinst_HEADERS = \
${srcdir}/include/odp_align_internal.h \
${srcdir}/include/odp_atomic_internal.h \
${srcdir}/include/odp_buffer_inlines.h \
+ ${srcdir}/include/odp_bitmap_internal.h \
${srcdir}/include/odp_buffer_internal.h \
${srcdir}/include/odp_classification_datamodel.h \
${srcdir}/include/odp_classification_inlines.h \
@@ -154,6 +155,7 @@ __LIB__libodp_linux_la_SOURCES = \
_ishmphy.c \
odp_atomic.c \
odp_barrier.c \
+ odp_bitmap.c \
odp_buffer.c \
odp_byteorder.c \
odp_classification.c \
diff --git a/platform/linux-generic/include/odp_bitmap_internal.h b/platform/linux-generic/include/odp_bitmap_internal.h
new file mode 100644
index 0000000..1be4d02
--- /dev/null
+++ b/platform/linux-generic/include/odp_bitmap_internal.h
@@ -0,0 +1,317 @@
+/* Copyright (c) 2016, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * @file
+ *
+ * ODP generic bitmap types and operations.
+ */
+
+#ifndef ODP_BITMAP_INTERNAL_H_
+#define ODP_BITMAP_INTERNAL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <odp/api/hints.h>
+
+/* Generate unique identifier for instantiated class */
+#define TOKENIZE(template, line) \
+ template ## _ ## line ## _ ## __COUNTER__
+
+/* Array size in general */
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
+
+#define BITS_PER_BYTE (8)
+#define BITS_PER_LONG __WORDSIZE
+#define BYTES_PER_LONG (BITS_PER_LONG / BITS_PER_BYTE)
+
+#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
+#define BITS_TO_LONGS(nr) BIT_WORD(nr + BITS_PER_LONG - 1)
+
+#define BITMAP_FIRST_WORD_MASK(start) \
+ (~0UL << ((start) & (BITS_PER_LONG - 1)))
+#define BITMAP_LAST_WORD_MASK(nbits) \
+ (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
+
+/* WAPL bitmap base class */
+typedef struct {
+ unsigned int nwords;
+ unsigned int *pl;
+ unsigned long *ul;
+} wapl_bitmap_t;
+
+/*
+ * Word-Aligned Position List (WAPL) bitmap, which actually
+ * is not a compression, but with an extra list of non-empty
+ * word positions.
+ *
+ * WAPL accelerates bitwise operations and iterations by
+ * applying only to non-empty positions instead of walking
+ * through the whole bitmap.
+ *
+ * WAPL uses [1 ~ N] instead of [0 ~ N - 1] as position
+ * values and an extra 0 as end indicator for position list.
+ * This is the reason to allocate one extra room below.
+ */
+#define instantiate_wapl_bitmap(line, nbits) \
+ struct TOKENIZE(wapl_bitmap, line) { \
+ unsigned int pl[BITS_TO_LONGS(nbits) + 1]; \
+ unsigned long ul[BITS_TO_LONGS(nbits) + 1]; \
+ }
+
+#define WAPL_BITMAP(nbits) instantiate_wapl_bitmap(__LINE__, nbits)
+
+/*
+ * Upcast any derived WAPL bitmap class to its base class
+ */
+#define __wapl_upcast(base, derived) \
+ do { \
+ __typeof__(derived) p = derived; \
+ base.pl = p->pl; \
+ base.ul = p->ul; \
+ base.nwords = ARRAY_SIZE(p->ul) - 1; \
+ } while (0)
+
+/*
+ * WAPL base class bitmap operations
+ */
+void __wapl_bitmap_and(wapl_bitmap_t *dst,
+ wapl_bitmap_t *src, wapl_bitmap_t *and);
+
+void __wapl_bitmap_or(wapl_bitmap_t *dst, wapl_bitmap_t *or);
+
+void __wapl_bitmap_set(wapl_bitmap_t *map, unsigned int bit);
+
+void __wapl_bitmap_clear(wapl_bitmap_t *map, unsigned int bit);
+
+/*
+ * Generic WAPL bitmap operations
+ */
+#define wapl_bitmap_zero(map) \
+ ({ \
+ __typeof__(map) p = map; \
+ memset((void *)p, 0, sizeof(__typeof__(*p))); \
+ })
+
+#define wapl_bitmap_copy(dst, src) \
+ ({ \
+ __typeof__(dst) d = dst; \
+ __typeof__(src) s = src; \
+ if (d != s) \
+ memcpy((void *)d, (void *)s, \
+ sizeof(__typeof__(*d))); \
+ })
+
+#define wapl_bitmap_and(dst, src, and) \
+ ({ \
+ wapl_bitmap_t d, s, a; \
+ __wapl_upcast(d, dst); \
+ __wapl_upcast(s, src); \
+ __wapl_upcast(a, and); \
+ __wapl_bitmap_and(&d, &s, &a); \
+ })
+
+#define wapl_bitmap_or(dst, src, or) \
+ ({ \
+ wapl_bitmap_t d, o; \
+ wapl_bitmap_copy(dst, src); \
+ __wapl_upcast(d, dst); \
+ __wapl_upcast(o, or); \
+ __wapl_bitmap_or(&d, &o); \
+ })
+
+#define wapl_bitmap_set(map, bit) \
+ ({ \
+ wapl_bitmap_t b; \
+ __wapl_upcast(b, map); \
+ __wapl_bitmap_set(&b, bit); \
+ })
+
+#define wapl_bitmap_clear(map, bit) \
+ ({ \
+ wapl_bitmap_t b; \
+ __wapl_upcast(b, map); \
+ __wapl_bitmap_clear(&b, bit); \
+ })
+
+/*
+ * Round robin iterator runs upon a WAPL bitmap:
+ *
+ * wapl_bitmap_iterator(iterator, WAPL bitmap);
+ * for (iterator->start(); iterator->has_next(); ) {
+ * unsigned int bit_index = iterator->next();
+ * ...operations on this bit index...
+ * }
+ */
+typedef struct wapl_bitmap_iterator {
+ int _start, _next, _nbits;
+ wapl_bitmap_t _base;
+
+ void (*start)(struct wapl_bitmap_iterator *this);
+ bool (*has_next)(struct wapl_bitmap_iterator *this);
+ unsigned int (*next)(struct wapl_bitmap_iterator *this);
+} wapl_bitmap_iterator_t;
+
+/*
+ * WAPL bitmap iterator constructor
+ */
+void __wapl_bitmap_iterator(wapl_bitmap_iterator_t *this);
+
+/*
+ * Generic constructor accepts any derived WAPL bitmap class
+ */
+#define wapl_bitmap_iterator(iterator, map) \
+ ({ \
+ __typeof__(iterator) __it = iterator; \
+ __wapl_upcast(__it->_base, map); \
+ __wapl_bitmap_iterator(__it); \
+ })
+
+/* Sparse bitmap base class */
+typedef struct {
+ unsigned int nbits;
+ unsigned int *last, *pl, *il;
+} sparse_bitmap_t;
+
+/*
+ * Sparse bitmap, lists all bit indexes directly as an array.
+ * Expected to be significantly straightforward iteration.
+ */
+#define instantiate_sparse_bitmap(line, nbits) \
+ struct TOKENIZE(sparse_bitmap, line) { \
+ unsigned int last; \
+ unsigned int pl[nbits]; \
+ unsigned int il[nbits]; \
+ }
+
+#define SPARSE_BITMAP(nbits) instantiate_sparse_bitmap(__LINE__, nbits)
+
+/*
+ * Upcast any derived sparse bitmap class to its base class
+ */
+#define __sparse_upcast(base, derived) \
+ do { \
+ __typeof__(derived) p = derived; \
+ base.pl = p->pl; \
+ base.il = p->il; \
+ base.last = &p->last; \
+ base.nbits = ARRAY_SIZE(p->il); \
+ } while (0)
+
+/*
+ * Sparse base class bitmap operations
+ */
+void __sparse_bitmap_set(sparse_bitmap_t *map, unsigned int bit);
+
+void __sparse_bitmap_clear(sparse_bitmap_t *map, unsigned int bit);
+
+/*
+ * Generic sparse bitmap operations
+ */
+#define sparse_bitmap_zero(map) \
+ ({ \
+ __typeof__(map) p = map; \
+ memset((void *)p, 0, sizeof(__typeof__(*p))); \
+ })
+
+#define sparse_bitmap_set(map, bit) \
+ ({ \
+ sparse_bitmap_t b; \
+ __sparse_upcast(b, map); \
+ __sparse_bitmap_set(&b, bit); \
+ })
+
+#define sparse_bitmap_clear(map, bit) \
+ ({ \
+ sparse_bitmap_t b; \
+ __sparse_upcast(b, map); \
+ __sparse_bitmap_clear(&b, bit); \
+ })
+
+/*
+ * Round robin iterator runs upon a sparse bitmap:
+ *
+ * sparse_bitmap_iterator(iterator, SPARSE bitmap);
+ * for (iterator->start(); iterator->has_next(); ) {
+ * unsigned int bit_index = iterator->next();
+ * ...operations on this bit index...
+ * }
+ */
+typedef struct sparse_bitmap_iterator {
+ int _start, _next, _nbits;
+ sparse_bitmap_t _base;
+
+ void (*start)(struct sparse_bitmap_iterator *this);
+ bool (*has_next)(struct sparse_bitmap_iterator *this);
+ unsigned int (*next)(struct sparse_bitmap_iterator *this);
+} sparse_bitmap_iterator_t;
+
+/*
+ * Sparse bitmap iterator constructor
+ */
+void __sparse_bitmap_iterator(sparse_bitmap_iterator_t *this);
+
+/*
+ * Generic constructor accepts any derived sparse bitmap class.
+ */
+#define sparse_bitmap_iterator(iterator, map) \
+ ({ \
+ __typeof__(iterator) __it = iterator; \
+ __sparse_upcast(__it->_base, map); \
+ __sparse_bitmap_iterator(__it); \
+ })
+
+/*
+ * Raw bitmap atomic set and clear.
+ */
+void raw_bitmap_set(unsigned long *map, unsigned int bit);
+
+void raw_bitmap_clear(unsigned long *map, unsigned int bit);
+
+/*
+ * It will enter infinite loop incase that all bits are zero,
+ * so please make sure the bitmap at least has one set.
+ */
+static inline int __bitmap_wraparound_next(
+ unsigned long *addr, unsigned int nbits, int start)
+{
+ unsigned long tmp;
+
+ if (start >= (int)nbits)
+ start = 0;
+
+ tmp = addr[BIT_WORD(start)];
+
+ /* Handle 1st word. */
+ tmp &= BITMAP_FIRST_WORD_MASK(start);
+ start = start & ~(BITS_PER_LONG - 1);
+
+ while (!tmp) {
+ start += BITS_PER_LONG;
+ if (start >= (int)nbits)
+ start = 0;
+
+ tmp = addr[BIT_WORD(start)];
+ }
+
+ start += __builtin_ffsl(tmp) - 1;
+ return start;
+}
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/platform/linux-generic/odp_bitmap.c b/platform/linux-generic/odp_bitmap.c
new file mode 100644
index 0000000..a29b9ef
--- /dev/null
+++ b/platform/linux-generic/odp_bitmap.c
@@ -0,0 +1,315 @@
+/* Copyright (c) 2016, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include <odp/api/std_types.h>
+#include <odp/api/byteorder.h>
+#include <odp_bitmap_internal.h>
+
+/*
+ * WAPL base class bitmap operations
+ */
+static inline void __wapl_add_pos(
+ wapl_bitmap_t *map, unsigned int p)
+{
+ unsigned int s, k = 0;
+ unsigned int *pl = map->pl;
+
+ while (pl[k] && p > pl[k])
+ k++;
+
+ if (p == pl[k])
+ return;
+
+ /* sorted insertion */
+ for (; pl[k] && p < pl[k]; k++) {
+ s = pl[k];
+ pl[k] = p;
+ p = s;
+ }
+
+ if (k < map->nwords)
+ pl[k++] = p;
+
+ pl[k] = 0;
+}
+
+static inline void __wapl_remove_pos(
+ wapl_bitmap_t *map, unsigned int p)
+{
+ unsigned int k = 0;
+ unsigned int *pl = map->pl;
+
+ while (pl[k] && p != pl[k])
+ k++;
+
+ for (; pl[k]; k++)
+ pl[k] = pl[k + 1];
+}
+
+void __wapl_bitmap_and(wapl_bitmap_t *dst,
+ wapl_bitmap_t *src, wapl_bitmap_t *and)
+{
+ unsigned int k = 0, p;
+ unsigned int *pl = src->pl;
+
+ while ((p = *pl++) != 0) {
+ dst->ul[p] = src->ul[p] & and->ul[p];
+ if (dst->ul[p])
+ dst->pl[k++] = p;
+ }
+
+ dst->pl[k] = 0;
+}
+
+void __wapl_bitmap_or(wapl_bitmap_t *dst, wapl_bitmap_t *or)
+{
+ unsigned int p;
+ unsigned int *pl = or->pl;
+
+ while ((p = *pl++) != 0) {
+ if (dst->ul[p] == 0)
+ __wapl_add_pos(dst, p);
+
+ dst->ul[p] |= or->ul[p];
+ }
+}
+
+void __wapl_bitmap_set(wapl_bitmap_t *map, unsigned int bit)
+{
+ unsigned int p = BIT_WORD(bit) + 1;
+ unsigned long set = 1UL << (bit & (BITS_PER_LONG - 1));
+
+ if (p > map->nwords)
+ return;
+
+ if (map->ul[p] == 0)
+ __wapl_add_pos(map, p);
+
+ map->ul[p] |= set;
+}
+
+void __wapl_bitmap_clear(wapl_bitmap_t *map, unsigned int bit)
+{
+ unsigned int p = BIT_WORD(bit) + 1;
+ unsigned long clear = 1UL << (bit & (BITS_PER_LONG - 1));
+
+ if (p > map->nwords)
+ return;
+
+ map->ul[p] &= ~clear;
+
+ if (map->ul[p] == 0)
+ __wapl_remove_pos(map, p);
+}
+
+/*
+ * WAPL bitmap iterator implementation
+ */
+static void __wapl_iterator_start(wapl_bitmap_iterator_t *this)
+{
+ this->_nbits = this->_base.nwords * BITS_PER_LONG;
+
+ /* Advance to next queue index to start this
+ * new round iteration.
+ */
+ if (this->_base.pl[0] == 0)
+ this->_start = -1;
+ else
+ this->_start = __bitmap_wraparound_next(
+ &this->_base.ul[1], this->_nbits, this->_start + 1);
+
+ this->_next = this->_start;
+}
+
+static bool __wapl_iterator_has_next(wapl_bitmap_iterator_t *this)
+{
+ return (this->_next != -1);
+}
+
+static unsigned int __wapl_iterator_next(wapl_bitmap_iterator_t *this)
+{
+ int next = this->_next;
+
+ this->_next = __bitmap_wraparound_next(
+ &this->_base.ul[1], this->_nbits, this->_next + 1);
+
+ if (this->_next == this->_start)
+ this->_next = -1;
+
+ return next;
+}
+
+void __wapl_bitmap_iterator(wapl_bitmap_iterator_t *this)
+{
+ this->start = __wapl_iterator_start;
+ this->has_next = __wapl_iterator_has_next;
+ this->next = __wapl_iterator_next;
+
+ this->_start = -1;
+ this->_next = this->_start;
+}
+
+/*
+ * Sparse base class bitmap operations
+ */
+void __sparse_bitmap_set(sparse_bitmap_t *map, unsigned int bit)
+{
+ unsigned int last = *map->last;
+
+ /* Index exceeds */
+ if (bit >= map->nbits)
+ return;
+
+ /* Full bitmap */
+ if (last >= map->nbits)
+ return;
+
+ /* Bit was not set previously,
+ * also record where we set the bit
+ */
+ if (!map->pl[bit]) {
+ map->il[last++] = bit;
+ map->pl[bit] = last;
+
+ *map->last = last;
+ }
+}
+
+void __sparse_bitmap_clear(sparse_bitmap_t *map, unsigned int bit)
+{
+ unsigned int p, i;
+ unsigned int last = *map->last;
+
+ /* Index exceeds */
+ if (bit >= map->nbits)
+ return;
+
+ /* Empty bitmap */
+ if (last == 0)
+ return;
+
+ /* Bit was set previously */
+ if (map->pl[bit]) {
+ p = map->pl[bit] - 1;
+ map->pl[bit] = 0;
+
+ last--;
+ *map->last = last;
+
+ /* Fill the hole with the latest index */
+ if (p < last) {
+ i = map->il[last];
+ map->pl[i] = p + 1;
+ map->il[p] = i;
+ }
+ }
+}
+
+/*
+ * Sparse bitmap iterator implementation
+ */
+static void __sparse_iterator_start(sparse_bitmap_iterator_t *this)
+{
+ this->_nbits = (int)*this->_base.last;
+
+ /* Advance to next queue index to start this
+ * new round iteration.
+ */
+ if (this->_nbits == 0)
+ this->_start = -1;
+ else
+ this->_start = (this->_start + 1) & (this->_nbits - 1);
+
+ this->_next = this->_start;
+}
+
+static bool __sparse_iterator_has_next(sparse_bitmap_iterator_t *this)
+{
+ return (this->_next != -1);
+}
+
+static unsigned int __sparse_iterator_next(sparse_bitmap_iterator_t *this)
+{
+ int next = this->_next;
+
+ this->_next = (this->_next + 1) & (this->_nbits - 1);
+ if (this->_next == this->_start)
+ this->_next = -1;
+
+ return this->_base.il[next];
+}
+
+void __sparse_bitmap_iterator(sparse_bitmap_iterator_t *this)
+{
+ this->start = __sparse_iterator_start;
+ this->has_next = __sparse_iterator_has_next;
+ this->next = __sparse_iterator_next;
+
+ this->_start = -1;
+ this->_next = this->_start;
+}
+
+/*
+ * Generic byte-width atomic set/clear
+ */
+static inline void atomic_byte_set(
+ unsigned char *addr, unsigned int bit)
+{
+ unsigned char load, store;
+ unsigned char set = 1 << (bit & (BITS_PER_BYTE - 1));
+
+ do {
+ load = *addr;
+ store = load | set;
+ } while (!__atomic_compare_exchange_n(addr, &load, store,
+ 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED));
+}
+
+static inline void atomic_byte_clear(
+ unsigned char *addr, unsigned int bit)
+{
+ unsigned char load, store;
+ unsigned char clear = 1 << (bit & (BITS_PER_BYTE - 1));
+
+ do {
+ load = *addr;
+ store = load & ~clear;
+ } while (!__atomic_compare_exchange_n(addr, &load, store,
+ 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED));
+}
+
+static inline unsigned char *__bit_byte(
+ unsigned long *word, unsigned int bit)
+{
+ unsigned int i;
+ unsigned char *b;
+
+ b = (unsigned char *)word;
+
+ i = bit & (BITS_PER_LONG - 1);
+ i = i / BITS_PER_BYTE;
+
+#if (ODP_BYTE_ORDER == ODP_BIG_ENDIAN)
+ i = BYTES_PER_LONG - 1 - i;
+#endif
+ return &b[i];
+}
+
+void raw_bitmap_set(unsigned long *map, unsigned int bit)
+{
+ unsigned long *p = map + BIT_WORD(bit);
+
+ atomic_byte_set(__bit_byte(p, bit), bit);
+}
+
+void raw_bitmap_clear(unsigned long *map, unsigned int bit)
+{
+ unsigned long *p = map + BIT_WORD(bit);
+
+ atomic_byte_clear(__bit_byte(p, bit), bit);
+}
commit 3e399ed202522790efa552666aa04dbfd9e06da4
Author: Yi He <yi.he(a)linaro.org>
Date: Wed Jan 11 07:50:31 2017 +0000
linux-gen: sched: add unsched_queue callback
Add this unsched_queue callback to indicate queue's
ineligible for scheduling.
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index c0aee42..530d157 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -25,6 +25,7 @@ typedef int (*schedule_init_queue_fn_t)(uint32_t queue_index,
);
typedef void (*schedule_destroy_queue_fn_t)(uint32_t queue_index);
typedef int (*schedule_sched_queue_fn_t)(uint32_t queue_index);
+typedef int (*schedule_unsched_queue_fn_t)(uint32_t queue_index);
typedef int (*schedule_ord_enq_multi_fn_t)(uint32_t queue_index,
void *buf_hdr[], int num, int *ret);
typedef int (*schedule_init_global_fn_t)(void);
@@ -44,6 +45,7 @@ typedef struct schedule_fn_t {
schedule_init_queue_fn_t init_queue;
schedule_destroy_queue_fn_t destroy_queue;
schedule_sched_queue_fn_t sched_queue;
+ schedule_unsched_queue_fn_t unsched_queue;
schedule_ord_enq_multi_fn_t ord_enq_multi;
schedule_init_global_fn_t init_global;
schedule_term_global_fn_t term_global;
diff --git a/platform/linux-generic/odp_queue.c b/platform/linux-generic/odp_queue.c
index 5efdbde..fcf4bf5 100644
--- a/platform/linux-generic/odp_queue.c
+++ b/platform/linux-generic/odp_queue.c
@@ -522,8 +522,10 @@ static inline int deq_multi(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr[],
if (hdr == NULL) {
/* Already empty queue */
- if (queue->s.status == QUEUE_STATUS_SCHED)
+ if (queue->s.status == QUEUE_STATUS_SCHED) {
queue->s.status = QUEUE_STATUS_NOTSCHED;
+ sched_fn->unsched_queue(queue->s.index);
+ }
UNLOCK(&queue->s.lock);
return 0;
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index c878d8b..cd5bf21 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -1200,6 +1200,11 @@ static int schedule_sched_queue(uint32_t queue_index)
return 0;
}
+static int schedule_unsched_queue(uint32_t queue_index ODP_UNUSED)
+{
+ return 0;
+}
+
static int schedule_num_grps(void)
{
return NUM_SCHED_GRPS;
@@ -1218,6 +1223,7 @@ const schedule_fn_t schedule_default_fn = {
.init_queue = schedule_init_queue,
.destroy_queue = schedule_destroy_queue,
.sched_queue = schedule_sched_queue,
+ .unsched_queue = schedule_unsched_queue,
.ord_enq_multi = schedule_ord_enq_multi,
.init_global = schedule_init_global,
.term_global = schedule_term_global,
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index 2c1adf6..0fd4d87 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -409,6 +409,11 @@ static int sched_queue(uint32_t qi)
return 0;
}
+static int unsched_queue(uint32_t qi ODP_UNUSED)
+{
+ return 0;
+}
+
static int ord_enq_multi(uint32_t queue_index, void *buf_hdr[], int num,
int *ret)
{
@@ -835,6 +840,7 @@ const schedule_fn_t schedule_sp_fn = {
.init_queue = init_queue,
.destroy_queue = destroy_queue,
.sched_queue = sched_queue,
+ .unsched_queue = unsched_queue,
.ord_enq_multi = ord_enq_multi,
.init_global = init_global,
.term_global = term_global,
commit 31498a7a8bd19de593f6b862cb39d484b99c9bf8
Author: Yi He <yi.he(a)linaro.org>
Date: Wed Jan 11 07:50:30 2017 +0000
linux-gen: sched: solve ordered context inversion
For ordered queue, a thread consumes events (dequeue) and
acquires its unique sequential context in two steps, non
atomic and preemptable.
This leads to potential ordered context inversion in case
the thread consumes prior events acquired subsequent context,
while the thread consumes subsequent events but acquired
prior context.
This patch insert the ordered context acquisition into
event dequeue operation to make these two steps atomic.
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 6c2b050..c0aee42 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -12,6 +12,7 @@ extern "C" {
#endif
#include <odp/api/queue.h>
+#include <odp_queue_internal.h>
#include <odp/api/schedule.h>
typedef void (*schedule_pktio_start_fn_t)(int pktio_index, int num_in_queue,
@@ -33,6 +34,7 @@ typedef int (*schedule_term_local_fn_t)(void);
typedef void (*schedule_order_lock_fn_t)(void);
typedef void (*schedule_order_unlock_fn_t)(void);
typedef unsigned (*schedule_max_ordered_locks_fn_t)(void);
+typedef void (*schedule_save_context_fn_t)(queue_entry_t *queue);
typedef struct schedule_fn_t {
schedule_pktio_start_fn_t pktio_start;
@@ -50,6 +52,7 @@ typedef struct schedule_fn_t {
schedule_order_lock_fn_t order_lock;
schedule_order_unlock_fn_t order_unlock;
schedule_max_ordered_locks_fn_t max_ordered_locks;
+ schedule_save_context_fn_t save_context;
} schedule_fn_t;
/* Interface towards the scheduler */
diff --git a/platform/linux-generic/odp_queue.c b/platform/linux-generic/odp_queue.c
index 3975405..5efdbde 100644
--- a/platform/linux-generic/odp_queue.c
+++ b/platform/linux-generic/odp_queue.c
@@ -565,6 +565,9 @@ static inline int deq_multi(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr[],
if (hdr == NULL)
queue->s.tail = NULL;
+ if (queue->s.type == ODP_QUEUE_TYPE_SCHED)
+ sched_fn->save_context(queue);
+
UNLOCK(&queue->s.lock);
return i;
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index e14d145..c878d8b 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -1205,6 +1205,10 @@ static int schedule_num_grps(void)
return NUM_SCHED_GRPS;
}
+static void schedule_save_context(queue_entry_t *queue ODP_UNUSED)
+{
+}
+
/* Fill in scheduler interface */
const schedule_fn_t schedule_default_fn = {
.pktio_start = schedule_pktio_start,
@@ -1221,7 +1225,8 @@ const schedule_fn_t schedule_default_fn = {
.term_local = schedule_term_local,
.order_lock = order_lock,
.order_unlock = order_unlock,
- .max_ordered_locks = schedule_max_ordered_locks
+ .max_ordered_locks = schedule_max_ordered_locks,
+ .save_context = schedule_save_context
};
/* Fill in scheduler API calls */
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index bdfb6af..2c1adf6 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -822,6 +822,10 @@ static void order_unlock(void)
{
}
+static void save_context(queue_entry_t *queue ODP_UNUSED)
+{
+}
+
/* Fill in scheduler interface */
const schedule_fn_t schedule_sp_fn = {
.pktio_start = pktio_start,
@@ -838,7 +842,8 @@ const schedule_fn_t schedule_sp_fn = {
.term_local = term_local,
.order_lock = order_lock,
.order_unlock = order_unlock,
- .max_ordered_locks = max_ordered_locks
+ .max_ordered_locks = max_ordered_locks,
+ .save_context = save_context
};
/* Fill in scheduler API calls */
-----------------------------------------------------------------------
Summary of changes:
doc/users-guide/users-guide-packet.adoc | 239 ++-
doc/users-guide/users-guide.adoc | 120 ++
include/odp/api/spec/byteorder.h | 4 -
platform/linux-generic/Makefile.am | 3 +
.../include/odp/api/plat/byteorder_types.h | 3 -
.../linux-generic/include/odp_bitmap_internal.h | 317 ++++
platform/linux-generic/include/odp_schedule_if.h | 5 +
platform/linux-generic/m4/odp_schedule.m4 | 9 +-
platform/linux-generic/odp_bitmap.c | 315 ++++
platform/linux-generic/odp_queue.c | 7 +-
platform/linux-generic/odp_schedule.c | 13 +-
platform/linux-generic/odp_schedule_if.c | 6 +
platform/linux-generic/odp_schedule_iquery.c | 1521 ++++++++++++++++++++
platform/linux-generic/odp_schedule_sp.c | 13 +-
14 files changed, 2563 insertions(+), 12 deletions(-)
create mode 100644 platform/linux-generic/include/odp_bitmap_internal.h
create mode 100644 platform/linux-generic/odp_bitmap.c
create mode 100644 platform/linux-generic/odp_schedule_iquery.c
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch next updated. v1.13.0.0-73-g53d71e1
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, next has been updated
via 53d71e1a9e543e8da738fbf4b9d028e750939147 (commit)
via 348ba720aa596ad2179de50f8be1486c0b2f2103 (commit)
via f4d24e9b3c8fd6fa5f2724e652b45d13ddae1378 (commit)
via 4b6d85a80fb0a190cde95944e2cf62886447df93 (commit)
via f1502d11a771cf53a9e9ba189c949305cc3ba94e (commit)
via 5cd91a6e3bf76edc0045bc379dd18fa75f65ccd2 (commit)
from 63a39fabe4924d142d2df041d817f732eb4fdafb (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 53d71e1a9e543e8da738fbf4b9d028e750939147
Author: Yi He <yi.he(a)linaro.org>
Date: Fri Dec 23 02:32:09 2016 +0000
linux-gen: sched: fix SP scheduler hang in process mode
SP scheduler hangs in process mode performance test
due to global data structure were not created in shared
memory region.
Signed-off-by: Yi He <yi.he(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index ad01bfe..bdfb6af 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -9,6 +9,7 @@
#include <odp/api/thread.h>
#include <odp/api/time.h>
#include <odp/api/schedule.h>
+#include <odp/api/shared_memory.h>
#include <odp_schedule_if.h>
#include <odp_debug_internal.h>
#include <odp_align_internal.h>
@@ -107,6 +108,7 @@ typedef struct {
sched_cmd_t pktio_cmd[NUM_PKTIO];
prio_queue_t prio_queue[NUM_GROUP][NUM_PRIO];
sched_group_t sched_group;
+ odp_shm_t shm;
} sched_global_t;
typedef struct {
@@ -118,7 +120,7 @@ typedef struct {
int group[NUM_GROUP];
} sched_local_t;
-static sched_global_t sched_global;
+static sched_global_t *sched_global;
static __thread sched_local_t sched_local;
static inline uint32_t index_to_ring_idx(int pktio, uint32_t index)
@@ -144,30 +146,44 @@ static inline uint32_t index_from_ring_idx(uint32_t *index, uint32_t ring_idx)
static int init_global(void)
{
int i, j;
- sched_group_t *sched_group = &sched_global.sched_group;
+ odp_shm_t shm;
+ sched_group_t *sched_group = NULL;
ODP_DBG("Using SP scheduler\n");
- memset(&sched_global, 0, sizeof(sched_global_t));
+ shm = odp_shm_reserve("sp_scheduler",
+ sizeof(sched_global_t),
+ ODP_CACHE_LINE_SIZE, 0);
+
+ sched_global = odp_shm_addr(shm);
+
+ if (sched_global == NULL) {
+ ODP_ERR("Schedule init: Shm reserve failed.\n");
+ return -1;
+ }
+
+ memset(sched_global, 0, sizeof(sched_global_t));
+ sched_global->shm = shm;
for (i = 0; i < NUM_QUEUE; i++) {
- sched_global.queue_cmd[i].s.type = CMD_QUEUE;
- sched_global.queue_cmd[i].s.index = i;
- sched_global.queue_cmd[i].s.ring_idx = index_to_ring_idx(0, i);
+ sched_global->queue_cmd[i].s.type = CMD_QUEUE;
+ sched_global->queue_cmd[i].s.index = i;
+ sched_global->queue_cmd[i].s.ring_idx = index_to_ring_idx(0, i);
}
for (i = 0; i < NUM_PKTIO; i++) {
- sched_global.pktio_cmd[i].s.type = CMD_PKTIO;
- sched_global.pktio_cmd[i].s.index = i;
- sched_global.pktio_cmd[i].s.ring_idx = index_to_ring_idx(1, i);
- sched_global.pktio_cmd[i].s.prio = PKTIN_PRIO;
- sched_global.pktio_cmd[i].s.group = GROUP_PKTIN;
+ sched_global->pktio_cmd[i].s.type = CMD_PKTIO;
+ sched_global->pktio_cmd[i].s.index = i;
+ sched_global->pktio_cmd[i].s.ring_idx = index_to_ring_idx(1, i);
+ sched_global->pktio_cmd[i].s.prio = PKTIN_PRIO;
+ sched_global->pktio_cmd[i].s.group = GROUP_PKTIN;
}
for (i = 0; i < NUM_GROUP; i++)
for (j = 0; j < NUM_PRIO; j++)
- ring_init(&sched_global.prio_queue[i][j].ring);
+ ring_init(&sched_global->prio_queue[i][j].ring);
+ sched_group = &sched_global->sched_group;
odp_ticketlock_init(&sched_group->s.lock);
for (i = 0; i < NUM_THREAD; i++)
@@ -201,16 +217,22 @@ static int init_local(void)
static int term_global(void)
{
- int qi;
+ int qi, ret = 0;
for (qi = 0; qi < NUM_QUEUE; qi++) {
- if (sched_global.queue_cmd[qi].s.init) {
+ if (sched_global->queue_cmd[qi].s.init) {
/* todo: dequeue until empty ? */
sched_cb_queue_destroy_finalize(qi);
}
}
- return 0;
+ ret = odp_shm_free(sched_global->shm);
+ if (ret < 0) {
+ ODP_ERR("Shm free failed for sp_scheduler");
+ ret = -1;
+ }
+
+ return ret;
}
static int term_local(void)
@@ -266,7 +288,7 @@ static void remove_group(sched_group_t *sched_group, int thr, int group)
static int thr_add(odp_schedule_group_t group, int thr)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < 0 || group >= NUM_GROUP)
return -1;
@@ -291,7 +313,7 @@ static int thr_add(odp_schedule_group_t group, int thr)
static int thr_rem(odp_schedule_group_t group, int thr)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < 0 || group >= NUM_GROUP)
return -1;
@@ -319,7 +341,7 @@ static int num_grps(void)
static int init_queue(uint32_t qi, const odp_schedule_param_t *sched_param)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
odp_schedule_group_t group = sched_param->group;
int prio = 0;
@@ -332,18 +354,18 @@ static int init_queue(uint32_t qi, const odp_schedule_param_t *sched_param)
if (sched_param->prio > 0)
prio = LOWEST_QUEUE_PRIO;
- sched_global.queue_cmd[qi].s.prio = prio;
- sched_global.queue_cmd[qi].s.group = group;
- sched_global.queue_cmd[qi].s.init = 1;
+ sched_global->queue_cmd[qi].s.prio = prio;
+ sched_global->queue_cmd[qi].s.group = group;
+ sched_global->queue_cmd[qi].s.init = 1;
return 0;
}
static void destroy_queue(uint32_t qi)
{
- sched_global.queue_cmd[qi].s.prio = 0;
- sched_global.queue_cmd[qi].s.group = 0;
- sched_global.queue_cmd[qi].s.init = 0;
+ sched_global->queue_cmd[qi].s.prio = 0;
+ sched_global->queue_cmd[qi].s.group = 0;
+ sched_global->queue_cmd[qi].s.init = 0;
}
static inline void add_tail(sched_cmd_t *cmd)
@@ -353,8 +375,7 @@ static inline void add_tail(sched_cmd_t *cmd)
int prio = cmd->s.prio;
uint32_t idx = cmd->s.ring_idx;
- prio_queue = &sched_global.prio_queue[group][prio];
-
+ prio_queue = &sched_global->prio_queue[group][prio];
ring_enq(&prio_queue->ring, RING_MASK, idx);
}
@@ -364,8 +385,7 @@ static inline sched_cmd_t *rem_head(int group, int prio)
uint32_t ring_idx, index;
int pktio;
- prio_queue = &sched_global.prio_queue[group][prio];
-
+ prio_queue = &sched_global->prio_queue[group][prio];
ring_idx = ring_deq(&prio_queue->ring, RING_MASK);
if (ring_idx == RING_EMPTY)
@@ -374,16 +394,16 @@ static inline sched_cmd_t *rem_head(int group, int prio)
pktio = index_from_ring_idx(&index, ring_idx);
if (pktio)
- return &sched_global.pktio_cmd[index];
+ return &sched_global->pktio_cmd[index];
- return &sched_global.queue_cmd[index];
+ return &sched_global->queue_cmd[index];
}
static int sched_queue(uint32_t qi)
{
sched_cmd_t *cmd;
- cmd = &sched_global.queue_cmd[qi];
+ cmd = &sched_global->queue_cmd[qi];
add_tail(cmd);
return 0;
@@ -409,7 +429,7 @@ static void pktio_start(int pktio_index, int num, int pktin_idx[])
ODP_DBG("pktio index: %i, %i pktin queues %i\n",
pktio_index, num, pktin_idx[0]);
- cmd = &sched_global.pktio_cmd[pktio_index];
+ cmd = &sched_global->pktio_cmd[pktio_index];
if (num > NUM_PKTIN)
ODP_ABORT("Supports only %i pktin queues per interface\n",
@@ -427,7 +447,7 @@ static inline sched_cmd_t *sched_cmd(void)
{
int prio, i;
int thr = sched_local.thr_id;
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
thr_group_t *thr_group = &sched_group->s.thr[thr];
uint32_t gen_cnt;
@@ -601,7 +621,7 @@ static odp_schedule_group_t schedule_group_create(const char *name,
const odp_thrmask_t *thrmask)
{
odp_schedule_group_t group = ODP_SCHED_GROUP_INVALID;
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
int i;
odp_ticketlock_lock(&sched_group->s.lock);
@@ -632,7 +652,7 @@ static odp_schedule_group_t schedule_group_create(const char *name,
static int schedule_group_destroy(odp_schedule_group_t group)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < NUM_STATIC_GROUP || group >= NUM_GROUP)
return -1;
@@ -655,7 +675,7 @@ static int schedule_group_destroy(odp_schedule_group_t group)
static odp_schedule_group_t schedule_group_lookup(const char *name)
{
odp_schedule_group_t group = ODP_SCHED_GROUP_INVALID;
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
int i;
odp_ticketlock_lock(&sched_group->s.lock);
@@ -676,7 +696,7 @@ static int schedule_group_join(odp_schedule_group_t group,
const odp_thrmask_t *thrmask)
{
int thr;
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < 0 || group >= NUM_GROUP)
return -1;
@@ -708,7 +728,7 @@ static int schedule_group_leave(odp_schedule_group_t group,
const odp_thrmask_t *thrmask)
{
int thr;
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
odp_thrmask_t *all = &sched_group->s.group[GROUP_ALL].mask;
odp_thrmask_t not;
@@ -742,7 +762,7 @@ static int schedule_group_leave(odp_schedule_group_t group,
static int schedule_group_thrmask(odp_schedule_group_t group,
odp_thrmask_t *thrmask)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < 0 || group >= NUM_GROUP)
return -1;
@@ -764,7 +784,7 @@ static int schedule_group_thrmask(odp_schedule_group_t group,
static int schedule_group_info(odp_schedule_group_t group,
odp_schedule_group_info_t *info)
{
- sched_group_t *sched_group = &sched_global.sched_group;
+ sched_group_t *sched_group = &sched_global->sched_group;
if (group < 0 || group >= NUM_GROUP)
return -1;
commit 348ba720aa596ad2179de50f8be1486c0b2f2103
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:30 2017 +0200
linux-gen: packet: implement references as copy
Implement packet references API as packet copy. This is the
simplest way to support the API, as other packet functions
are not affected at all.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 024f694..1d2b506 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -2221,3 +2221,81 @@ uint64_t odp_packet_seg_to_u64(odp_packet_seg_t hdl)
{
return _odp_pri(hdl);
}
+
+odp_packet_t odp_packet_ref_static(odp_packet_t pkt)
+{
+ odp_packet_t new;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ return new;
+}
+
+odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset)
+{
+ odp_packet_t new;
+ int ret;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ if (new == ODP_PACKET_INVALID) {
+ ODP_ERR("copy failed\n");
+ return ODP_PACKET_INVALID;
+ }
+
+ ret = odp_packet_trunc_head(&new, offset, NULL, NULL);
+
+ if (ret < 0) {
+ ODP_ERR("trunk_head failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+
+ return new;
+}
+
+odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
+ odp_packet_t hdr)
+{
+ odp_packet_t new;
+ int ret;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ if (new == ODP_PACKET_INVALID) {
+ ODP_ERR("copy failed\n");
+ return ODP_PACKET_INVALID;
+ }
+
+ if (offset) {
+ ret = odp_packet_trunc_head(&new, offset, NULL, NULL);
+
+ if (ret < 0) {
+ ODP_ERR("trunk_head failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+ }
+
+ ret = odp_packet_concat(&hdr, new);
+
+ if (ret < 0) {
+ ODP_ERR("concat failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+
+ return hdr;
+}
+
+int odp_packet_has_ref(odp_packet_t pkt)
+{
+ (void)pkt;
+
+ return 0;
+}
+
+uint32_t odp_packet_unshared_len(odp_packet_t pkt)
+{
+ return odp_packet_len(pkt);
+}
commit f4d24e9b3c8fd6fa5f2724e652b45d13ddae1378
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:28 2017 +0200
validation: packet: remove non compatible tests
Tests for bad inputs are not compatible to the spec.
Out-of-range values cause undefined results and must not
be tested in validation suite.
Remove reference checks that do not comply anymore to
the new odp_packet_has_ref() specification.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/common_plat/validation/api/packet/packet.c b/test/common_plat/validation/api/packet/packet.c
index f64c599..900c426 100644
--- a/test/common_plat/validation/api/packet/packet.c
+++ b/test/common_plat/validation/api/packet/packet.c
@@ -1877,46 +1877,70 @@ void packet_test_extend_ref(void)
/* Verify ref lengths */
CU_ASSERT(ref != ODP_PACKET_INVALID);
CU_ASSERT(odp_packet_len(ref) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+ if (odp_packet_has_ref(ref) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
- /* And ref's affect on max_pkt */
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 100);
+ /* And ref's affect on max_pkt */
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 100);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(ref) == odp_packet_len(ref));
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) ==
+ odp_packet_len(max_pkt));
+ }
/* Now extend max_pkt and verify effect */
CU_ASSERT(odp_packet_extend_head(&max_pkt, 10, NULL, NULL) >= 0);
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ }
/* Extend on max_pkt should not affect ref */
- CU_ASSERT(odp_packet_has_ref(ref) == 1);
CU_ASSERT(odp_packet_len(ref) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+ }
/* Now extend ref and verify effect*/
CU_ASSERT(odp_packet_extend_head(&ref, 20, NULL, NULL) >= 0);
CU_ASSERT(odp_packet_len(ref) == max_len - 180);
- CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+ }
/* Extend on ref should not affect max_pkt */
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ }
/* Trunc max_pkt of all unshared len */
- CU_ASSERT(odp_packet_trunc_head(&max_pkt,
- odp_packet_unshared_len(max_pkt),
- NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_trunc_head(&max_pkt, 110, NULL, NULL) >= 0);
/* Verify effect on max_pkt */
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 0);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 0);
+ }
/* Verify that ref is unchanged */
CU_ASSERT(odp_packet_len(ref) == max_len - 180);
- CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+ }
/* Free ref and verify that max_pkt is back to being unreferenced */
odp_packet_free(ref);
@@ -2089,37 +2113,42 @@ void packet_test_ref(void)
odp_packet_unshared_len(hdr_pkt[i]));
}
- /* Attempt an invalid ref */
- refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, pkt_len, hdr_pkt[0]);
- CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
-
- /* We can't ref to ourselves */
- refhdr_pkt[0] = odp_packet_ref_pkt(hdr_pkt[0], 0, hdr_pkt[0]);
- CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
-
- /* Now create a couple of valid refs */
+ /* Create a couple of refs */
refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, offset[0], hdr_pkt[0]);
refhdr_pkt[1] = odp_packet_ref_pkt(base_pkt, offset[1], hdr_pkt[1]);
CU_ASSERT(refhdr_pkt[0] != ODP_PACKET_INVALID);
CU_ASSERT(refhdr_pkt[1] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[1]) == 1);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+ /* If base packet has now references, ref packet should be also
+ * references. */
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[1]) == 1);
- /* Verify ref lengths and contents */
- CU_ASSERT(odp_packet_unshared_len(base_pkt) == 0);
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == 0);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == pkt_len);
+ }
CU_ASSERT(odp_packet_len(refhdr_pkt[0]) ==
hdr_len[0] + pkt_len - offset[0]);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
CU_ASSERT(odp_packet_len(refhdr_pkt[1]) ==
hdr_len[1] + pkt_len - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) == hdr_len[1]);
+
+ if (odp_packet_has_ref(refhdr_pkt[0]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) ==
+ odp_packet_len(refhdr_pkt[0]));
+ }
+
+ if (odp_packet_has_ref(refhdr_pkt[1]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) == hdr_len[1]);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) ==
+ odp_packet_len(refhdr_pkt[1]));
+ }
packet_compare_offset(refhdr_pkt[0], hdr_len[0],
base_pkt, offset[0],
@@ -2137,23 +2166,16 @@ void packet_test_ref(void)
refhdr_pkt[2] = odp_packet_ref_pkt(refhdr_pkt[0], 2, hdr_cpy);
CU_ASSERT(refhdr_pkt[2] != ODP_PACKET_INVALID);
- if (refhdr_pkt[2] != ODP_PACKET_INVALID) {
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ if (odp_packet_has_ref(refhdr_pkt[2]) == 1) {
CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[2]) == hdr_len[2]);
CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == 2);
-
- /* Free the compound ref and verify we're back to simple ref */
- odp_packet_free(refhdr_pkt[2]);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
}
/* Delete the refs */
odp_packet_free(refhdr_pkt[0]);
odp_packet_free(refhdr_pkt[1]);
+ odp_packet_free(refhdr_pkt[2]);
/* Verify that base_pkt no longer has a ref */
CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
@@ -2164,9 +2186,11 @@ void packet_test_ref(void)
CU_ASSERT(hdr_pkt[2] != ODP_PACKET_INVALID);
CU_ASSERT(hdr_pkt[3] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[3]) == 1);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[3]) == 1);
+ }
CU_ASSERT(odp_packet_len(refhdr_pkt[2]) ==
odp_packet_len(refhdr_pkt[3]));
@@ -2185,7 +2209,12 @@ void packet_test_ref(void)
/* Create a static reference */
ref_pkt[0] = odp_packet_ref_static(base_pkt);
CU_ASSERT(ref_pkt[0] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
+ }
+
CU_ASSERT(odp_packet_len(ref_pkt[0]) == odp_packet_len(base_pkt));
packet_compare_offset(ref_pkt[0], 0, base_pkt, 0,
odp_packet_len(base_pkt));
@@ -2194,33 +2223,38 @@ void packet_test_ref(void)
odp_packet_free(ref_pkt[0]);
CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
- /* Create an invalid basic reference */
- ref_pkt[0] = odp_packet_ref(segmented_base_pkt, segmented_pkt_len);
- CU_ASSERT(ref_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 0);
-
- /* Now create valid references */
+ /* Create references */
ref_pkt[0] = odp_packet_ref(segmented_base_pkt, offset[0]);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ }
ref_pkt[1] = odp_packet_ref(segmented_base_pkt, offset[1]);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ }
/* Verify reference lengths */
CU_ASSERT(odp_packet_len(ref_pkt[0]) == segmented_pkt_len - offset[0]);
CU_ASSERT(odp_packet_len(ref_pkt[1]) == segmented_pkt_len - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
/* Free the base pkts -- references should still be valid */
odp_packet_free(base_pkt);
odp_packet_free(segmented_base_pkt);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
-
packet_compare_offset(ref_pkt[0], 0,
segmented_test_packet, offset[0],
segmented_pkt_len - offset[0]);
@@ -2233,20 +2267,35 @@ void packet_test_ref(void)
hr[1] = odp_packet_headroom(ref_pkt[1]);
CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ }
+
CU_ASSERT(odp_packet_len(ref_pkt[0]) ==
hr[0] + segmented_pkt_len - offset[0]);
CU_ASSERT(odp_packet_pull_head(ref_pkt[0], hr[0] / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0] - (hr[0] / 2));
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) ==
+ hr[0] - (hr[0] / 2));
+ }
if (hr[1] > 0) {
CU_ASSERT(odp_packet_push_head(ref_pkt[1], 1) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 1);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 1);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
1 + segmented_pkt_len - offset[1]);
CU_ASSERT(odp_packet_pull_head(ref_pkt[1], 1) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
segmented_pkt_len - offset[1]);
}
@@ -2261,36 +2310,68 @@ void packet_test_ref(void)
CU_ASSERT_FATAL(ref_pkt[1] != ODP_PACKET_INVALID);
ref_len[1] = odp_packet_len(ref_pkt[1]);
CU_ASSERT(ref_len[1] == odp_packet_len(base_pkt) - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
CU_ASSERT(odp_packet_push_head(base_pkt, base_hr / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) == base_hr / 2 + offset[1]);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr / 2 + offset[1]);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
ref_pkt[0] = odp_packet_ref(base_pkt, offset[0]);
CU_ASSERT_FATAL(ref_pkt[0] != ODP_PACKET_INVALID);
ref_len[0] = odp_packet_len(ref_pkt[0]);
CU_ASSERT(ref_len[0] = odp_packet_len(base_pkt) - offset[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
CU_ASSERT(odp_packet_push_head(base_pkt,
base_hr - base_hr / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
- base_hr - base_hr / 2 + offset[0]);
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
CU_ASSERT(odp_packet_len(ref_pkt[0]) == ref_len[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
hr[0] = odp_packet_headroom(ref_pkt[0]);
hr[1] = odp_packet_headroom(ref_pkt[1]);
CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
CU_ASSERT(odp_packet_push_head(ref_pkt[1], hr[1]) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == hr[1]);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
- base_hr - base_hr / 2 + offset[0]);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ }
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == hr[1]);
+ }
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+ }
odp_packet_free(base_pkt);
odp_packet_free(ref_pkt[0]);
commit 4b6d85a80fb0a190cde95944e2cf62886447df93
Author: Bill Fischofer <bill.fischofer(a)linaro.org>
Date: Tue Jan 10 20:33:57 2017 -0600
validation: packet: add packet reference tests
Add validation tests for the new packet reference APIs:
- odp_packet_ref_static()
- odp_packet_ref()
- odp_packet_ref_pkt()
- odp_packet_has_ref()
- odp_packet_unshared_len()
Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Reviewed-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/common_plat/validation/api/packet/packet.c b/test/common_plat/validation/api/packet/packet.c
index e3d28f6..f64c599 100644
--- a/test/common_plat/validation/api/packet/packet.c
+++ b/test/common_plat/validation/api/packet/packet.c
@@ -245,6 +245,7 @@ void packet_test_alloc_free(void)
params.pkt.num = 1;
pool = odp_pool_create("packet_pool_alloc", ¶ms);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
/* Allocate the only buffer from the pool */
packet = odp_packet_alloc(pool, packet_len);
@@ -1447,7 +1448,7 @@ void packet_test_concat_extend_trunc(void)
param.pkt.num = 100;
pool = odp_pool_create("packet_pool_concat", ¶m);
- CU_ASSERT(packet_pool != ODP_POOL_INVALID);
+ CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, alloc_len);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
@@ -1466,6 +1467,7 @@ void packet_test_concat_extend_trunc(void)
CU_ASSERT(odp_packet_len(pkt) == (cur_len + alloc_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
}
ret = odp_packet_extend_tail(&pkt, ext_len, NULL, NULL);
@@ -1473,12 +1475,14 @@ void packet_test_concat_extend_trunc(void)
CU_ASSERT(odp_packet_len(pkt) == (cur_len + ext_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
ret = odp_packet_extend_head(&pkt, ext_len, NULL, NULL);
CU_ASSERT(ret >= 0);
CU_ASSERT(odp_packet_len(pkt) == (cur_len + ext_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
pkt2 = odp_packet_alloc(pool, alloc_len);
CU_ASSERT_FATAL(pkt2 != ODP_PACKET_INVALID);
@@ -1491,18 +1495,21 @@ void packet_test_concat_extend_trunc(void)
CU_ASSERT(odp_packet_len(pkt) == (cur_len + alloc_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
ret = odp_packet_trunc_head(&pkt, trunc_len, NULL, NULL);
CU_ASSERT(ret >= 0);
CU_ASSERT(odp_packet_len(pkt) == (cur_len - trunc_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
ret = odp_packet_trunc_tail(&pkt, trunc_len, NULL, NULL);
CU_ASSERT(ret >= 0);
CU_ASSERT(odp_packet_len(pkt) == (cur_len - trunc_len));
cur_len = odp_packet_len(pkt);
+ CU_ASSERT(cur_len == odp_packet_unshared_len(pkt));
odp_packet_free(pkt);
@@ -1534,7 +1541,7 @@ void packet_test_extend_small(void)
param.pkt.num = 100;
pool = odp_pool_create("packet_pool_extend", ¶m);
- CU_ASSERT(packet_pool != ODP_POOL_INVALID);
+ CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID);
for (round = 0; round < 2; round++) {
pkt = odp_packet_alloc(pool, 1);
@@ -1570,6 +1577,7 @@ void packet_test_extend_small(void)
}
CU_ASSERT(odp_packet_len(pkt) == len);
+ CU_ASSERT(odp_packet_unshared_len(pkt) == len);
len = odp_packet_len(pkt);
@@ -1628,7 +1636,7 @@ void packet_test_extend_large(void)
param.pkt.num = 100;
pool = odp_pool_create("packet_pool_extend", ¶m);
- CU_ASSERT(packet_pool != ODP_POOL_INVALID);
+ CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID);
for (round = 0; round < 2 * num_div; round++) {
ext_len = len / div;
@@ -1747,7 +1755,7 @@ void packet_test_extend_mix(void)
param.pkt.num = 100;
pool = odp_pool_create("packet_pool_extend", ¶m);
- CU_ASSERT(packet_pool != ODP_POOL_INVALID);
+ CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID);
for (round = 0; round < 2; round++) {
small_count = 30;
@@ -1835,6 +1843,90 @@ void packet_test_extend_mix(void)
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
+void packet_test_extend_ref(void)
+{
+ odp_packet_t max_pkt, ref;
+ uint32_t hr, tr, max_len;
+
+ max_pkt = odp_packet_copy(segmented_test_packet,
+ odp_packet_pool(segmented_test_packet));
+ CU_ASSERT_FATAL(max_pkt != ODP_PACKET_INVALID);
+ max_len = odp_packet_len(max_pkt);
+
+ /* Maximize the max pkt */
+ hr = odp_packet_headroom(max_pkt);
+ tr = odp_packet_tailroom(max_pkt);
+ odp_packet_push_head(max_pkt, hr);
+ odp_packet_push_tail(max_pkt, tr);
+
+ /* Max packet should not be extendable at either end */
+ CU_ASSERT(odp_packet_extend_tail(&max_pkt, 1, NULL, NULL) < 0);
+ CU_ASSERT(odp_packet_extend_head(&max_pkt, 1, NULL, NULL) < 0);
+
+ /* See if we can trunc and extend anyway */
+ CU_ASSERT(odp_packet_trunc_tail(&max_pkt, hr + tr + 1,
+ NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_extend_head(&max_pkt, 1, NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_len(max_pkt) == max_len);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == max_len);
+
+ /* Now try with a reference in place */
+ CU_ASSERT(odp_packet_trunc_tail(&max_pkt, 100, NULL, NULL) >= 0);
+ ref = odp_packet_ref(max_pkt, 100);
+
+ /* Verify ref lengths */
+ CU_ASSERT(ref != ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_len(ref) == max_len - 200);
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+
+ /* And ref's affect on max_pkt */
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 100);
+
+ /* Now extend max_pkt and verify effect */
+ CU_ASSERT(odp_packet_extend_head(&max_pkt, 10, NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ /* Extend on max_pkt should not affect ref */
+ CU_ASSERT(odp_packet_has_ref(ref) == 1);
+ CU_ASSERT(odp_packet_len(ref) == max_len - 200);
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+
+ /* Now extend ref and verify effect*/
+ CU_ASSERT(odp_packet_extend_head(&ref, 20, NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_len(ref) == max_len - 180);
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ /* Extend on ref should not affect max_pkt */
+ CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ /* Trunc max_pkt of all unshared len */
+ CU_ASSERT(odp_packet_trunc_head(&max_pkt,
+ odp_packet_unshared_len(max_pkt),
+ NULL, NULL) >= 0);
+
+ /* Verify effect on max_pkt */
+ CU_ASSERT(odp_packet_len(max_pkt) == max_len - 200);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 0);
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ /* Verify that ref is unchanged */
+ CU_ASSERT(odp_packet_len(ref) == max_len - 180);
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ /* Free ref and verify that max_pkt is back to being unreferenced */
+ odp_packet_free(ref);
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 0);
+ CU_ASSERT(odp_packet_len(max_pkt) == max_len - 200);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == max_len - 200);
+
+ odp_packet_free(max_pkt);
+}
+
void packet_test_align(void)
{
odp_packet_t pkt;
@@ -1939,6 +2031,272 @@ void packet_test_offset(void)
CU_ASSERT_PTR_NOT_NULL(ptr);
}
+void packet_test_ref(void)
+{
+ odp_packet_t base_pkt, segmented_base_pkt, hdr_pkt[4],
+ ref_pkt[4], refhdr_pkt[4], hdr_cpy;
+ uint32_t pkt_len, segmented_pkt_len, hdr_len[4], offset[4], hr[4],
+ base_hr, ref_len[4];
+ int i;
+
+ base_pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet));
+ base_hr = odp_packet_headroom(base_pkt);
+ pkt_len = odp_packet_len(test_packet);
+ CU_ASSERT_FATAL(base_pkt != ODP_PACKET_INVALID);
+
+ segmented_base_pkt =
+ odp_packet_copy(segmented_test_packet,
+ odp_packet_pool(segmented_test_packet));
+ segmented_pkt_len = odp_packet_len(segmented_test_packet);
+ CU_ASSERT_FATAL(segmented_base_pkt != ODP_PACKET_INVALID);
+
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
+
+ hdr_pkt[0] =
+ odp_packet_copy_part(segmented_test_packet, 0,
+ odp_packet_len(segmented_test_packet) / 4,
+ odp_packet_pool(segmented_test_packet));
+ CU_ASSERT_FATAL(hdr_pkt[0] != ODP_PACKET_INVALID);
+ hdr_len[0] = odp_packet_len(hdr_pkt[0]);
+ offset[0] = 0;
+
+ hdr_pkt[1] =
+ odp_packet_copy_part(segmented_test_packet, 10,
+ odp_packet_len(segmented_test_packet) / 8,
+ odp_packet_pool(segmented_test_packet));
+ CU_ASSERT_FATAL(hdr_pkt[1] != ODP_PACKET_INVALID);
+ hdr_len[1] = odp_packet_len(hdr_pkt[1]);
+ offset[1] = 5;
+
+ hdr_pkt[2] = odp_packet_copy_part(test_packet, 0,
+ odp_packet_len(test_packet) / 4,
+ odp_packet_pool(test_packet));
+ CU_ASSERT_FATAL(hdr_pkt[2] != ODP_PACKET_INVALID);
+ hdr_len[2] = odp_packet_len(hdr_pkt[2]);
+ offset[2] = 64;
+
+ hdr_pkt[3] = odp_packet_copy_part(test_packet, 0,
+ odp_packet_len(test_packet) / 4,
+ odp_packet_pool(test_packet));
+ CU_ASSERT_FATAL(hdr_pkt[3] != ODP_PACKET_INVALID);
+ hdr_len[3] = odp_packet_len(hdr_pkt[3]);
+ offset[3] = 64;
+
+ /* Nothing is a ref or has a ref before we start */
+ for (i = 0; i < 4; i++) {
+ CU_ASSERT(odp_packet_has_ref(hdr_pkt[i]) == 0);
+ CU_ASSERT(odp_packet_len(hdr_pkt[i]) ==
+ odp_packet_unshared_len(hdr_pkt[i]));
+ }
+
+ /* Attempt an invalid ref */
+ refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, pkt_len, hdr_pkt[0]);
+ CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
+
+ /* We can't ref to ourselves */
+ refhdr_pkt[0] = odp_packet_ref_pkt(hdr_pkt[0], 0, hdr_pkt[0]);
+ CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
+
+ /* Now create a couple of valid refs */
+ refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, offset[0], hdr_pkt[0]);
+ refhdr_pkt[1] = odp_packet_ref_pkt(base_pkt, offset[1], hdr_pkt[1]);
+
+ CU_ASSERT(refhdr_pkt[0] != ODP_PACKET_INVALID);
+ CU_ASSERT(refhdr_pkt[1] != ODP_PACKET_INVALID);
+
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[1]) == 1);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ /* Verify ref lengths and contents */
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == 0);
+
+ CU_ASSERT(odp_packet_len(refhdr_pkt[0]) ==
+ hdr_len[0] + pkt_len - offset[0]);
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
+ CU_ASSERT(odp_packet_len(refhdr_pkt[1]) ==
+ hdr_len[1] + pkt_len - offset[1]);
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) == hdr_len[1]);
+
+ packet_compare_offset(refhdr_pkt[0], hdr_len[0],
+ base_pkt, offset[0],
+ pkt_len - offset[0]);
+
+ packet_compare_offset(refhdr_pkt[1], hdr_len[1],
+ base_pkt, offset[1],
+ pkt_len - offset[1]);
+
+ /* See if compound references are supported and if so that they
+ * operate properly */
+ hdr_cpy = odp_packet_copy(hdr_pkt[2], odp_packet_pool(hdr_pkt[2]));
+ CU_ASSERT_FATAL(hdr_cpy != ODP_PACKET_INVALID);
+
+ refhdr_pkt[2] = odp_packet_ref_pkt(refhdr_pkt[0], 2, hdr_cpy);
+ CU_ASSERT(refhdr_pkt[2] != ODP_PACKET_INVALID);
+
+ if (refhdr_pkt[2] != ODP_PACKET_INVALID) {
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[2]) == hdr_len[2]);
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == 2);
+
+ /* Free the compound ref and verify we're back to simple ref */
+ odp_packet_free(refhdr_pkt[2]);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
+ }
+
+ /* Delete the refs */
+ odp_packet_free(refhdr_pkt[0]);
+ odp_packet_free(refhdr_pkt[1]);
+
+ /* Verify that base_pkt no longer has a ref */
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
+
+ /* Now create a two more shared refs */
+ refhdr_pkt[2] = odp_packet_ref_pkt(base_pkt, offset[2], hdr_pkt[2]);
+ refhdr_pkt[3] = odp_packet_ref_pkt(base_pkt, offset[3], hdr_pkt[3]);
+
+ CU_ASSERT(hdr_pkt[2] != ODP_PACKET_INVALID);
+ CU_ASSERT(hdr_pkt[3] != ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[3]) == 1);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ CU_ASSERT(odp_packet_len(refhdr_pkt[2]) ==
+ odp_packet_len(refhdr_pkt[3]));
+
+ packet_compare_offset(refhdr_pkt[2], 0,
+ refhdr_pkt[3], 0,
+ odp_packet_len(hdr_pkt[2]));
+
+ /* Delete the headers */
+ odp_packet_free(refhdr_pkt[2]);
+ odp_packet_free(refhdr_pkt[3]);
+
+ /* Verify that base_pkt is no longer ref'd */
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
+
+ /* Create a static reference */
+ ref_pkt[0] = odp_packet_ref_static(base_pkt);
+ CU_ASSERT(ref_pkt[0] != ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+ CU_ASSERT(odp_packet_len(ref_pkt[0]) == odp_packet_len(base_pkt));
+ packet_compare_offset(ref_pkt[0], 0, base_pkt, 0,
+ odp_packet_len(base_pkt));
+
+ /* Now delete it */
+ odp_packet_free(ref_pkt[0]);
+ CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
+
+ /* Create an invalid basic reference */
+ ref_pkt[0] = odp_packet_ref(segmented_base_pkt, segmented_pkt_len);
+ CU_ASSERT(ref_pkt[0] == ODP_PACKET_INVALID);
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 0);
+
+ /* Now create valid references */
+ ref_pkt[0] = odp_packet_ref(segmented_base_pkt, offset[0]);
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+
+ ref_pkt[1] = odp_packet_ref(segmented_base_pkt, offset[1]);
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+
+ /* Verify reference lengths */
+ CU_ASSERT(odp_packet_len(ref_pkt[0]) == segmented_pkt_len - offset[0]);
+ CU_ASSERT(odp_packet_len(ref_pkt[1]) == segmented_pkt_len - offset[1]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ /* Free the base pkts -- references should still be valid */
+ odp_packet_free(base_pkt);
+ odp_packet_free(segmented_base_pkt);
+
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
+
+ packet_compare_offset(ref_pkt[0], 0,
+ segmented_test_packet, offset[0],
+ segmented_pkt_len - offset[0]);
+ packet_compare_offset(ref_pkt[1], 0,
+ segmented_test_packet, offset[1],
+ segmented_pkt_len - offset[1]);
+
+ /* Verify we can modify the refs */
+ hr[0] = odp_packet_headroom(ref_pkt[0]);
+ hr[1] = odp_packet_headroom(ref_pkt[1]);
+
+ CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ CU_ASSERT(odp_packet_len(ref_pkt[0]) ==
+ hr[0] + segmented_pkt_len - offset[0]);
+
+ CU_ASSERT(odp_packet_pull_head(ref_pkt[0], hr[0] / 2) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0] - (hr[0] / 2));
+
+ if (hr[1] > 0) {
+ CU_ASSERT(odp_packet_push_head(ref_pkt[1], 1) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 1);
+ CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
+ 1 + segmented_pkt_len - offset[1]);
+ CU_ASSERT(odp_packet_pull_head(ref_pkt[1], 1) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
+ segmented_pkt_len - offset[1]);
+ }
+
+ odp_packet_free(ref_pkt[0]);
+ odp_packet_free(ref_pkt[1]);
+
+ /* Verify we can modify base packet after reference is created */
+ base_pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet));
+
+ ref_pkt[1] = odp_packet_ref(base_pkt, offset[1]);
+ CU_ASSERT_FATAL(ref_pkt[1] != ODP_PACKET_INVALID);
+ ref_len[1] = odp_packet_len(ref_pkt[1]);
+ CU_ASSERT(ref_len[1] == odp_packet_len(base_pkt) - offset[1]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+
+ CU_ASSERT(odp_packet_push_head(base_pkt, base_hr / 2) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == base_hr / 2 + offset[1]);
+ CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+
+ ref_pkt[0] = odp_packet_ref(base_pkt, offset[0]);
+ CU_ASSERT_FATAL(ref_pkt[0] != ODP_PACKET_INVALID);
+ ref_len[0] = odp_packet_len(ref_pkt[0]);
+ CU_ASSERT(ref_len[0] = odp_packet_len(base_pkt) - offset[0]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ CU_ASSERT(odp_packet_push_head(base_pkt,
+ base_hr - base_hr / 2) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+ CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
+ CU_ASSERT(odp_packet_len(ref_pkt[0]) == ref_len[0]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ hr[0] = odp_packet_headroom(ref_pkt[0]);
+ hr[1] = odp_packet_headroom(ref_pkt[1]);
+ CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
+ CU_ASSERT(odp_packet_push_head(ref_pkt[1], hr[1]) != NULL);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == hr[1]);
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+
+ odp_packet_free(base_pkt);
+ odp_packet_free(ref_pkt[0]);
+ odp_packet_free(ref_pkt[1]);
+}
+
odp_testinfo_t packet_suite[] = {
ODP_TEST_INFO(packet_test_alloc_free),
ODP_TEST_INFO(packet_test_alloc_free_multi),
@@ -1965,8 +2323,10 @@ odp_testinfo_t packet_suite[] = {
ODP_TEST_INFO(packet_test_extend_small),
ODP_TEST_INFO(packet_test_extend_large),
ODP_TEST_INFO(packet_test_extend_mix),
+ ODP_TEST_INFO(packet_test_extend_ref),
ODP_TEST_INFO(packet_test_align),
ODP_TEST_INFO(packet_test_offset),
+ ODP_TEST_INFO(packet_test_ref),
ODP_TEST_INFO_NULL,
};
diff --git a/test/common_plat/validation/api/packet/packet.h b/test/common_plat/validation/api/packet/packet.h
index 9bc3d63..783b7a1 100644
--- a/test/common_plat/validation/api/packet/packet.h
+++ b/test/common_plat/validation/api/packet/packet.h
@@ -35,8 +35,10 @@ void packet_test_concat_extend_trunc(void);
void packet_test_extend_small(void);
void packet_test_extend_large(void);
void packet_test_extend_mix(void);
+void packet_test_extend_ref(void);
void packet_test_align(void);
void packet_test_offset(void);
+void packet_test_ref(void);
/* test arrays: */
extern odp_testinfo_t packet_suite[];
commit f1502d11a771cf53a9e9ba189c949305cc3ba94e
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:27 2017 +0200
api: packet: references may be implemented as copy
Some implementations may implement new references as packet copy.
odp_packet_has_ref() will return 0 for copies, since those are
unique packets.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/packet.h b/include/odp/api/spec/packet.h
index b6450c1..05ffd68 100644
--- a/include/odp/api/spec/packet.h
+++ b/include/odp/api/spec/packet.h
@@ -892,9 +892,6 @@ odp_packet_t odp_packet_ref_static(odp_packet_t pkt);
* dynamic references must not be mixed. Results are undefined if these
* restrictions are not observed.
*
- * odp_packet_unshared_len() may be used to determine the number of bytes
- * starting at offset zero that are unique to a packet handle.
- *
* The packet handle 'pkt' may itself by a (dynamic) reference to a packet.
*
* If the caller does not intend to modify either the packet or the new
@@ -952,8 +949,9 @@ odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
* When a packet has multiple references, packet data is divided into two
* parts: unshared and shared. The unshared part always precedes the shared
* part. This call returns number of bytes in the unshared part. When a
- * packet has only a single reference, all packet data is unshared and
- * unshared length equals the packet length (odp_packet_len()).
+ * packet has only a single reference (see odp_packet_has_ref()), all packet
+ * data is unshared and unshared length equals the packet length
+ * (odp_packet_len()).
*
* Application may modify only the unshared part, the rest of the packet data
* must be treated as read only.
@@ -967,8 +965,16 @@ uint32_t odp_packet_unshared_len(odp_packet_t pkt);
/**
* Test if packet has multiple references
*
- * A packet that has multiple references shares data and possibly metadata
- * with other packets. Shared part must be treated as read only.
+ * A packet that has multiple references share data with other packets. In case
+ * of a static reference it also shares metadata. Shared parts must be treated
+ * as read only.
+ *
+ * New references are created with odp_packet_ref_static(), odp_packet_ref() and
+ * odp_packet_ref_pkt() calls. However, some of those calls may implement the
+ * new reference as a packet copy. If a copy is done, the new reference is
+ * actually a new, unique packet and this function returns '0' for it.
+ * When a real reference is created (instead of a copy), this function
+ * returns '1' for both packets (the original packet and the new reference).
*
* @param pkt Packet handle
*
commit 5cd91a6e3bf76edc0045bc379dd18fa75f65ccd2
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Tue Jan 10 20:33:55 2017 -0600
api: packet: add support for packet references
Introduce new APIs that support efficient sharing of portions of
packets:
* odp_packet_ref_static() creates a new static reference
for a packet
* odp_packet_ref() creates a new dynamic reference to a packet
* odp_packet_ref_pkt() creates a reference to a packet with
a supplied header packet
* odp_packet_has_ref() checks if a packet has multiple
references to it
* odp_packet_unshared_len() returns the unshared data length of
a reference
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Reviewed-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/packet.h b/include/odp/api/spec/packet.h
index 4a86eba..b6450c1 100644
--- a/include/odp/api/spec/packet.h
+++ b/include/odp/api/spec/packet.h
@@ -795,7 +795,7 @@ uint32_t odp_packet_seg_data_len(odp_packet_t pkt, odp_packet_seg_t seg);
* data pointers. Otherwise, all old pointers remain valid.
*
* The resulting packet is always allocated from the same pool as
- * the destination packet. The source packet may have been allocate from
+ * the destination packet. The source packet may have been allocated from
* any pool.
*
* On failure, both handles remain valid and packets are not modified.
@@ -848,6 +848,137 @@ int odp_packet_split(odp_packet_t *pkt, uint32_t len, odp_packet_t *tail);
/*
*
+ * References
+ * ********************************************************
+ *
+ */
+
+/**
+ * Create a static reference to a packet
+ *
+ * A static reference is used to obtain an additional handle for referring to
+ * the entire packet as it is. As long as a packet has multiple (static)
+ * references, any of the references (including 'pkt') must not be used to
+ * modify the packet in any way - both data and metadata must remain static.
+ * The packet may be modified again when there is a single reference left.
+ * Static and dynamic references must not be mixed. Results are undefined if
+ * these restrictions are not observed.
+ *
+ * While static references are inflexible they offer efficient way to do,
+ * e.g., packet retransmissions. Use odp_packet_ref() or odp_packet_ref_pkt()
+ * for more flexible, dynamic references.
+ *
+ * Packet is not modified on failure.
+ *
+ * @param pkt Handle of the packet for which a static reference is
+ * to be created.
+ *
+ * @return Static reference to the packet
+ * @retval ODP_PACKET_INVALID On failure
+ */
+odp_packet_t odp_packet_ref_static(odp_packet_t pkt);
+
+/**
+ * Create a reference to a packet
+ *
+ * Returns a new (dynamic) reference to a packet starting the shared part of
+ * the data at a specified byte offset. Metadata and data before the offset
+ * are not shared with other references of the packet. The rest of the data is
+ * shared and must be treated as read only. Initially the returned reference
+ * has metadata initialized to default values and does not contain unshared
+ * data. Packet (head) manipulation functions may be used normally to, e.g.,
+ * add a unique header onto the shared payload. The shared part of the packet
+ * may be modified again when there is a single reference left. Static and
+ * dynamic references must not be mixed. Results are undefined if these
+ * restrictions are not observed.
+ *
+ * odp_packet_unshared_len() may be used to determine the number of bytes
+ * starting at offset zero that are unique to a packet handle.
+ *
+ * The packet handle 'pkt' may itself by a (dynamic) reference to a packet.
+ *
+ * If the caller does not intend to modify either the packet or the new
+ * reference to it, odp_packet_ref_static() may be used to create
+ * a static reference that is more optimized for that use case.
+ *
+ * Packet is not modified on failure.
+ *
+ * @param pkt Handle of the packet for which a reference is to be
+ * created.
+ *
+ * @param offset Byte offset in the packet at which the shared part is to
+ * begin. This must be in the range 0 ... odp_packet_len(pkt)-1.
+ *
+ * @return New reference to the packet
+ * @retval ODP_PACKET_INVALID On failure
+ */
+odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset);
+
+/**
+ * Create a reference to a packet with a header packet
+ *
+ * This operation is otherwise identical to odp_packet_ref(), but it prepends
+ * a supplied 'hdr' packet as the head of the new reference. The resulting
+ * packet consists metadata and data of the 'hdr' packet, followed by the
+ * shared part of packet 'pkt'.
+ *
+ * The packet handle ('pkt') may itself by a (dynamic) reference to a packet,
+ * but the header packet handle ('hdr') must be unique. Both packets must be
+ * have been allocated from the same pool and the handles must not refer to
+ * the same packet. Results are undefined if these restrictions are not
+ * observed.
+ *
+ * Packets are not modified on failure. The header packet 'hdr' is consumed
+ * on success.
+ *
+ * @param pkt Handle of the packet for which a reference is to be
+ * created.
+ *
+ * @param offset Byte offset in 'pkt' at which the shared part is to
+ * begin. Must be in the range 0 ... odp_packet_len(pkt)-1.
+ *
+ * @param hdr Handle of the header packet to be prefixed onto the new
+ * reference. Must be a unique reference.
+ *
+ * @return New reference the reference packet
+ * @retval ODP_PACKET_INVALID On failure
+ */
+odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
+ odp_packet_t hdr);
+
+/**
+ * Packet unshared data length
+ *
+ * When a packet has multiple references, packet data is divided into two
+ * parts: unshared and shared. The unshared part always precedes the shared
+ * part. This call returns number of bytes in the unshared part. When a
+ * packet has only a single reference, all packet data is unshared and
+ * unshared length equals the packet length (odp_packet_len()).
+ *
+ * Application may modify only the unshared part, the rest of the packet data
+ * must be treated as read only.
+ *
+ * @param pkt Packet handle
+ *
+ * @return Packet unshared data length
+ */
+uint32_t odp_packet_unshared_len(odp_packet_t pkt);
+
+/**
+ * Test if packet has multiple references
+ *
+ * A packet that has multiple references shares data and possibly metadata
+ * with other packets. Shared part must be treated as read only.
+ *
+ * @param pkt Packet handle
+ *
+ * @retval 0 This is the single reference to the packet
+ * @retval 1 Packet has multiple references
+ */
+int odp_packet_has_ref(odp_packet_t pkt);
+
+/*
+ *
* Copy
* ********************************************************
*
-----------------------------------------------------------------------
Summary of changes:
include/odp/api/spec/packet.h | 139 +++++++-
platform/linux-generic/odp_packet.c | 78 ++++
platform/linux-generic/odp_schedule_sp.c | 100 +++---
test/common_plat/validation/api/packet/packet.c | 449 +++++++++++++++++++++++-
test/common_plat/validation/api/packet/packet.h | 2 +
5 files changed, 723 insertions(+), 45 deletions(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch next updated. v1.13.0.0-67-g63a39fa
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, next has been updated
via 63a39fabe4924d142d2df041d817f732eb4fdafb (commit)
via 431a0783ebea4fc09e781f431599cacd3a3e4e0e (commit)
via 483cc787d1bec821a2008e32ef4dd611e365ffe4 (commit)
via de21a1cc01d03c39fd0772dff96fb69b06613f58 (commit)
via 3d6cbd2e2881c1e18922b26c7fd4a2ec9464becd (commit)
via 52f32ce1fa6b5416c59ead45ff27d731d98b8f87 (commit)
via 05f8f96ae606eecfff48e3544885d43b9f541f3c (commit)
via e971043e275307634472b35ce394326216c3e301 (commit)
via af5205809e3921ea0c4db5771ea1da5d2f0eaaf5 (commit)
via 32b94edb4961a3ac1a2e5c90f65ee3f118852151 (commit)
via 9420b7953a05f2759524234a26e7e2a774a23769 (commit)
via 622103adf9b6d8e73e86c751469ee2523f4dd952 (commit)
via 981b778400a726121400dd4535f3cc2006d4ac67 (commit)
via 8acb1d0a0c97d6902ad1b9f975facfc9c88f47b5 (commit)
via af2c8ff31853d005aaa13247e3a19e5be7138c97 (commit)
via 3f9e9b3f17627e35843eef7e3846a75298259b69 (commit)
via 6c01f54700e5776d1f1b59517d053f0d9b62a10c (commit)
via 96f3c0362b61a415b9ecc319ee3427c8f4b7c081 (commit)
via 0ed479bd9d474f1d7588f3370fb306a2e000ff4f (commit)
via 483af96a7a14885694496843551ed8fad708192c (commit)
via f59d87a65cf1d08f8715a01dceeaf370a29e51f3 (commit)
via 3528ca70668da492a2f1fe85c167b2024406dd8d (commit)
from 332d48c9c25504b3cbb9451e292a98c15df17ccb (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
-----------------------------------------------------------------------
Summary of changes:
.codecov.yml | 4 +-
.travis.yml | 20 +-
CONTRIBUTING | 6 +-
configure.ac | 19 +-
example/Makefile.inc | 2 +-
helper/Makefile.am | 18 +-
helper/cuckootable.c | 7 +-
helper/hashtable.c | 7 +-
.../threads_extn.h => linux/process.h} | 44 +-
helper/include/odp/helper/linux/pthread.h | 66 +++
helper/include/odp/helper/odph_cuckootable.h | 80 +++-
helper/include/odp/helper/odph_hashtable.h | 75 +++-
helper/include/odp/helper/odph_iplookuptable.h | 97 ++++-
helper/include/odp/helper/odph_lineartable.h | 65 ++-
helper/include/odp/helper/table.h | 10 +-
helper/iplookuptable.c | 13 +-
helper/lineartable.c | 7 +-
helper/{platform/linux-generic => linux}/thread.c | 78 +---
helper/m4/configure.m4 | 8 +-
helper/test/.gitignore | 1 +
helper/test/Makefile.am | 9 +-
helper/test/cuckootable.c | 9 +-
helper/test/linux-generic/Makefile.am | 5 -
helper/test/linux/Makefile.am | 5 +
helper/test/{linux-generic => linux}/process.c | 3 +-
.../{linux-generic/thread.c => linux/pthread.c} | 2 +-
platform/linux-generic/Makefile.am | 10 +
.../include/odp_classification_inlines.h | 81 +++-
test/Makefile.inc | 2 +-
test/common_plat/validation/api/Makefile.inc | 2 +-
.../validation/api/classification/classification.h | 4 +
.../api/classification/odp_classification_common.c | 17 +-
.../classification/odp_classification_test_pmr.c | 453 +++++++++++++++++++++
.../classification/odp_classification_testsuites.h | 4 +-
test/common_plat/validation/api/crypto/crypto.c | 6 +-
.../validation/api/crypto/odp_crypto_test_inp.c | 398 +++++++++++++++---
.../validation/api/crypto/odp_crypto_test_inp.h | 1 +
test/linux-generic/Makefile.inc | 2 +-
38 files changed, 1361 insertions(+), 279 deletions(-)
rename helper/include/odp/helper/{platform/linux-generic/threads_extn.h => linux/process.h} (59%)
create mode 100644 helper/include/odp/helper/linux/pthread.h
rename helper/{platform/linux-generic => linux}/thread.c (70%)
delete mode 100644 helper/test/linux-generic/Makefile.am
create mode 100644 helper/test/linux/Makefile.am
rename helper/test/{linux-generic => linux}/process.c (96%)
rename helper/test/{linux-generic/thread.c => linux/pthread.c} (97%)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch master updated. v1.13.0.0-67-g63a39fa
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 63a39fabe4924d142d2df041d817f732eb4fdafb (commit)
from 431a0783ebea4fc09e781f431599cacd3a3e4e0e (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 63a39fabe4924d142d2df041d817f732eb4fdafb
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Wed Feb 22 00:09:23 2017 +0300
codecov: lower expectations from codecov
On main page for each commit Codecov does tests. This
patch lowers expectations for 'codecov/project' to make
it pass and as the result combined mark check (travis + codecov)
green under commit on main page.
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
diff --git a/.codecov.yml b/.codecov.yml
index 86bcd1d..36270d6 100644
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -7,7 +7,9 @@ coverage:
round: down
range: "50...75"
status:
- project: yes
+ project:
+ target: 70%
+ threshold: 5%
patch: yes
changes: yes
-----------------------------------------------------------------------
Summary of changes:
.codecov.yml | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch api-next updated. v1.13.0.0-307-ga820c28
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, api-next has been updated
via a820c285a87dfa274c6290638983575bb2e63ba4 (commit)
from 44ae9773bc94f8cd349034901f08a2eed46dc822 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit a820c285a87dfa274c6290638983575bb2e63ba4
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Fri Feb 17 13:34:14 2017 +0200
linux-gen: ipsec: add stubs for functions
Added stubs for functions so that applications can be built
already. A proper implementation follows later on.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_ipsec.c b/platform/linux-generic/odp_ipsec.c
index ce7fded..588d8d8 100644
--- a/platform/linux-generic/odp_ipsec.c
+++ b/platform/linux-generic/odp_ipsec.c
@@ -14,3 +14,114 @@ int odp_ipsec_capability(odp_ipsec_capability_t *capa)
return 0;
}
+
+int odp_ipsec_cipher_capability(odp_cipher_alg_t cipher,
+ odp_crypto_cipher_capability_t capa[], int num)
+{
+ (void)cipher;
+ (void)capa;
+ (void)num;
+
+ return -1;
+}
+
+int odp_ipsec_auth_capability(odp_auth_alg_t auth,
+ odp_crypto_auth_capability_t capa[], int num)
+{
+ (void)auth;
+ (void)capa;
+ (void)num;
+
+ return -1;
+}
+
+void odp_ipsec_config_init(odp_ipsec_config_t *config)
+{
+ memset(config, 0, sizeof(odp_ipsec_config_t));
+}
+
+int odp_ipsec_config(const odp_ipsec_config_t *config)
+{
+ (void)config;
+
+ return -1;
+}
+
+void odp_ipsec_sa_param_init(odp_ipsec_sa_param_t *param)
+{
+ memset(param, 0, sizeof(odp_ipsec_sa_param_t));
+}
+
+odp_ipsec_sa_t odp_ipsec_sa_create(odp_ipsec_sa_param_t *param)
+{
+ (void)param;
+
+ return ODP_IPSEC_SA_INVALID;
+}
+
+int odp_ipsec_sa_destroy(odp_ipsec_sa_t sa)
+{
+ (void)sa;
+
+ return -1;
+}
+
+int odp_ipsec_in(const odp_ipsec_op_param_t *input,
+ odp_ipsec_op_result_t *output)
+{
+ (void)input;
+ (void)output;
+
+ return -1;
+}
+
+int odp_ipsec_out(const odp_ipsec_op_param_t *input,
+ odp_ipsec_op_result_t *output)
+{
+ (void)input;
+ (void)output;
+
+ return -1;
+}
+
+int odp_ipsec_in_enq(const odp_ipsec_op_param_t *input)
+{
+ (void)input;
+
+ return -1;
+}
+
+int odp_ipsec_out_enq(const odp_ipsec_op_param_t *input)
+{
+ (void)input;
+
+ return -1;
+}
+
+int odp_ipsec_result(odp_ipsec_op_result_t *result, odp_event_t event)
+{
+ (void)result;
+ (void)event;
+
+ return -1;
+}
+
+int odp_ipsec_mtu_update(odp_ipsec_sa_t sa, uint32_t mtu)
+{
+ (void)sa;
+ (void)mtu;
+
+ return -1;
+}
+
+void *odp_ipsec_sa_context(odp_ipsec_sa_t sa)
+{
+ (void)sa;
+
+ return NULL;
+}
+
+uint64_t odp_ipsec_sa_to_u64(odp_ipsec_sa_t sa)
+{
+ return _odp_pri(sa);
+}
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/odp_ipsec.c | 111 +++++++++++++++++++++++++++++++++++++
1 file changed, 111 insertions(+)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch api-next updated. v1.13.0.0-306-g44ae977
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, api-next has been updated
via 44ae9773bc94f8cd349034901f08a2eed46dc822 (commit)
via 82e5497c801ee3be6f49371c065b4eb43628048c (commit)
via 3f5d8c5b1f50efe8bf017b8a0014af668c664c43 (commit)
via f72f999552de02c602864baa82bb374322415b24 (commit)
via 56ee80a8482f1161a84b3e5145fab2e0f7653ccb (commit)
via 431a0783ebea4fc09e781f431599cacd3a3e4e0e (commit)
via 483cc787d1bec821a2008e32ef4dd611e365ffe4 (commit)
via de21a1cc01d03c39fd0772dff96fb69b06613f58 (commit)
via 3d6cbd2e2881c1e18922b26c7fd4a2ec9464becd (commit)
via 52f32ce1fa6b5416c59ead45ff27d731d98b8f87 (commit)
from abc36ae6747eb7729ea10ab4fa806939abca8c3e (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 44ae9773bc94f8cd349034901f08a2eed46dc822
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:30 2017 +0200
linux-gen: packet: implement references as copy
Implement packet references API as packet copy. This is the
simplest way to support the API, as other packet functions
are not affected at all.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 024f694..1d2b506 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -2221,3 +2221,81 @@ uint64_t odp_packet_seg_to_u64(odp_packet_seg_t hdl)
{
return _odp_pri(hdl);
}
+
+odp_packet_t odp_packet_ref_static(odp_packet_t pkt)
+{
+ odp_packet_t new;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ return new;
+}
+
+odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset)
+{
+ odp_packet_t new;
+ int ret;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ if (new == ODP_PACKET_INVALID) {
+ ODP_ERR("copy failed\n");
+ return ODP_PACKET_INVALID;
+ }
+
+ ret = odp_packet_trunc_head(&new, offset, NULL, NULL);
+
+ if (ret < 0) {
+ ODP_ERR("trunk_head failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+
+ return new;
+}
+
+odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
+ odp_packet_t hdr)
+{
+ odp_packet_t new;
+ int ret;
+
+ new = odp_packet_copy(pkt, odp_packet_pool(pkt));
+
+ if (new == ODP_PACKET_INVALID) {
+ ODP_ERR("copy failed\n");
+ return ODP_PACKET_INVALID;
+ }
+
+ if (offset) {
+ ret = odp_packet_trunc_head(&new, offset, NULL, NULL);
+
+ if (ret < 0) {
+ ODP_ERR("trunk_head failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+ }
+
+ ret = odp_packet_concat(&hdr, new);
+
+ if (ret < 0) {
+ ODP_ERR("concat failed\n");
+ odp_packet_free(new);
+ return ODP_PACKET_INVALID;
+ }
+
+ return hdr;
+}
+
+int odp_packet_has_ref(odp_packet_t pkt)
+{
+ (void)pkt;
+
+ return 0;
+}
+
+uint32_t odp_packet_unshared_len(odp_packet_t pkt)
+{
+ return odp_packet_len(pkt);
+}
commit 82e5497c801ee3be6f49371c065b4eb43628048c
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:29 2017 +0200
Revert "linux-generic: packet: implement reference apis"
This reverts commit 22b3986fea090986625f3255d57b64de35bbc475.
Plan to merge first version with packet copy. Than this patch will
be applied again.
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index 42df5ac..e3ada5c 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -19,7 +19,6 @@ extern "C" {
#include <odp/api/align.h>
#include <odp/api/debug.h>
-#include <odp_debug_internal.h>
#include <odp_buffer_internal.h>
#include <odp_pool_internal.h>
#include <odp_buffer_inlines.h>
@@ -169,7 +168,7 @@ typedef struct {
* packet_init(). Because of this any new fields added must be reviewed for
* initialization requirements.
*/
-typedef struct odp_packet_hdr_t {
+typedef struct {
/* common buffer header */
odp_buffer_hdr_t buf_hdr;
@@ -185,13 +184,6 @@ typedef struct odp_packet_hdr_t {
uint32_t headroom;
uint32_t tailroom;
- /* Fields used to support packet references */
- uint32_t unshared_len;
- struct odp_packet_hdr_t *ref_hdr;
- uint32_t ref_offset;
- uint32_t ref_len;
- odp_atomic_u32_t ref_count;
-
/*
* Members below are not initialized by packet_init()
*/
@@ -220,55 +212,6 @@ static inline odp_packet_hdr_t *odp_packet_hdr(odp_packet_t pkt)
return (odp_packet_hdr_t *)buf_hdl_to_hdr((odp_buffer_t)pkt);
}
-static inline odp_packet_hdr_t *odp_packet_last_hdr(odp_packet_t pkt,
- uint32_t *offset)
-{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- odp_packet_hdr_t *prev_hdr = pkt_hdr;
- uint32_t ref_offset = 0;
-
- while (pkt_hdr->ref_hdr) {
- ref_offset = pkt_hdr->ref_offset;
- prev_hdr = pkt_hdr;
- pkt_hdr = pkt_hdr->ref_hdr;
- }
-
- if (offset) {
- if (prev_hdr != pkt_hdr)
- ref_offset += pkt_hdr->frame_len - prev_hdr->ref_len;
- *offset = ref_offset;
- }
-
- return pkt_hdr;
-}
-
-static inline odp_packet_hdr_t *odp_packet_prev_hdr(odp_packet_hdr_t *pkt_hdr,
- odp_packet_hdr_t *cur_hdr,
- uint32_t *offset)
-{
- uint32_t ref_offset = 0;
- odp_packet_hdr_t *prev_hdr = pkt_hdr;
-
- while (pkt_hdr->ref_hdr != cur_hdr) {
- ref_offset = pkt_hdr->ref_offset;
- prev_hdr = pkt_hdr;
- pkt_hdr = pkt_hdr->ref_hdr;
- }
-
- if (offset) {
- if (prev_hdr != pkt_hdr)
- ref_offset += pkt_hdr->frame_len - prev_hdr->ref_len;
- *offset = ref_offset;
- }
-
- return pkt_hdr;
-}
-
-static inline odp_packet_t _odp_packet_hdl(odp_packet_hdr_t *pkt_hdr)
-{
- return (odp_packet_t)odp_hdr_to_buf(&pkt_hdr->buf_hdr);
-}
-
static inline void copy_packet_parser_metadata(odp_packet_hdr_t *src_hdr,
odp_packet_hdr_t *dst_hdr)
{
@@ -291,41 +234,17 @@ static inline void pull_tail(odp_packet_hdr_t *pkt_hdr, uint32_t len)
pkt_hdr->tailroom += len;
pkt_hdr->frame_len -= len;
- pkt_hdr->unshared_len -= len;
pkt_hdr->buf_hdr.seg[last].len -= len;
}
static inline uint32_t packet_len(odp_packet_hdr_t *pkt_hdr)
{
- uint32_t pkt_len = 0;
- uint32_t offset = 0;
-
- do {
- pkt_len += pkt_hdr->frame_len - offset;
- offset = pkt_hdr->ref_offset;
- if (pkt_hdr->ref_hdr)
- offset += (pkt_hdr->ref_hdr->frame_len -
- pkt_hdr->ref_len);
- pkt_hdr = pkt_hdr->ref_hdr;
- } while (pkt_hdr);
-
- return pkt_len;
-}
-
-static inline uint32_t packet_ref_count(odp_packet_hdr_t *pkt_hdr)
-{
- return odp_atomic_load_u32(&pkt_hdr->ref_count);
-}
-
-static inline void packet_ref_count_set(odp_packet_hdr_t *pkt_hdr, uint32_t n)
-{
- odp_atomic_init_u32(&pkt_hdr->ref_count, n);
+ return pkt_hdr->frame_len;
}
static inline void packet_set_len(odp_packet_hdr_t *pkt_hdr, uint32_t len)
{
pkt_hdr->frame_len = len;
- pkt_hdr->unshared_len = len;
}
static inline int packet_parse_l2_not_done(packet_parser_t *prs)
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 3aadc4d..024f694 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -33,24 +33,13 @@ static inline odp_buffer_t buffer_handle(odp_packet_hdr_t *pkt_hdr)
return pkt_hdr->buf_hdr.handle.handle;
}
-static inline uint32_t packet_ref_inc(odp_packet_hdr_t *pkt_hdr)
-{
- return odp_atomic_fetch_inc_u32(&pkt_hdr->ref_count);
-}
-
-static inline uint32_t packet_ref_dec(odp_packet_hdr_t *pkt_hdr)
-{
- return odp_atomic_fetch_dec_u32(&pkt_hdr->ref_count);
-}
-
static inline uint32_t packet_seg_len(odp_packet_hdr_t *pkt_hdr,
uint32_t seg_idx)
{
return pkt_hdr->buf_hdr.seg[seg_idx].len;
}
-static inline uint8_t *packet_seg_data(odp_packet_hdr_t *pkt_hdr,
- uint32_t seg_idx)
+static inline void *packet_seg_data(odp_packet_hdr_t *pkt_hdr, uint32_t seg_idx)
{
return pkt_hdr->buf_hdr.seg[seg_idx].data;
}
@@ -63,11 +52,6 @@ static inline int packet_last_seg(odp_packet_hdr_t *pkt_hdr)
return pkt_hdr->buf_hdr.segcount - 1;
}
-static inline void *packet_data(odp_packet_hdr_t *pkt_hdr)
-{
- return pkt_hdr->buf_hdr.seg[0].data;
-}
-
static inline uint32_t packet_first_seg_len(odp_packet_hdr_t *pkt_hdr)
{
return packet_seg_len(pkt_hdr, 0);
@@ -80,6 +64,11 @@ static inline uint32_t packet_last_seg_len(odp_packet_hdr_t *pkt_hdr)
return packet_seg_len(pkt_hdr, last);
}
+static inline void *packet_data(odp_packet_hdr_t *pkt_hdr)
+{
+ return pkt_hdr->buf_hdr.seg[0].data;
+}
+
static inline void *packet_tail(odp_packet_hdr_t *pkt_hdr)
{
int last = packet_last_seg(pkt_hdr);
@@ -110,7 +99,6 @@ static inline void push_head(odp_packet_hdr_t *pkt_hdr, uint32_t len)
{
pkt_hdr->headroom -= len;
pkt_hdr->frame_len += len;
- pkt_hdr->unshared_len += len;
pkt_hdr->buf_hdr.seg[0].data -= len;
pkt_hdr->buf_hdr.seg[0].len += len;
}
@@ -119,7 +107,6 @@ static inline void pull_head(odp_packet_hdr_t *pkt_hdr, uint32_t len)
{
pkt_hdr->headroom += len;
pkt_hdr->frame_len -= len;
- pkt_hdr->unshared_len -= len;
pkt_hdr->buf_hdr.seg[0].data += len;
pkt_hdr->buf_hdr.seg[0].len -= len;
}
@@ -130,7 +117,6 @@ static inline void push_tail(odp_packet_hdr_t *pkt_hdr, uint32_t len)
pkt_hdr->tailroom -= len;
pkt_hdr->frame_len += len;
- pkt_hdr->unshared_len += len;
pkt_hdr->buf_hdr.seg[last].len += len;
}
@@ -158,10 +144,6 @@ static inline void packet_seg_copy_md(odp_packet_hdr_t *dst,
dst->buf_hdr.uarea_addr = src->buf_hdr.uarea_addr;
dst->buf_hdr.uarea_size = src->buf_hdr.uarea_size;
- /* reference related metadata */
- dst->ref_len = src->ref_len;
- dst->unshared_len = src->unshared_len;
-
/* segmentation data is not copied:
* buf_hdr.seg[]
* buf_hdr.segcount
@@ -176,15 +158,7 @@ static inline void *packet_map(odp_packet_hdr_t *pkt_hdr,
int seg = 0;
int seg_count = pkt_hdr->buf_hdr.segcount;
- /* Special processing for references */
- while (offset >= pkt_hdr->frame_len && pkt_hdr->ref_hdr) {
- offset -= (pkt_hdr->frame_len - pkt_hdr->ref_offset);
- offset += (pkt_hdr->ref_hdr->frame_len - pkt_hdr->ref_len);
- pkt_hdr = pkt_hdr->ref_hdr;
- seg_count = pkt_hdr->buf_hdr.segcount;
- }
-
- if (odp_unlikely(offset > pkt_hdr->frame_len))
+ if (odp_unlikely(offset >= pkt_hdr->frame_len))
return NULL;
if (odp_likely(CONFIG_PACKET_MAX_SEGS == 1 || seg_count == 1)) {
@@ -233,9 +207,6 @@ void packet_parse_reset(odp_packet_hdr_t *pkt_hdr)
pkt_hdr->p.l2_offset = 0;
pkt_hdr->p.l3_offset = ODP_PACKET_OFFSET_INVALID;
pkt_hdr->p.l4_offset = ODP_PACKET_OFFSET_INVALID;
-
- /* Ensure dummy pkt_hdrs used in I/O recv classification are valid */
- pkt_hdr->ref_hdr = NULL;
}
/**
@@ -281,10 +252,6 @@ static inline void packet_init(odp_packet_hdr_t *pkt_hdr, uint32_t len,
CONFIG_PACKET_TAILROOM;
pkt_hdr->input = ODP_PKTIO_INVALID;
-
- /* By default packet has no references */
- pkt_hdr->unshared_len = len;
- pkt_hdr->ref_hdr = NULL;
}
static inline void init_segments(odp_packet_hdr_t *pkt_hdr[], int num)
@@ -297,7 +264,6 @@ static inline void init_segments(odp_packet_hdr_t *pkt_hdr[], int num)
hdr->buf_hdr.seg[0].data = hdr->buf_hdr.base_data;
hdr->buf_hdr.seg[0].len = BASE_LEN;
- packet_ref_count_set(hdr, 1);
/* Link segments */
if (CONFIG_PACKET_MAX_SEGS != 1) {
@@ -307,7 +273,6 @@ static inline void init_segments(odp_packet_hdr_t *pkt_hdr[], int num)
for (i = 1; i < num; i++) {
odp_buffer_hdr_t *buf_hdr;
- packet_ref_count_set(pkt_hdr[i], 1);
buf_hdr = &pkt_hdr[i]->buf_hdr;
hdr->buf_hdr.seg[i].hdr = buf_hdr;
hdr->buf_hdr.seg[i].data = buf_hdr->base_data;
@@ -411,10 +376,9 @@ static inline odp_packet_hdr_t *add_segments(odp_packet_hdr_t *pkt_hdr,
new_hdr->buf_hdr.seg[0].len = seg_len;
packet_seg_copy_md(new_hdr, pkt_hdr);
- new_hdr->frame_len = pkt_hdr->frame_len + len;
- new_hdr->unshared_len = pkt_hdr->unshared_len + len;
- new_hdr->headroom = pool->headroom + offset;
- new_hdr->tailroom = pkt_hdr->tailroom;
+ new_hdr->frame_len = pkt_hdr->frame_len + len;
+ new_hdr->headroom = pool->headroom + offset;
+ new_hdr->tailroom = pkt_hdr->tailroom;
pkt_hdr = new_hdr;
} else {
@@ -427,9 +391,8 @@ static inline odp_packet_hdr_t *add_segments(odp_packet_hdr_t *pkt_hdr,
last = packet_last_seg(pkt_hdr);
pkt_hdr->buf_hdr.seg[last].len = seg_len;
- pkt_hdr->frame_len += len;
- pkt_hdr->unshared_len += len;
- pkt_hdr->tailroom = pool->tailroom + offset;
+ pkt_hdr->frame_len += len;
+ pkt_hdr->tailroom = pool->tailroom + offset;
}
return pkt_hdr;
@@ -437,18 +400,13 @@ static inline odp_packet_hdr_t *add_segments(odp_packet_hdr_t *pkt_hdr,
static inline void free_bufs(odp_packet_hdr_t *pkt_hdr, int first, int num)
{
- int i, nfree;
+ int i;
odp_buffer_t buf[num];
- for (i = 0, nfree = 0; i < num; i++) {
- odp_packet_hdr_t *hdr = pkt_hdr->buf_hdr.seg[first + i].hdr;
-
- if (packet_ref_dec(hdr) == 1)
- buf[nfree++] = buffer_handle(hdr);
- }
+ for (i = 0; i < num; i++)
+ buf[i] = buffer_handle(pkt_hdr->buf_hdr.seg[first + i].hdr);
- if (nfree > 0)
- buffer_free_multi(buf, nfree);
+ buffer_free_multi(buf, num);
}
static inline odp_packet_hdr_t *free_segments(odp_packet_hdr_t *pkt_hdr,
@@ -459,15 +417,11 @@ static inline odp_packet_hdr_t *free_segments(odp_packet_hdr_t *pkt_hdr,
if (head) {
odp_packet_hdr_t *new_hdr;
- int i, nfree;
+ int i;
odp_buffer_t buf[num];
- for (i = 0, nfree = 0; i < num; i++) {
- new_hdr = pkt_hdr->buf_hdr.seg[i].hdr;
-
- if (packet_ref_dec(new_hdr) == 1)
- buf[nfree++] = buffer_handle(new_hdr);
- }
+ for (i = 0; i < num; i++)
+ buf[i] = buffer_handle(pkt_hdr->buf_hdr.seg[i].hdr);
/* First remaining segment is the new packet descriptor */
new_hdr = pkt_hdr->buf_hdr.seg[num].hdr;
@@ -476,17 +430,15 @@ static inline odp_packet_hdr_t *free_segments(odp_packet_hdr_t *pkt_hdr,
packet_seg_copy_md(new_hdr, pkt_hdr);
/* Tailroom not changed */
- new_hdr->tailroom = pkt_hdr->tailroom;
- new_hdr->headroom = seg_headroom(new_hdr, 0);
- new_hdr->frame_len = pkt_hdr->frame_len - free_len;
- new_hdr->unshared_len = pkt_hdr->unshared_len - free_len;
+ new_hdr->tailroom = pkt_hdr->tailroom;
+ new_hdr->headroom = seg_headroom(new_hdr, 0);
+ new_hdr->frame_len = pkt_hdr->frame_len - free_len;
pull_head(new_hdr, pull_len);
pkt_hdr = new_hdr;
- if (nfree > 0)
- buffer_free_multi(buf, nfree);
+ buffer_free_multi(buf, num);
} else {
/* Free last 'num' bufs */
free_bufs(pkt_hdr, num_remain, num);
@@ -495,7 +447,6 @@ static inline odp_packet_hdr_t *free_segments(odp_packet_hdr_t *pkt_hdr,
* of the metadata. */
pkt_hdr->buf_hdr.segcount = num_remain;
pkt_hdr->frame_len -= free_len;
- pkt_hdr->unshared_len -= free_len;
pkt_hdr->tailroom = seg_tailroom(pkt_hdr, num_remain - 1);
pull_tail(pkt_hdr, pull_len);
@@ -599,34 +550,45 @@ int odp_packet_alloc_multi(odp_pool_t pool_hdl, uint32_t len,
return num;
}
-static inline void packet_free(odp_packet_hdr_t *pkt_hdr)
-{
- odp_packet_hdr_t *ref_hdr;
- uint32_t ref_count;
-
- do {
- ref_hdr = pkt_hdr->ref_hdr;
- ref_count = packet_ref_count(pkt_hdr) - 1;
- free_bufs(pkt_hdr, 0, pkt_hdr->buf_hdr.segcount);
-
- if (ref_count == 1)
- pkt_hdr->unshared_len = pkt_hdr->frame_len;
-
- pkt_hdr = ref_hdr;
- } while (pkt_hdr);
-}
-
void odp_packet_free(odp_packet_t pkt)
{
- packet_free(odp_packet_hdr(pkt));
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+ int num_seg = pkt_hdr->buf_hdr.segcount;
+
+ if (odp_likely(CONFIG_PACKET_MAX_SEGS == 1 || num_seg == 1))
+ buffer_free_multi((odp_buffer_t *)&pkt, 1);
+ else
+ free_bufs(pkt_hdr, 0, num_seg);
}
void odp_packet_free_multi(const odp_packet_t pkt[], int num)
{
- int i;
+ if (CONFIG_PACKET_MAX_SEGS == 1) {
+ buffer_free_multi((const odp_buffer_t * const)pkt, num);
+ } else {
+ odp_buffer_t buf[num * CONFIG_PACKET_MAX_SEGS];
+ int i, j;
+ int bufs = 0;
- for (i = 0; i < num; i++)
- packet_free(odp_packet_hdr(pkt[i]));
+ for (i = 0; i < num; i++) {
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt[i]);
+ int num_seg = pkt_hdr->buf_hdr.segcount;
+ odp_buffer_hdr_t *buf_hdr = &pkt_hdr->buf_hdr;
+
+ buf[bufs] = (odp_buffer_t)pkt[i];
+ bufs++;
+
+ if (odp_likely(num_seg == 1))
+ continue;
+
+ for (j = 1; j < num_seg; j++) {
+ buf[bufs] = buffer_handle(buf_hdr->seg[j].hdr);
+ bufs++;
+ }
+ }
+
+ buffer_free_multi(buf, bufs);
+ }
}
int odp_packet_reset(odp_packet_t pkt, uint32_t len)
@@ -637,9 +599,6 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len)
if (len > pool->headroom + pool->data_size + pool->tailroom)
return -1;
- if (pkt_hdr->ref_hdr)
- packet_free(pkt_hdr->ref_hdr);
-
packet_init(pkt_hdr, len, 0);
return 0;
@@ -682,21 +641,15 @@ void *odp_packet_head(odp_packet_t pkt)
uint32_t odp_packet_buf_len(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t buf_len = 0;
- do {
- buf_len += pkt_hdr->buf_hdr.size * pkt_hdr->buf_hdr.segcount;
- pkt_hdr = pkt_hdr->ref_hdr;
- } while (pkt_hdr);
-
- return buf_len;
+ return pkt_hdr->buf_hdr.size * pkt_hdr->buf_hdr.segcount;
}
void *odp_packet_data(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return packet_map(pkt_hdr, 0, NULL, NULL);
+ return packet_data(pkt_hdr);
}
uint32_t odp_packet_seg_len(odp_packet_t pkt)
@@ -708,32 +661,7 @@ uint32_t odp_packet_seg_len(odp_packet_t pkt)
uint32_t odp_packet_len(odp_packet_t pkt)
{
- return packet_len(odp_packet_hdr(pkt));
-}
-
-uint32_t odp_packet_unshared_len(odp_packet_t pkt)
-{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t pkt_len = 0, offset = 0;
-
- do {
- if (packet_ref_count(pkt_hdr) > 1) {
- if (offset == 0)
- pkt_len += pkt_hdr->unshared_len;
- break;
- }
-
- pkt_len += pkt_hdr->frame_len - offset;
- offset = pkt_hdr->ref_offset;
-
- if (pkt_hdr->ref_hdr)
- offset += (pkt_hdr->ref_hdr->frame_len -
- pkt_hdr->ref_len);
-
- pkt_hdr = pkt_hdr->ref_hdr;
- } while (pkt_hdr);
-
- return pkt_len;
+ return odp_packet_hdr(pkt)->frame_len;
}
uint32_t odp_packet_headroom(odp_packet_t pkt)
@@ -743,12 +671,12 @@ uint32_t odp_packet_headroom(odp_packet_t pkt)
uint32_t odp_packet_tailroom(odp_packet_t pkt)
{
- return odp_packet_last_hdr(pkt, NULL)->tailroom;
+ return odp_packet_hdr(pkt)->tailroom;
}
void *odp_packet_tail(odp_packet_t pkt)
{
- odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(pkt, NULL);
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return packet_tail(pkt_hdr);
}
@@ -942,7 +870,7 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
uint32_t frame_len = pkt_hdr->frame_len;
- uint32_t headroom = pkt_hdr->headroom;
+ uint32_t headroom = pkt_hdr->headroom;
int ret = 0;
if (len > headroom) {
@@ -957,46 +885,6 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
segs = pkt_hdr->buf_hdr.segcount;
if (odp_unlikely((segs + num) > CONFIG_PACKET_MAX_SEGS)) {
- /* Handle recursively via references when
- * working with referenced packets since another
- * thread may be accessing it concurrently via
- * its reference to it. */
- if (packet_ref_count(pkt_hdr) > 1) {
- odp_packet_t ref;
- uint32_t unshared_len;
-
- push_head(pkt_hdr, headroom);
- unshared_len = pkt_hdr->unshared_len;
- ref = odp_packet_ref(*pkt, 0);
-
- if (ref == ODP_PACKET_INVALID) {
- pull_head(pkt_hdr, headroom);
- return -1;
- }
-
- ret = odp_packet_extend_head(&ref,
- len - headroom,
- data_ptr,
- seg_len);
-
- if (ret < 0) {
- odp_packet_free(ref);
- pull_head(pkt_hdr, headroom);
- return -1;
- }
-
- /* Since this is a special ref, the
- * base pkt's unshared len is unchanged */
- pkt_hdr->unshared_len = unshared_len;
-
- /* Remove extra ref to the base pkt */
- odp_packet_free(*pkt);
-
- /* Return the ref as the extension result */
- *pkt = ref;
- return 1;
- }
-
/* Cannot directly add new segments */
odp_packet_hdr_t *new_hdr;
int new_segs = 0;
@@ -1048,7 +936,6 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
pkt_hdr->buf_hdr.segcount = segs;
pkt_hdr->frame_len = frame_len;
- pkt_hdr->unshared_len = frame_len;
pkt_hdr->headroom = offset + pool->headroom;
pkt_hdr->tailroom = pool->tailroom;
@@ -1074,16 +961,11 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len,
push_head(pkt_hdr, len);
}
- if (data_ptr || seg_len) {
- uint32_t seg_ln = 0;
- void *data = packet_map(pkt_hdr, 0, &seg_ln, NULL);
-
- if (data_ptr)
- *data_ptr = data;
+ if (data_ptr)
+ *data_ptr = packet_data(pkt_hdr);
- if (seg_len)
- *seg_len = seg_ln;
- }
+ if (seg_len)
+ *seg_len = packet_first_seg_len(pkt_hdr);
return ret;
}
@@ -1095,8 +977,6 @@ void *odp_packet_pull_head(odp_packet_t pkt, uint32_t len)
if (len > pkt_hdr->frame_len)
return NULL;
- ODP_ASSERT(len <= pkt_hdr->unshared_len);
-
pull_head(pkt_hdr, len);
return packet_data(pkt_hdr);
}
@@ -1104,35 +984,15 @@ void *odp_packet_pull_head(odp_packet_t pkt, uint32_t len)
int odp_packet_trunc_head(odp_packet_t *pkt, uint32_t len,
void **data_ptr, uint32_t *seg_len_out)
{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt), *nxt_hdr;
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
uint32_t seg_len = packet_first_seg_len(pkt_hdr);
- int ret = 0;
- if (len > packet_len(pkt_hdr))
+ if (len > pkt_hdr->frame_len)
return -1;
- ODP_ASSERT(len <= odp_packet_unshared_len(*pkt));
-
- /* Special processing for references */
- while (len >= pkt_hdr->frame_len && pkt_hdr->ref_hdr) {
- ODP_ASSERT(packet_ref_count(pkt_hdr) == 1);
- nxt_hdr = pkt_hdr->ref_hdr;
- len -= pkt_hdr->frame_len;
- len += pkt_hdr->ref_offset +
- (nxt_hdr->frame_len - pkt_hdr->ref_len);
- pkt_hdr->ref_hdr = NULL;
- packet_free(pkt_hdr);
- pkt_hdr = nxt_hdr;
- seg_len = packet_first_seg_len(pkt_hdr);
- *pkt = packet_handle(pkt_hdr);
- ret = 1;
- }
-
- if (CONFIG_PACKET_MAX_SEGS == 1 ||
- len < seg_len ||
- pkt_hdr->buf_hdr.segcount == 1) {
+ if (len < seg_len) {
pull_head(pkt_hdr, len);
- } else {
+ } else if (CONFIG_PACKET_MAX_SEGS != 1) {
int num = 0;
uint32_t pull_len = 0;
@@ -1147,29 +1007,23 @@ int odp_packet_trunc_head(odp_packet_t *pkt, uint32_t len,
*pkt = packet_handle(pkt_hdr);
}
- if (data_ptr || seg_len_out) {
- void *data_head = packet_map(pkt_hdr, 0, &seg_len, NULL);
-
- if (data_ptr)
- *data_ptr = data_head;
+ if (data_ptr)
+ *data_ptr = packet_data(pkt_hdr);
- if (seg_len_out)
- *seg_len_out = seg_len;
- }
+ if (seg_len_out)
+ *seg_len_out = packet_first_seg_len(pkt_hdr);
- return ret;
+ return 0;
}
void *odp_packet_push_tail(odp_packet_t pkt, uint32_t len)
{
- odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(pkt, NULL);
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
void *old_tail;
if (len > pkt_hdr->tailroom)
return NULL;
- ODP_ASSERT(packet_ref_count(pkt_hdr) == 1);
-
old_tail = packet_tail(pkt_hdr);
push_tail(pkt_hdr, len);
@@ -1179,14 +1033,12 @@ void *odp_packet_push_tail(odp_packet_t pkt, uint32_t len)
int odp_packet_extend_tail(odp_packet_t *pkt, uint32_t len,
void **data_ptr, uint32_t *seg_len_out)
{
- odp_packet_hdr_t *pkt_hdr = odp_packet_last_hdr(*pkt, NULL);
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
uint32_t frame_len = pkt_hdr->frame_len;
uint32_t tailroom = pkt_hdr->tailroom;
uint32_t tail_off = frame_len;
int ret = 0;
- ODP_ASSERT(packet_ref_count(pkt_hdr) == 1);
-
if (len > tailroom) {
pool_t *pool = pool_entry_from_hdl(pkt_hdr->buf_hdr.pool_hdl);
int num;
@@ -1277,7 +1129,6 @@ void *odp_packet_pull_tail(odp_packet_t pkt, uint32_t len)
if (len > packet_last_seg_len(pkt_hdr))
return NULL;
- ODP_ASSERT(packet_ref_count(pkt_hdr) == 1);
pull_tail(pkt_hdr, len);
return packet_tail(pkt_hdr);
@@ -1288,34 +1139,17 @@ int odp_packet_trunc_tail(odp_packet_t *pkt, uint32_t len,
{
int last;
uint32_t seg_len;
- uint32_t offset;
- odp_packet_hdr_t *first_hdr = odp_packet_hdr(*pkt);
- odp_packet_hdr_t *pkt_hdr, *prev_hdr;
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(*pkt);
- if (len > packet_len(first_hdr))
+ if (len > pkt_hdr->frame_len)
return -1;
- pkt_hdr = odp_packet_last_hdr(*pkt, &offset);
-
- /* Special processing for references */
- while (len >= pkt_hdr->frame_len - offset && first_hdr->ref_hdr) {
- len -= (pkt_hdr->frame_len - offset);
- prev_hdr = odp_packet_prev_hdr(first_hdr, pkt_hdr, &offset);
- ODP_ASSERT(packet_ref_count(prev_hdr) == 1);
- prev_hdr->ref_hdr = NULL;
- packet_free(pkt_hdr);
- pkt_hdr = prev_hdr;
- }
-
- ODP_ASSERT(packet_ref_count(pkt_hdr) == 1);
last = packet_last_seg(pkt_hdr);
seg_len = packet_seg_len(pkt_hdr, last);
- if (CONFIG_PACKET_MAX_SEGS == 1 ||
- len < seg_len ||
- pkt_hdr->buf_hdr.segcount == 1) {
+ if (len < seg_len) {
pull_tail(pkt_hdr, len);
- } else {
+ } else if (CONFIG_PACKET_MAX_SEGS != 1) {
int num = 0;
uint32_t pull_len = 0;
@@ -1522,50 +1356,35 @@ void odp_packet_ts_set(odp_packet_t pkt, odp_time_t timestamp)
int odp_packet_is_segmented(odp_packet_t pkt)
{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
-
- return pkt_hdr->buf_hdr.segcount > 1 || pkt_hdr->ref_hdr != NULL;
+ return odp_packet_hdr(pkt)->buf_hdr.segcount > 1;
}
int odp_packet_num_segs(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t segcount = 0, i;
- uint32_t seg_offset = 0, offset;
-
- do {
- segcount += pkt_hdr->buf_hdr.segcount - seg_offset;
- offset = pkt_hdr->ref_offset;
- pkt_hdr = pkt_hdr->ref_hdr;
- if (pkt_hdr) {
- for (i = 0, seg_offset = 0;
- i < pkt_hdr->buf_hdr.segcount;
- i++, seg_offset++) {
- if (offset < pkt_hdr->buf_hdr.seg[i].len)
- break;
- offset -= pkt_hdr->buf_hdr.seg[i].len;
- }
- }
- } while (pkt_hdr);
- return segcount;
+ return pkt_hdr->buf_hdr.segcount;
}
-odp_packet_seg_t odp_packet_first_seg(odp_packet_t pkt ODP_UNUSED)
+odp_packet_seg_t odp_packet_first_seg(odp_packet_t pkt)
{
+ (void)pkt;
+
return 0;
}
odp_packet_seg_t odp_packet_last_seg(odp_packet_t pkt)
{
- return (odp_packet_seg_t)(odp_packet_num_segs(pkt) - 1);
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+
+ return packet_last_seg(pkt_hdr);
}
odp_packet_seg_t odp_packet_next_seg(odp_packet_t pkt, odp_packet_seg_t seg)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- if (odp_unlikely(seg >= packet_last_seg(pkt_hdr)))
+ if (odp_unlikely(seg >= (odp_packet_seg_t)packet_last_seg(pkt_hdr)))
return ODP_PACKET_SEG_INVALID;
return seg + 1;
@@ -1581,51 +1400,21 @@ odp_packet_seg_t odp_packet_next_seg(odp_packet_t pkt, odp_packet_seg_t seg)
void *odp_packet_seg_data(odp_packet_t pkt, odp_packet_seg_t seg)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t seg_offset = 0, offset = 0, i;
-
- while (seg >= pkt_hdr->buf_hdr.segcount - seg_offset &&
- pkt_hdr->ref_hdr) {
- seg -= (pkt_hdr->buf_hdr.segcount - seg_offset);
- offset = pkt_hdr->ref_offset;
- pkt_hdr = pkt_hdr->ref_hdr;
- for (i = 0, seg_offset = 0;
- i < pkt_hdr->buf_hdr.segcount;
- i++, seg_offset++) {
- if (offset < pkt_hdr->buf_hdr.seg[i].len)
- break;
- offset -= pkt_hdr->buf_hdr.seg[i].len;
- }
- }
- if (odp_unlikely(seg + seg_offset >= pkt_hdr->buf_hdr.segcount))
+ if (odp_unlikely(seg >= pkt_hdr->buf_hdr.segcount))
return NULL;
- return packet_seg_data(pkt_hdr, seg + seg_offset) + offset;
+ return packet_seg_data(pkt_hdr, seg);
}
uint32_t odp_packet_seg_data_len(odp_packet_t pkt, odp_packet_seg_t seg)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t seg_offset = 0, offset = 0, i;
-
- while (seg >= pkt_hdr->buf_hdr.segcount - seg_offset &&
- pkt_hdr->ref_hdr) {
- seg -= (pkt_hdr->buf_hdr.segcount - seg_offset);
- offset = pkt_hdr->ref_offset;
- pkt_hdr = pkt_hdr->ref_hdr;
- for (i = 0, seg_offset = 0;
- i < pkt_hdr->buf_hdr.segcount;
- i++, seg_offset++) {
- if (offset < pkt_hdr->buf_hdr.seg[i].len)
- break;
- offset -= pkt_hdr->buf_hdr.seg[i].len;
- }
- }
- if (odp_unlikely(seg + seg_offset >= pkt_hdr->buf_hdr.segcount))
+ if (odp_unlikely(seg >= pkt_hdr->buf_hdr.segcount))
return 0;
- return packet_seg_len(pkt_hdr, seg + seg_offset) - offset;
+ return packet_seg_len(pkt_hdr, seg);
}
/*
@@ -1639,14 +1428,12 @@ int odp_packet_add_data(odp_packet_t *pkt_ptr, uint32_t offset, uint32_t len)
{
odp_packet_t pkt = *pkt_ptr;
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- uint32_t pktlen = packet_len(pkt_hdr);
+ uint32_t pktlen = pkt_hdr->frame_len;
odp_packet_t newpkt;
if (offset > pktlen)
return -1;
- ODP_ASSERT(odp_packet_unshared_len(*pkt_ptr) >= offset);
-
newpkt = odp_packet_alloc(pkt_hdr->buf_hdr.pool_hdl, pktlen + len);
if (newpkt == ODP_PACKET_INVALID)
@@ -1709,8 +1496,6 @@ int odp_packet_align(odp_packet_t *pkt, uint32_t offset, uint32_t len,
if (align > ODP_CACHE_LINE_SIZE)
return -1;
- ODP_ASSERT(odp_packet_has_ref(*pkt) == 0);
-
if (seglen >= len) {
misalign = align <= 1 ? 0 :
ROUNDUP_ALIGN(uaddr, align) - uaddr;
@@ -1750,13 +1535,10 @@ int odp_packet_concat(odp_packet_t *dst, odp_packet_t src)
uint32_t dst_len = dst_hdr->frame_len;
uint32_t src_len = src_hdr->frame_len;
- ODP_ASSERT(packet_ref_count(dst_hdr) == 1);
-
/* Do a copy if resulting packet would be out of segments or packets
- * are from different pools or src is a reference. */
+ * are from different pools. */
if (odp_unlikely((dst_segs + src_segs) > CONFIG_PACKET_MAX_SEGS) ||
- odp_unlikely(dst_pool != src_pool) ||
- odp_unlikely(packet_ref_count(src_hdr)) > 1) {
+ odp_unlikely(dst_pool != src_pool)) {
if (odp_packet_extend_tail(dst, src_len, NULL, NULL) >= 0) {
(void)odp_packet_copy_from_pkt(*dst, dst_len,
src, 0, src_len);
@@ -1771,9 +1553,8 @@ int odp_packet_concat(odp_packet_t *dst, odp_packet_t src)
add_all_segs(dst_hdr, src_hdr);
- dst_hdr->frame_len = dst_len + src_len;
- dst_hdr->unshared_len = dst_len + src_len;
- dst_hdr->tailroom = src_hdr->tailroom;
+ dst_hdr->frame_len = dst_len + src_len;
+ dst_hdr->tailroom = src_hdr->tailroom;
/* Data was not moved in memory */
return 0;
@@ -1786,7 +1567,6 @@ int odp_packet_split(odp_packet_t *pkt, uint32_t len, odp_packet_t *tail)
if (len >= pktlen || tail == NULL)
return -1;
- ODP_ASSERT(odp_packet_unshared_len(*pkt) >= len);
*tail = odp_packet_copy_part(*pkt, len, pktlen - len,
odp_packet_pool(*pkt));
@@ -1797,109 +1577,6 @@ int odp_packet_split(odp_packet_t *pkt, uint32_t len, odp_packet_t *tail)
}
/*
- * References
- */
-
-static inline void packet_ref(odp_packet_hdr_t *pkt_hdr)
-{
- uint32_t i;
- odp_packet_hdr_t *hdr;
-
- do {
- for (i = 0; i < pkt_hdr->buf_hdr.segcount; i++) {
- hdr = pkt_hdr->buf_hdr.seg[i].hdr;
- packet_ref_inc(hdr);
- }
-
- pkt_hdr = pkt_hdr->ref_hdr;
- } while (pkt_hdr);
-}
-
-static inline odp_packet_t packet_splice(odp_packet_hdr_t *pkt_hdr,
- uint32_t offset,
- odp_packet_hdr_t *ref_hdr)
-{
- /* Catch attempted references to stale handles in debug builds */
- ODP_ASSERT(packet_ref_count(pkt_hdr) > 0);
-
- /* Splicing is from the last section of src pkt */
- while (ref_hdr->ref_hdr)
- ref_hdr = ref_hdr->ref_hdr;
-
- /* Find section where splice begins */
- while (offset >= pkt_hdr->frame_len && pkt_hdr->ref_hdr) {
- offset -= (pkt_hdr->frame_len - pkt_hdr->ref_offset);
- offset += (pkt_hdr->ref_hdr->frame_len - pkt_hdr->ref_len);
- pkt_hdr = pkt_hdr->ref_hdr;
- }
-
- ref_hdr->ref_hdr = pkt_hdr;
- ref_hdr->ref_offset = offset;
- ref_hdr->ref_len = pkt_hdr->frame_len;
-
- if (offset < pkt_hdr->unshared_len)
- pkt_hdr->unshared_len = offset;
-
- packet_ref(pkt_hdr);
- return _odp_packet_hdl(ref_hdr);
-}
-
-odp_packet_t odp_packet_ref_static(odp_packet_t pkt)
-{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
-
- pkt_hdr->unshared_len = 0;
- packet_ref(pkt_hdr);
- return pkt;
-}
-
-odp_packet_t odp_packet_ref(odp_packet_t pkt, uint32_t offset)
-{
- odp_packet_t hdr;
- odp_packet_hdr_t *pkt_hdr;
-
- if (pkt == ODP_PACKET_INVALID)
- return ODP_PACKET_INVALID;
-
- pkt_hdr = odp_packet_hdr(pkt);
- if (offset >= packet_len(pkt_hdr))
- return ODP_PACKET_INVALID;
-
- hdr = odp_packet_alloc(odp_packet_pool(pkt), 0);
-
- if (hdr == ODP_PACKET_INVALID)
- return ODP_PACKET_INVALID;
-
- return packet_splice(pkt_hdr, offset, odp_packet_hdr(hdr));
-}
-
-odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
- odp_packet_t hdr)
-{
- odp_packet_hdr_t *pkt_hdr;
-
- if (pkt == ODP_PACKET_INVALID ||
- hdr == ODP_PACKET_INVALID ||
- pkt == hdr)
- return ODP_PACKET_INVALID;
-
- ODP_ASSERT(odp_packet_has_ref(hdr) == 0);
-
- pkt_hdr = odp_packet_hdr(pkt);
- if (offset >= packet_len(pkt_hdr))
- return ODP_PACKET_INVALID;
-
- return packet_splice(pkt_hdr, offset, odp_packet_hdr(hdr));
-}
-
-int odp_packet_has_ref(odp_packet_t pkt)
-{
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
-
- return pkt_hdr->ref_hdr != NULL || packet_ref_count(pkt_hdr) > 1;
-}
-
-/*
*
* Copy
* ********************************************************
@@ -1908,7 +1585,8 @@ int odp_packet_has_ref(odp_packet_t pkt)
odp_packet_t odp_packet_copy(odp_packet_t pkt, odp_pool_t pool)
{
- uint32_t pktlen = odp_packet_len(pkt);
+ odp_packet_hdr_t *srchdr = odp_packet_hdr(pkt);
+ uint32_t pktlen = srchdr->frame_len;
odp_packet_t newpkt = odp_packet_alloc(pool, pktlen);
if (newpkt != ODP_PACKET_INVALID) {
@@ -1947,7 +1625,7 @@ int odp_packet_copy_to_mem(odp_packet_t pkt, uint32_t offset,
uint8_t *dstaddr = (uint8_t *)dst;
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- if (offset + len > packet_len(pkt_hdr))
+ if (offset + len > pkt_hdr->frame_len)
return -1;
while (len > 0) {
@@ -1971,11 +1649,9 @@ int odp_packet_copy_from_mem(odp_packet_t pkt, uint32_t offset,
const uint8_t *srcaddr = (const uint8_t *)src;
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- if (offset + len > packet_len(pkt_hdr))
+ if (offset + len > pkt_hdr->frame_len)
return -1;
- ODP_ASSERT(odp_packet_unshared_len(pkt) >= offset + len);
-
while (len > 0) {
mapaddr = packet_map(pkt_hdr, offset, &seglen, NULL);
cpylen = len > seglen ? seglen : len;
@@ -2001,12 +1677,10 @@ int odp_packet_copy_from_pkt(odp_packet_t dst, uint32_t dst_offset,
uint32_t src_seglen = 0; /* GCC */
int overlap;
- if (dst_offset + len > packet_len(dst_hdr) ||
- src_offset + len > packet_len(src_hdr))
+ if (dst_offset + len > dst_hdr->frame_len ||
+ src_offset + len > src_hdr->frame_len)
return -1;
- ODP_ASSERT(odp_packet_unshared_len(dst) >= dst_offset + len);
-
overlap = (dst_hdr == src_hdr &&
((dst_offset <= src_offset &&
dst_offset + len >= src_offset) ||
@@ -2090,7 +1764,7 @@ void odp_packet_print(odp_packet_t pkt)
len += snprintf(&str[len], n - len,
" l4_offset %" PRIu32 "\n", hdr->p.l4_offset);
len += snprintf(&str[len], n - len,
- " frame_len %" PRIu32 "\n", packet_len(hdr));
+ " frame_len %" PRIu32 "\n", hdr->frame_len);
len += snprintf(&str[len], n - len,
" input %" PRIu64 "\n",
odp_pktio_to_u64(hdr->input));
commit 3f5d8c5b1f50efe8bf017b8a0014af668c664c43
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:28 2017 +0200
validation: packet: remove non compatible tests
Tests for bad inputs are not compatible to the spec.
Out-of-range values cause undefined results and must not
be tested in validation suite.
Remove reference checks that do not comply anymore to
the new odp_packet_has_ref() specification.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/common_plat/validation/api/packet/packet.c b/test/common_plat/validation/api/packet/packet.c
index f64c599..900c426 100644
--- a/test/common_plat/validation/api/packet/packet.c
+++ b/test/common_plat/validation/api/packet/packet.c
@@ -1877,46 +1877,70 @@ void packet_test_extend_ref(void)
/* Verify ref lengths */
CU_ASSERT(ref != ODP_PACKET_INVALID);
CU_ASSERT(odp_packet_len(ref) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+ if (odp_packet_has_ref(ref) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
- /* And ref's affect on max_pkt */
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 100);
+ /* And ref's affect on max_pkt */
+ CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 100);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(ref) == odp_packet_len(ref));
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) ==
+ odp_packet_len(max_pkt));
+ }
/* Now extend max_pkt and verify effect */
CU_ASSERT(odp_packet_extend_head(&max_pkt, 10, NULL, NULL) >= 0);
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ }
/* Extend on max_pkt should not affect ref */
- CU_ASSERT(odp_packet_has_ref(ref) == 1);
CU_ASSERT(odp_packet_len(ref) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 0);
+ }
/* Now extend ref and verify effect*/
CU_ASSERT(odp_packet_extend_head(&ref, 20, NULL, NULL) >= 0);
CU_ASSERT(odp_packet_len(ref) == max_len - 180);
- CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+ }
/* Extend on ref should not affect max_pkt */
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 90);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 110);
+ }
/* Trunc max_pkt of all unshared len */
- CU_ASSERT(odp_packet_trunc_head(&max_pkt,
- odp_packet_unshared_len(max_pkt),
- NULL, NULL) >= 0);
+ CU_ASSERT(odp_packet_trunc_head(&max_pkt, 110, NULL, NULL) >= 0);
/* Verify effect on max_pkt */
CU_ASSERT(odp_packet_len(max_pkt) == max_len - 200);
- CU_ASSERT(odp_packet_unshared_len(max_pkt) == 0);
- CU_ASSERT(odp_packet_has_ref(max_pkt) == 1);
+
+ if (odp_packet_has_ref(max_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(max_pkt) == 0);
+ }
/* Verify that ref is unchanged */
CU_ASSERT(odp_packet_len(ref) == max_len - 180);
- CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+
+ if (odp_packet_has_ref(ref) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref) == 20);
+ }
/* Free ref and verify that max_pkt is back to being unreferenced */
odp_packet_free(ref);
@@ -2089,37 +2113,42 @@ void packet_test_ref(void)
odp_packet_unshared_len(hdr_pkt[i]));
}
- /* Attempt an invalid ref */
- refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, pkt_len, hdr_pkt[0]);
- CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
-
- /* We can't ref to ourselves */
- refhdr_pkt[0] = odp_packet_ref_pkt(hdr_pkt[0], 0, hdr_pkt[0]);
- CU_ASSERT(refhdr_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(hdr_pkt[0]) == 0);
-
- /* Now create a couple of valid refs */
+ /* Create a couple of refs */
refhdr_pkt[0] = odp_packet_ref_pkt(base_pkt, offset[0], hdr_pkt[0]);
refhdr_pkt[1] = odp_packet_ref_pkt(base_pkt, offset[1], hdr_pkt[1]);
CU_ASSERT(refhdr_pkt[0] != ODP_PACKET_INVALID);
CU_ASSERT(refhdr_pkt[1] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[1]) == 1);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+ /* If base packet has now references, ref packet should be also
+ * references. */
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[1]) == 1);
- /* Verify ref lengths and contents */
- CU_ASSERT(odp_packet_unshared_len(base_pkt) == 0);
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == 0);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) == pkt_len);
+ }
CU_ASSERT(odp_packet_len(refhdr_pkt[0]) ==
hdr_len[0] + pkt_len - offset[0]);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
CU_ASSERT(odp_packet_len(refhdr_pkt[1]) ==
hdr_len[1] + pkt_len - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) == hdr_len[1]);
+
+ if (odp_packet_has_ref(refhdr_pkt[0]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) ==
+ odp_packet_len(refhdr_pkt[0]));
+ }
+
+ if (odp_packet_has_ref(refhdr_pkt[1]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) == hdr_len[1]);
+ } else {
+ CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[1]) ==
+ odp_packet_len(refhdr_pkt[1]));
+ }
packet_compare_offset(refhdr_pkt[0], hdr_len[0],
base_pkt, offset[0],
@@ -2137,23 +2166,16 @@ void packet_test_ref(void)
refhdr_pkt[2] = odp_packet_ref_pkt(refhdr_pkt[0], 2, hdr_cpy);
CU_ASSERT(refhdr_pkt[2] != ODP_PACKET_INVALID);
- if (refhdr_pkt[2] != ODP_PACKET_INVALID) {
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ if (odp_packet_has_ref(refhdr_pkt[2]) == 1) {
CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[2]) == hdr_len[2]);
CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == 2);
-
- /* Free the compound ref and verify we're back to simple ref */
- odp_packet_free(refhdr_pkt[2]);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[0]) == 1);
- CU_ASSERT(odp_packet_unshared_len(refhdr_pkt[0]) == hdr_len[0]);
}
/* Delete the refs */
odp_packet_free(refhdr_pkt[0]);
odp_packet_free(refhdr_pkt[1]);
+ odp_packet_free(refhdr_pkt[2]);
/* Verify that base_pkt no longer has a ref */
CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
@@ -2164,9 +2186,11 @@ void packet_test_ref(void)
CU_ASSERT(hdr_pkt[2] != ODP_PACKET_INVALID);
CU_ASSERT(hdr_pkt[3] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
- CU_ASSERT(odp_packet_has_ref(refhdr_pkt[3]) == 1);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[2]) == 1);
+ CU_ASSERT(odp_packet_has_ref(refhdr_pkt[3]) == 1);
+ }
CU_ASSERT(odp_packet_len(refhdr_pkt[2]) ==
odp_packet_len(refhdr_pkt[3]));
@@ -2185,7 +2209,12 @@ void packet_test_ref(void)
/* Create a static reference */
ref_pkt[0] = odp_packet_ref_static(base_pkt);
CU_ASSERT(ref_pkt[0] != ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(base_pkt) == 1);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
+ }
+
CU_ASSERT(odp_packet_len(ref_pkt[0]) == odp_packet_len(base_pkt));
packet_compare_offset(ref_pkt[0], 0, base_pkt, 0,
odp_packet_len(base_pkt));
@@ -2194,33 +2223,38 @@ void packet_test_ref(void)
odp_packet_free(ref_pkt[0]);
CU_ASSERT(odp_packet_has_ref(base_pkt) == 0);
- /* Create an invalid basic reference */
- ref_pkt[0] = odp_packet_ref(segmented_base_pkt, segmented_pkt_len);
- CU_ASSERT(ref_pkt[0] == ODP_PACKET_INVALID);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 0);
-
- /* Now create valid references */
+ /* Create references */
ref_pkt[0] = odp_packet_ref(segmented_base_pkt, offset[0]);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ }
ref_pkt[1] = odp_packet_ref(segmented_base_pkt, offset[1]);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
- CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_has_ref(segmented_base_pkt) == 1);
+ }
/* Verify reference lengths */
CU_ASSERT(odp_packet_len(ref_pkt[0]) == segmented_pkt_len - offset[0]);
CU_ASSERT(odp_packet_len(ref_pkt[1]) == segmented_pkt_len - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
/* Free the base pkts -- references should still be valid */
odp_packet_free(base_pkt);
odp_packet_free(segmented_base_pkt);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[0]) == 1);
- CU_ASSERT(odp_packet_has_ref(ref_pkt[1]) == 1);
-
packet_compare_offset(ref_pkt[0], 0,
segmented_test_packet, offset[0],
segmented_pkt_len - offset[0]);
@@ -2233,20 +2267,35 @@ void packet_test_ref(void)
hr[1] = odp_packet_headroom(ref_pkt[1]);
CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ }
+
CU_ASSERT(odp_packet_len(ref_pkt[0]) ==
hr[0] + segmented_pkt_len - offset[0]);
CU_ASSERT(odp_packet_pull_head(ref_pkt[0], hr[0] / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0] - (hr[0] / 2));
+
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) ==
+ hr[0] - (hr[0] / 2));
+ }
if (hr[1] > 0) {
CU_ASSERT(odp_packet_push_head(ref_pkt[1], 1) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 1);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 1);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
1 + segmented_pkt_len - offset[1]);
CU_ASSERT(odp_packet_pull_head(ref_pkt[1], 1) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) ==
segmented_pkt_len - offset[1]);
}
@@ -2261,36 +2310,68 @@ void packet_test_ref(void)
CU_ASSERT_FATAL(ref_pkt[1] != ODP_PACKET_INVALID);
ref_len[1] = odp_packet_len(ref_pkt[1]);
CU_ASSERT(ref_len[1] == odp_packet_len(base_pkt) - offset[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
CU_ASSERT(odp_packet_push_head(base_pkt, base_hr / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) == base_hr / 2 + offset[1]);
+
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr / 2 + offset[1]);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
ref_pkt[0] = odp_packet_ref(base_pkt, offset[0]);
CU_ASSERT_FATAL(ref_pkt[0] != ODP_PACKET_INVALID);
ref_len[0] = odp_packet_len(ref_pkt[0]);
CU_ASSERT(ref_len[0] = odp_packet_len(base_pkt) - offset[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
CU_ASSERT(odp_packet_push_head(base_pkt,
base_hr - base_hr / 2) != NULL);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
- base_hr - base_hr / 2 + offset[0]);
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+ }
CU_ASSERT(odp_packet_len(ref_pkt[1]) == ref_len[1]);
CU_ASSERT(odp_packet_len(ref_pkt[0]) == ref_len[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == 0);
+ }
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == 0);
+ }
hr[0] = odp_packet_headroom(ref_pkt[0]);
hr[1] = odp_packet_headroom(ref_pkt[1]);
CU_ASSERT(odp_packet_push_head(ref_pkt[0], hr[0]) != NULL);
CU_ASSERT(odp_packet_push_head(ref_pkt[1], hr[1]) != NULL);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
- CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == hr[1]);
- CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
- base_hr - base_hr / 2 + offset[0]);
+ if (odp_packet_has_ref(ref_pkt[0]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[0]) == hr[0]);
+ }
+ if (odp_packet_has_ref(ref_pkt[1]) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(ref_pkt[1]) == hr[1]);
+ }
+ if (odp_packet_has_ref(base_pkt) == 1) {
+ /* CU_ASSERT needs braces */
+ CU_ASSERT(odp_packet_unshared_len(base_pkt) ==
+ base_hr - base_hr / 2 + offset[0]);
+ }
odp_packet_free(base_pkt);
odp_packet_free(ref_pkt[0]);
commit f72f999552de02c602864baa82bb374322415b24
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Feb 13 14:53:27 2017 +0200
api: packet: references may be implemented as copy
Some implementations may implement new references as packet copy.
odp_packet_has_ref() will return 0 for copies, since those are
unique packets.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/packet.h b/include/odp/api/spec/packet.h
index b6450c1..05ffd68 100644
--- a/include/odp/api/spec/packet.h
+++ b/include/odp/api/spec/packet.h
@@ -892,9 +892,6 @@ odp_packet_t odp_packet_ref_static(odp_packet_t pkt);
* dynamic references must not be mixed. Results are undefined if these
* restrictions are not observed.
*
- * odp_packet_unshared_len() may be used to determine the number of bytes
- * starting at offset zero that are unique to a packet handle.
- *
* The packet handle 'pkt' may itself by a (dynamic) reference to a packet.
*
* If the caller does not intend to modify either the packet or the new
@@ -952,8 +949,9 @@ odp_packet_t odp_packet_ref_pkt(odp_packet_t pkt, uint32_t offset,
* When a packet has multiple references, packet data is divided into two
* parts: unshared and shared. The unshared part always precedes the shared
* part. This call returns number of bytes in the unshared part. When a
- * packet has only a single reference, all packet data is unshared and
- * unshared length equals the packet length (odp_packet_len()).
+ * packet has only a single reference (see odp_packet_has_ref()), all packet
+ * data is unshared and unshared length equals the packet length
+ * (odp_packet_len()).
*
* Application may modify only the unshared part, the rest of the packet data
* must be treated as read only.
@@ -967,8 +965,16 @@ uint32_t odp_packet_unshared_len(odp_packet_t pkt);
/**
* Test if packet has multiple references
*
- * A packet that has multiple references shares data and possibly metadata
- * with other packets. Shared part must be treated as read only.
+ * A packet that has multiple references share data with other packets. In case
+ * of a static reference it also shares metadata. Shared parts must be treated
+ * as read only.
+ *
+ * New references are created with odp_packet_ref_static(), odp_packet_ref() and
+ * odp_packet_ref_pkt() calls. However, some of those calls may implement the
+ * new reference as a packet copy. If a copy is done, the new reference is
+ * actually a new, unique packet and this function returns '0' for it.
+ * When a real reference is created (instead of a copy), this function
+ * returns '1' for both packets (the original packet and the new reference).
*
* @param pkt Packet handle
*
commit 56ee80a8482f1161a84b3e5145fab2e0f7653ccb
Merge: abc36ae 431a078
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Tue Feb 21 15:57:58 2017 +0300
Merge branch 'master' into api-next
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --cc configure.ac
index 0ff6c5a,d344e6a..e4bd3a7
--- a/configure.ac
+++ b/configure.ac
@@@ -53,9 -53,11 +53,11 @@@ AC_PROG_CX
AC_PROG_INSTALL
AC_PROG_MAKE_SET
+ AC_PROG_LN_S
+
AM_PROG_AR
#Use libtool
-LT_INIT([])
+LT_INIT([dlopen])
AC_SUBST([LIBTOOL_DEPS])
AM_PROG_LIBTOOL
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 2 +
include/odp/api/spec/packet.h | 20 +-
platform/linux-generic/Makefile.am | 10 +
.../include/odp_classification_inlines.h | 40 +-
.../linux-generic/include/odp_packet_internal.h | 85 +--
platform/linux-generic/odp_packet.c | 614 ++++++---------------
.../validation/api/classification/classification.h | 2 +
.../classification/odp_classification_test_pmr.c | 224 ++++++++
test/common_plat/validation/api/packet/packet.c | 241 +++++---
9 files changed, 629 insertions(+), 609 deletions(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch master updated. v1.13.0.0-66-g431a078
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 431a0783ebea4fc09e781f431599cacd3a3e4e0e (commit)
from 483cc787d1bec821a2008e32ef4dd611e365ffe4 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 431a0783ebea4fc09e781f431599cacd3a3e4e0e
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Mon Feb 20 18:43:25 2017 +0300
linux-gen: makefile: remove pass command
pass is not bash command and can be not installed.
Change it to dummy ":" bash function.
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index 9b05356..bfcbb5a 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -217,7 +217,7 @@ endif
# specific include path for installed files.
install-data-hook:
if [ -h $(prefix)/include/odp/api/abi ]; then \
- pass \
+ : \
else \
$(LN_S) -rf $(prefix)/include/odp/arch/@ARCH_ABI@/odp/api/abi \
$(prefix)/include/odp/api/abi; \
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/Makefile.am | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch master updated. v1.13.0.0-65-g483cc78
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 483cc787d1bec821a2008e32ef4dd611e365ffe4 (commit)
via de21a1cc01d03c39fd0772dff96fb69b06613f58 (commit)
via 3d6cbd2e2881c1e18922b26c7fd4a2ec9464becd (commit)
from 52f32ce1fa6b5416c59ead45ff27d731d98b8f87 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 483cc787d1bec821a2008e32ef4dd611e365ffe4
Author: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Date: Fri Feb 17 13:41:50 2017 +0530
validation: classification: add test case for outer and inner eth type
Add test case for outer and inner ethernet type packet matching rule
Signed-off-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/common_plat/validation/api/classification/classification.h b/test/common_plat/validation/api/classification/classification.h
index 66e3208..53c527f 100644
--- a/test/common_plat/validation/api/classification/classification.h
+++ b/test/common_plat/validation/api/classification/classification.h
@@ -100,6 +100,8 @@ void classification_test_pmr_term_dmac(void);
void classification_test_pmr_term_packet_len(void);
void classification_test_pmr_term_vlan_id_0(void);
void classification_test_pmr_term_vlan_id_x(void);
+void classification_test_pmr_term_eth_type_0(void);
+void classification_test_pmr_term_eth_type_x(void);
/* test arrays: */
extern odp_testinfo_t classification_suite_basic[];
diff --git a/test/common_plat/validation/api/classification/odp_classification_test_pmr.c b/test/common_plat/validation/api/classification/odp_classification_test_pmr.c
index d01f716..d952420 100644
--- a/test/common_plat/validation/api/classification/odp_classification_test_pmr.c
+++ b/test/common_plat/validation/api/classification/odp_classification_test_pmr.c
@@ -1097,6 +1097,228 @@ void classification_test_pmr_term_vlan_id_x(void)
odp_pktio_close(pktio);
}
+void classification_test_pmr_term_eth_type_0(void)
+{
+ odp_packet_t pkt;
+ uint32_t seqno;
+ uint16_t val;
+ uint16_t mask;
+ int retval;
+ odp_pktio_t pktio;
+ odp_queue_t queue;
+ odp_queue_t retqueue;
+ odp_queue_t default_queue;
+ odp_cos_t default_cos;
+ odp_pool_t default_pool;
+ odp_pool_t pool;
+ odp_pool_t recvpool;
+ odp_pmr_t pmr;
+ odp_cos_t cos;
+ char cosname[ODP_COS_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
+ odp_pmr_param_t pmr_param;
+ odph_ethhdr_t *eth;
+ cls_packet_info_t pkt_info;
+
+ val = 0x88A8;
+ mask = 0xffff;
+ seqno = 0;
+
+ pktio = create_pktio(ODP_QUEUE_TYPE_SCHED, pkt_pool);
+ CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
+ retval = start_pktio(pktio);
+ CU_ASSERT(retval == 0);
+
+ configure_default_cos(pktio, &default_cos,
+ &default_queue, &default_pool);
+
+ queue = queue_create("eth_type_0", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ pool = pool_create("eth_type_0");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ sprintf(cosname, "eth_type_0");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ odp_cls_pmr_param_init(&pmr_param);
+ pmr_param.term = ODP_PMR_ETHTYPE_0;
+ pmr_param.match.value = &val;
+ pmr_param.match.mask = &mask;
+ pmr_param.val_sz = sizeof(val);
+
+ pmr = odp_cls_pmr_create(&pmr_param, 1, default_cos, cos);
+ CU_ASSERT(pmr != ODP_PMR_INVAL);
+
+ pkt_info = default_pkt_info;
+ pkt_info.vlan = true;
+ pkt_info.vlan_qinq = true;
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+ eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
+ odp_pktio_mac_addr(pktio, eth->src.addr, ODPH_ETHADDR_LEN);
+ odp_pktio_mac_addr(pktio, eth->dst.addr, ODPH_ETHADDR_LEN);
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == pool);
+ CU_ASSERT(retqueue == queue);
+ odp_packet_free(pkt);
+
+ /* Other packets delivered to default queue */
+ pkt = create_packet(default_pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+ eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
+ odp_pktio_mac_addr(pktio, eth->src.addr, ODPH_ETHADDR_LEN);
+ odp_pktio_mac_addr(pktio, eth->dst.addr, ODPH_ETHADDR_LEN);
+
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == default_pool);
+ CU_ASSERT(retqueue == default_queue);
+
+ odp_cos_destroy(cos);
+ odp_cos_destroy(default_cos);
+ odp_cls_pmr_destroy(pmr);
+ odp_packet_free(pkt);
+ stop_pktio(pktio);
+ odp_pool_destroy(default_pool);
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
+ odp_queue_destroy(default_queue);
+ odp_pktio_close(pktio);
+}
+
+void classification_test_pmr_term_eth_type_x(void)
+{
+ odp_packet_t pkt;
+ uint32_t seqno;
+ uint16_t val;
+ uint16_t mask;
+ int retval;
+ odp_pktio_t pktio;
+ odp_queue_t queue;
+ odp_queue_t retqueue;
+ odp_queue_t default_queue;
+ odp_cos_t default_cos;
+ odp_pool_t default_pool;
+ odp_pool_t pool;
+ odp_pool_t recvpool;
+ odp_pmr_t pmr;
+ odp_cos_t cos;
+ char cosname[ODP_COS_NAME_LEN];
+ odp_cls_cos_param_t cls_param;
+ odp_pmr_param_t pmr_param;
+ odph_ethhdr_t *eth;
+ odph_vlanhdr_t *vlan_x;
+ cls_packet_info_t pkt_info;
+
+ val = 0x8100;
+ mask = 0xff00;
+ seqno = 0;
+
+ pktio = create_pktio(ODP_QUEUE_TYPE_SCHED, pkt_pool);
+ CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
+ retval = start_pktio(pktio);
+ CU_ASSERT(retval == 0);
+
+ configure_default_cos(pktio, &default_cos,
+ &default_queue, &default_pool);
+
+ queue = queue_create("eth_type_x", true);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+ pool = pool_create("eth_type_x");
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ sprintf(cosname, "eth_type_x");
+ odp_cls_cos_param_init(&cls_param);
+ cls_param.pool = pool;
+ cls_param.queue = queue;
+ cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+ cos = odp_cls_cos_create(cosname, &cls_param);
+ CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+ odp_cls_pmr_param_init(&pmr_param);
+ pmr_param.term = ODP_PMR_ETHTYPE_X;
+ pmr_param.match.value = &val;
+ pmr_param.match.mask = &mask;
+ pmr_param.val_sz = sizeof(val);
+
+ pmr = odp_cls_pmr_create(&pmr_param, 1, default_cos, cos);
+ CU_ASSERT(pmr != ODP_PMR_INVAL);
+
+ /* create packet of payload length 1024 */
+ pkt_info = default_pkt_info;
+ pkt_info.vlan = true;
+ pkt_info.vlan_qinq = true;
+ pkt = create_packet(pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+ eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
+ odp_pktio_mac_addr(pktio, eth->src.addr, ODPH_ETHADDR_LEN);
+ odp_pktio_mac_addr(pktio, eth->dst.addr, ODPH_ETHADDR_LEN);
+ vlan_x = (odph_vlanhdr_t *)(eth + 1);
+ vlan_x->tci = odp_cpu_to_be_16(1024);
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == pool);
+ CU_ASSERT(retqueue == queue);
+ odp_packet_free(pkt);
+
+ /* Other packets delivered to default queue */
+ pkt = create_packet(default_pkt_info);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ seqno = cls_pkt_get_seq(pkt);
+ CU_ASSERT(seqno != TEST_SEQ_INVALID);
+ eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
+ odp_pktio_mac_addr(pktio, eth->src.addr, ODPH_ETHADDR_LEN);
+ odp_pktio_mac_addr(pktio, eth->dst.addr, ODPH_ETHADDR_LEN);
+
+ enqueue_pktio_interface(pkt, pktio);
+
+ pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+ CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+ recvpool = odp_packet_pool(pkt);
+ CU_ASSERT(recvpool == default_pool);
+ CU_ASSERT(retqueue == default_queue);
+
+ odp_cos_destroy(cos);
+ odp_cos_destroy(default_cos);
+ odp_cls_pmr_destroy(pmr);
+ odp_packet_free(pkt);
+ stop_pktio(pktio);
+ odp_pool_destroy(default_pool);
+ odp_pool_destroy(pool);
+ odp_queue_destroy(queue);
+ odp_queue_destroy(default_queue);
+ odp_pktio_close(pktio);
+}
+
static void classification_test_pmr_pool_set(void)
{
odp_packet_t pkt;
@@ -1636,5 +1858,7 @@ odp_testinfo_t classification_suite_pmr[] = {
ODP_TEST_INFO(classification_test_pmr_term_packet_len),
ODP_TEST_INFO(classification_test_pmr_term_vlan_id_0),
ODP_TEST_INFO(classification_test_pmr_term_vlan_id_x),
+ ODP_TEST_INFO(classification_test_pmr_term_eth_type_0),
+ ODP_TEST_INFO(classification_test_pmr_term_eth_type_x),
ODP_TEST_INFO_NULL,
};
commit de21a1cc01d03c39fd0772dff96fb69b06613f58
Author: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Date: Fri Feb 17 13:41:49 2017 +0530
linux-generic: classification: implement eth type packet matching rule
Adds implementation for outer and inner ethernet type packet matching rule
Signed-off-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_classification_inlines.h b/platform/linux-generic/include/odp_classification_inlines.h
index c9517d6..2747db8 100644
--- a/platform/linux-generic/include/odp_classification_inlines.h
+++ b/platform/linux-generic/include/odp_classification_inlines.h
@@ -332,19 +332,43 @@ static inline int verify_pmr_custom_frame(const uint8_t *pkt_addr,
return 0;
}
-static inline int verify_pmr_eth_type_0(const uint8_t *pkt_addr ODP_UNUSED,
- odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
- pmr_term_value_t *term_value ODP_UNUSED)
+static inline int verify_pmr_eth_type_0(const uint8_t *pkt_addr,
+ odp_packet_hdr_t *pkt_hdr,
+ pmr_term_value_t *term_value)
{
- ODP_UNIMPLEMENTED();
+ const _odp_ethhdr_t *eth;
+ uint16_t ethtype;
+
+ if (!pkt_hdr->p.input_flags.vlan_qinq)
+ return 0;
+
+ eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
+ ethtype = odp_be_to_cpu_16(eth->type);
+
+ if (term_value->match.value == (ethtype & term_value->match.mask))
+ return 1;
+
return 0;
}
-static inline int verify_pmr_eth_type_x(const uint8_t *pkt_addr ODP_UNUSED,
- odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
- pmr_term_value_t *term_value ODP_UNUSED)
+static inline int verify_pmr_eth_type_x(const uint8_t *pkt_addr,
+ odp_packet_hdr_t *pkt_hdr,
+ pmr_term_value_t *term_value)
{
- ODP_UNIMPLEMENTED();
+ const _odp_ethhdr_t *eth;
+ uint16_t ethtype;
+ const _odp_vlanhdr_t *vlan;
+
+ if (!pkt_hdr->p.input_flags.vlan_qinq)
+ return 0;
+
+ eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
+ vlan = (const _odp_vlanhdr_t *)(eth + 1);
+ ethtype = odp_be_to_cpu_16(vlan->type);
+
+ if (term_value->match.value == (ethtype & term_value->match.mask))
+ return 1;
+
return 0;
}
#ifdef __cplusplus
commit 3d6cbd2e2881c1e18922b26c7fd4a2ec9464becd
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Sat Feb 18 22:13:10 2017 +0300
linux-gen: do not do double symlinks on make distcheck
Commit:
52f32ce1 linux-gen: abi: add symlink to arch specific dir
Fixed applications compilations for installed odp libs and includes
with adding symlink. But breaks make distcheck which creates that symlink
2 times and fails on second one because is already exist and that dir does
not have write permissions.
Current patch skips symlink creation if it's already exist and repairs
distcheck.
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index 0487028..9b05356 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -216,5 +216,9 @@ endif
# Create symlink for ABI header files. Application does not need to use the arch
# specific include path for installed files.
install-data-hook:
- $(LN_S) -r $(prefix)/include/odp/arch/@ARCH_ABI@/odp/api/abi \
- $(prefix)/include/odp/api/abi
+ if [ -h $(prefix)/include/odp/api/abi ]; then \
+ pass \
+ else \
+ $(LN_S) -rf $(prefix)/include/odp/arch/@ARCH_ABI@/odp/api/abi \
+ $(prefix)/include/odp/api/abi; \
+ fi
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/Makefile.am | 8 +-
.../include/odp_classification_inlines.h | 40 +++-
.../validation/api/classification/classification.h | 2 +
.../classification/odp_classification_test_pmr.c | 224 +++++++++++++++++++++
4 files changed, 264 insertions(+), 10 deletions(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch master updated. v1.13.0.0-62-g52f32ce
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 52f32ce1fa6b5416c59ead45ff27d731d98b8f87 (commit)
from 05f8f96ae606eecfff48e3544885d43b9f541f3c (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 52f32ce1fa6b5416c59ead45ff27d731d98b8f87
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Thu Feb 16 13:48:09 2017 +0200
linux-gen: abi: add symlink to arch specific dir
Added symbolic link to the installed include directory. The link
points to the arch specific abi dir, so that application does
not need to add the arch specific dir into its makefile.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/configure.ac b/configure.ac
index 0280ef1..d344e6a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -53,6 +53,8 @@ AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_MAKE_SET
+AC_PROG_LN_S
+
AM_PROG_AR
#Use libtool
LT_INIT([])
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index 576fedf..0487028 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -212,3 +212,9 @@ __LIB__libodp_linux_la_SOURCES = \
if HAVE_PCAP
__LIB__libodp_linux_la_SOURCES += pktio/pcap.c
endif
+
+# Create symlink for ABI header files. Application does not need to use the arch
+# specific include path for installed files.
+install-data-hook:
+ $(LN_S) -r $(prefix)/include/odp/arch/@ARCH_ABI@/odp/api/abi \
+ $(prefix)/include/odp/api/abi
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 2 ++
platform/linux-generic/Makefile.am | 6 ++++++
2 files changed, 8 insertions(+)
hooks/post-receive
--
8 years, 4 months
- 1
- 0
[COMMIT] branch api-next updated. v1.13.0.0-296-gabc36ae
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, api-next has been updated
via abc36ae6747eb7729ea10ab4fa806939abca8c3e (commit)
via 05f8f96ae606eecfff48e3544885d43b9f541f3c (commit)
via e971043e275307634472b35ce394326216c3e301 (commit)
from cc9544d7d0289f20bf52636b78ec59b22852816c (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit abc36ae6747eb7729ea10ab4fa806939abca8c3e
Merge: cc9544d 05f8f96
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Fri Feb 17 17:05:42 2017 +0300
Merge branch 'master' into api-next
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
-----------------------------------------------------------------------
Summary of changes:
.travis.yml | 4 +++-
CONTRIBUTING | 6 ++++--
2 files changed, 7 insertions(+), 3 deletions(-)
hooks/post-receive
--
8 years, 4 months
- 1
- 0