1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
INSTALLING DPDK USING THE MESON BUILD SYSTEM
---------------------------------------------
NOTE: Compiling and installing DPDK using ``meson`` and ``ninja``, rather
than using ``make`` (GNU make) is EXPERIMENTAL. Official builds of DPDK
should always be done using ``make``, as described in the ``Getting Started
Guide`` documentation, and at "http://core.dpdk.org/doc/quick-start".
Summary
--------
For many platforms, compiling and installing DPDK should work using the
following set of commands::
meson build
cd build
ninja
ninja install
This will compile DPDK in the ``build`` subdirectory, and then install the
resulting libraries, drivers and header files onto the system - generally
in /usr/local. A package-config file, ``libdpdk.pc``, for DPDK will also
be installed to allow ease of compiling and linking with applications.
After installation, to use DPDK, the necessary CFLAG and LDFLAG variables
can be got from pkg-config::
pkg-config --cflags libdpdk
pkg-config --libs libdpdk
More detail on each of these steps can be got from the following sections.
Getting the Tools
------------------
The ``meson`` tool is used to configure a DPDK build. On most Linux
distributions this can be got using the local package management system,
e.g. ``dnf install meson`` or ``apt-get install meson``. If meson is not
available as a suitable package, it can also be installed using the Python
3 ``pip`` tool, e.g. ``pip3 install meson``. Version 0.42 of meson is
recommended - if the version packaged is too old, the latest version is
generally available from "pip".
The other dependency for building is the ``ninja`` tool, which acts similar
to make and performs the actual build using information provided by meson.
Installing meson will, in many cases, also install ninja, but, if not
already installed, it too is generally packaged by most Linux distributions.
If not available as a package, it can be downloaded as source or binary from
https://ninja-build.org/
Configuring the Build
----------------------
To configure a build, run the meson tool, passing the path to the directory
to be used for the build e.g. ``meson build``, as shown above. If calling
meson from somewhere other than the root directory of the DPDK project the
path to the root directory should be passed as the first parameter, and the
build path as the second. For example, to build DPDK in /tmp/dpdk-build::
user@host:/tmp$ meson ~user/dpdk dpdk-build
Meson will then configure the build based on settings in the project's
meson.build files, and by checking the build environment for e.g. compiler
properties or the presence of dependencies, such as libpcap, or openssl
libcrypto libraries. Once done, meson writes a ``build.ninja`` file in the
build directory to be used to do the build itself when ninja is called.
Tuning of the build is possible, both as part of the original meson call,
or subsequently using ``meson configure`` command (``mesonconf`` in some
older versions). Some options, such as ``buildtype``, or ``werror`` are
built into meson, while others, such as ``max_lcores``, or the list of
examples to build, are DPDK-specific. To have a list of all options
available run ``meson configure`` in the build directory.
Examples of adjusting the defaults when doing initial meson configuration.
Project-specific options are passed used -Doption=value::
meson --werror werrorbuild # build with warnings as errors
meson --buildtype=debug debugbuild # build for debugging
meson -Dexamples=l3fwd,l2fwd fwdbuild # build some examples as
# part of the normal DPDK build
meson -Dmax_lcores=8 smallbuild # scale build for smaller systems
meson -Denable_docs=true fullbuild # build and install docs
Examples of setting the same options using meson configure::
meson configure -Dwerror=true
meson configure -Dbuildtype=debug
meson configure -Dexamples=l3fwd,l2fwd
meson configure -Dmax_lcores=8
NOTE: once meson has been run to configure a build in a directory, it
cannot be run again on the same directory. Instead ``meson configure``
should be used to change the build settings within the directory, and when
``ninja`` is called to do the build itself, it will trigger the necessary
re-scan from meson.
As well as those settings taken from ``meson configure``, other options
such as the compiler to use can be passed via environment variables. For
example::
CC=clang meson clang-build
NOTE: for more comprehensive overriding of compilers or other environment
settings, the tools for cross-compilation may be considered. However, for
basic overriding of the compiler etc., the above form works as expected.
Performing the Build
---------------------
Use ``ninja`` to perform the actual build inside the build folder
previously configured. In most cases no arguments are necessary.
Ninja accepts a number of flags which are similar to make. For example, to
call ninja from outside the build folder, you can use ``ninja -C build``.
Ninja also runs parallel builds by default, but you can limit this using
the ``-j`` flag, e.g. ``ninja -j1 -v`` to do the build one step at a time,
printing each command on a new line as it runs.
Installing the Compiled Files
------------------------------
Use ``ninja install`` to install the required DPDK files onto the system.
The install prefix defaults to ``/usr/local`` but can be used as with other
options above. The environment variable ``DESTDIR`` can be used to adjust
the root directory for the install, for example when packaging.
With the base install directory, the individual directories for libraries
and headers are configurable. By default, the following will be the
installed layout::
headers -> /usr/local/include
libraries -> /usr/local/lib64
drivers -> /usr/local/lib64/dpdk/drivers
libdpdk.pc -> /usr/local/lib64/pkgconfig
For the drivers, these will also be symbolically linked into the library
install directory, so that ld.so can find them in cases where one driver may
depend on another, e.g. a NIC PMD depending upon the PCI bus driver. Within
the EAL, the default search path for drivers will be set to the configured
driver install path, so dynamically-linked applications can be run without
having to pass in ``-d /path/to/driver`` options for standard drivers.
Cross Compiling DPDK
--------------------
To cross-compile DPDK on a desired target machine we can use the following
command::
meson cross-build --cross-file <target_machine_configuration>
For example if the target machine is arm64 we can use the following
command::
meson arm-build --cross-file config/arm/arm64_armv8_linuxapp_gcc
where config/arm/arm64_armv8_linuxapp_gcc contains the following
parameters::
[binaries]
c = 'aarch64-linux-gnu-gcc'
cpp = 'aarch64-linux-gnu-cpp'
ar = 'aarch64-linux-gnu-ar'
[host_machine]
system = 'linux'
cpu_family = 'aarch64'
cpu = 'armv8-a'
endian = 'little'
Using the DPDK within an Application
-------------------------------------
To compile and link against DPDK within an application, pkg-config should
be used to query the correct parameters. Examples of this are given in the
makefiles for the example applications included with DPDK. They demonstrate
how to link either against the DPDK shared libraries, or against the static
versions of the same.
From examples/helloworld/Makefile::
PC_FILE := $(shell pkg-config --path libdpdk)
CFLAGS += -O3 $(shell pkg-config --cflags libdpdk)
LDFLAGS_SHARED = $(shell pkg-config --libs libdpdk)
LDFLAGS_STATIC = -Wl,-Bstatic $(shell pkg-config --static --libs libdpdk)
build/$(APP)-shared: $(SRCS-y) Makefile $(PC_FILE) | build
$(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_SHARED)
build/$(APP)-static: $(SRCS-y) Makefile $(PC_FILE) | build
$(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_STATIC)
build:
@mkdir -p $@
NOTE: for --static builds, DPDK needs to be built with Meson >= 0.46 in order to
fully generate the list of private dependencies. If DPDK is built with an older
version of Meson, it might be necessary to manually specify dependencies of DPDK
PMDs/libraries, for example -lmlx5 -lmnl for librte-pmd-mlx5, or the static link
step might fail.
|
