summaryrefslogtreecommitdiffstats
path: root/documentation/sdk-manual/sdk-intro.xml
blob: 36d946459d0e20f770e72ab94f3f32760b8463c2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd"
[<!ENTITY % poky SYSTEM "../poky.ent"> %poky; ] >

<chapter id='sdk-intro'>
<title>Introduction</title>

<section id='sdk-manual-intro'>
    <title>Introduction</title>

    <para>
        Welcome to the Yocto Project Software Development Kit (SDK)
        Developer's Guide.
        This manual provides information that lets you use both the standard
        Yocto Project SDK and an extensible SDK to develop applications and
        images using the Yocto Project.
        Additionally, the manual also provides information on how to use
        the popular <trademark class='trade'>Eclipse</trademark> IDE as part
        of your application development workflow.
    </para>

    <para>
        Prior to the 2.0 Release of the Yocto Project, application
        development was primarily accomplished through the use of the
        Application Development Toolkit (ADT) and the availability
        of stand-alone cross-development toolchains and other tools.
        With the 2.1 Release of the Yocto Project, application development
        has transitioned to within a more traditional SDK and extensible
        SDK.
    </para>

    <para>
        A standard SDK consists of a cross-development toolchain that contains
        a compiler, debugger, and various miscellaneous tools; libraries,
        headers, and symbols to match an image; and environment setup script.
        You can use this SDK to independently develop and test code that is
        destined to run on some target machine.
    </para>

    <para>
        An extensible SDK consists of everything that the standard SDK has plus
        tools that allow you to easily add new applications and libraries to
        an image, modify the source of an existing component, test changes on
        the target hardware, and easily integrate an application into the
        the Yocto Project build system.
    </para>

    <para>
        Going beyond the actual SDK, the SDK development environment consists
        of the following:
        <itemizedlist>
            <listitem><para>An architecture-specific cross-toolchain and
                matching sysroots (target and native) all built by the
                <ulink url='&YOCTO_DOCS_DEV_URL;#build-system-term'>OpenEmbedded build system</ulink>.
                The toolchain and sysroots are based on a
                <ulink url='&YOCTO_DOCS_DEV_URL;#metadata'>Metadata</ulink>
                configuration and extensions,
                which allows you to cross-develop on the host machine for the
                target hardware.
                </para></listitem>
            <listitem><para>The Quick EMUlator (QEMU), which lets you simulate
                target hardware.
                QEMU is not literally part of the SDK.
                You must build and include this emulator separately.
                However, QEMU plays an important role in the development
                process that revolves around use of and SDK.
                </para></listitem>
            <listitem><para>The Eclipse IDE Yocto Plug-in.
                This plug-in is also available for you if you are an Eclipse
                user.
                In the same manner as QEMU, the plug-in is not literally part
                of the SDK but is rather available for use as part of the
                development process.
                </para></listitem>
            <listitem><para>Various user-space tools that greatly enhance
                your application development experience.
                These tools are also separate from the actual SDK but can be
                independently obtained and used in the development process.
                </para></listitem>
        </itemizedlist>
    </para>

    <section id='the-cross-development-toolchain'>
        <title>The Cross-Development Toolchain</title>

        <para>
            The
            <ulink url='&YOCTO_DOCS_DEV_URL;#cross-development-toolchain'>Cross-Development Toolchain</ulink>
            consists of a cross-compiler, cross-linker, and cross-debugger
            that are used to develop user-space applications for targeted
            hardware.
            This toolchain is created by running a toolchain installer script
            or through a
            <ulink url='&YOCTO_DOCS_DEV_URL;#build-directory'>Build Directory</ulink>
            that is based on your Metadata configuration or extension for
            your targeted device.
            The cross-toolchain works with a matching target sysroot.
        </para>
    </section>

    <section id='sysroot'>
        <title>Sysroots</title>

        <para>
            The native and target sysroots contain needed headers and libraries
            for generating binaries that run on the target architecture.
            The target sysroot is based on the target root filesystem image
            that is built by the OpenEmbedded build system and uses the same
            Metadata configuration used to build the cross-toolchain.
        </para>
    </section>

    <section id='the-qemu-emulator'>
        <title>The QEMU Emulator</title>

        <para>
            The QEMU emulator allows you to simulate your hardware while
            running your application or image.
            QEMU is not part of the SDK but is made available a number of ways:
            <itemizedlist>
                <listitem><para>
                    If you have cloned the <filename>poky</filename> Git
                    repository to create a
                    <ulink url='&YOCTO_DOCS_DEV_URL;#source-directory'>Source Directory</ulink>
                    and you have sourced the environment setup script, QEMU is
                    installed and automatically available.
                    </para></listitem>
                <listitem><para>
                    If you have downloaded a Yocto Project release and unpacked
                    it to create a
                    <ulink url='&YOCTO_DOCS_DEV_URL;#source-directory'>Source Directory</ulink>
                    and you have sourced the environment setup script, QEMU is
                    installed and automatically available.
                    </para></listitem>
                <listitem><para>
                    If you have installed the cross-toolchain tarball and you
                    have sourced the toolchain's setup environment script, QEMU
                    is also installed and automatically available.
                    </para></listitem>
            </itemizedlist>
        </para>
    </section>

    <section id='eclipse-overview'>
        <title>Eclipse Yocto Plug-in</title>

        <para>
            The Eclipse IDE is a popular development environment and it fully
            supports development using the Yocto Project.
            When you install and configure the Eclipse Yocto Project Plug-in
            into the Eclipse IDE, you maximize your Yocto Project experience.
            Installing and configuring the Plug-in results in an environment
            that has extensions specifically designed to let you more easily
            develop software.
            These extensions allow for cross-compilation, deployment, and
            execution of your output into a QEMU emulation session.
            You can also perform cross-debugging and profiling.
            The environment also supports a suite of tools that allows you to
            perform remote profiling, tracing, collection of power data,
            collection of latency data, and collection of performance data.
        </para>

        <para>
            For information about the application development workflow that
            uses the Eclipse IDE and for a detailed example of how to install
            and configure the Eclipse Yocto Project Plug-in, see the
            "<link link='sdk-developing-applications-using-eclipse'>Developing Applications Using <trademark class='trade'>Eclipse</trademark></link>"
            section.
        </para>
    </section>

    <section id='user-space-tools'>
        <title>User-Space Tools</title>

        <para>
            User-space tools are available as part of the SDK development
            process and can be helpful.
            The tools include LatencyTOP, PowerTOP, OProfile, Perf, SystemTap,
            and Lttng-ust.
            These tools are common development tools for the Linux platform.
            <itemizedlist>
                <listitem><para><emphasis>LatencyTOP:</emphasis> LatencyTOP
                    focuses on latency that causes skips in audio, stutters in
                    your desktop experience, or situations that overload your
                    server even when you have plenty of CPU power left.
                    </para></listitem>
                <listitem><para><emphasis>PowerTOP:</emphasis> Helps you
                    determine what software is using the most power.
                    You can find out more about PowerTOP at
                    <ulink url='https://01.org/powertop/'></ulink>.</para></listitem>
                <listitem><para><emphasis>OProfile:</emphasis> A system-wide
                    profiler for Linux systems that is capable of profiling all
                    running code at low overhead.
                    You can find out more about OProfile at
                    <ulink url='http://oprofile.sourceforge.net/about/'></ulink>.
                    For examples on how to setup and use this tool, see the
                    "<ulink url='&YOCTO_DOCS_PROF_URL;#profile-manual-oprofile'>OProfile</ulink>"
                    section in the Yocto Project Profiling and Tracing Manual.
                    </para></listitem>
                <listitem><para><emphasis>Perf:</emphasis> Performance counters
                    for Linux used to keep track of certain types of hardware
                    and software events.
                    For more information on these types of counters see
                    <ulink url='https://perf.wiki.kernel.org/'></ulink>.
                    For examples on how to setup and use this tool, see the
                    "<ulink url='&YOCTO_DOCS_PROF_URL;#profile-manual-perf'>perf</ulink>"
                    section in the Yocto Project Profiling and Tracing Manual.
                    </para></listitem>
                <listitem><para><emphasis>SystemTap:</emphasis> A free software
                    infrastructure that simplifies information gathering about
                    a running Linux system.
                    This information helps you diagnose performance or
                    functional problems.
                    SystemTap is not available as a user-space tool through
                    the Eclipse IDE Yocto Plug-in.
                    See <ulink url='http://sourceware.org/systemtap'></ulink>
                    for more information on SystemTap.
                    For examples on how to setup and use this tool, see the
                    "<ulink url='&YOCTO_DOCS_PROF_URL;#profile-manual-systemtap'>SystemTap</ulink>"
                    section in the Yocto Project Profiling and Tracing Manual.
                    </para></listitem>
                <listitem><para><emphasis>Lttng-ust:</emphasis> A User-space
                    Tracer designed to provide detailed information on
                    user-space activity.
                    See <ulink url='http://lttng.org/ust'></ulink> for more
                    information on Lttng-ust.
                    </para></listitem>
            </itemizedlist>
        </para>
    </section>
</section>

<section id='sdk-development-model'>
    <title>SDK Development Model</title>

    <para>
        Fundamentally, the SDK fits into the development process as follows:
        <imagedata fileref="figures/sdk-environment.png" align="center" width="6in" depth="5in" scalefit="100" />
        The SDK is installed on any machine and can be used to develop
        applications, images, and kernels.
        An SDK can even be used by a QA Engineer or Release Engineer.
        The fundamental concept is that the machine that has the SDK installed
        does not have to be associated with the machine that has the
        Yocto Project installed.
        A developer can independently compile and test an object on their
        machine and then, when the object is ready for integration into an
        image, they can simply make it available to the machine that has the
        the Yocto Project.
        Once the object is available, the image can be rebuilt using the
        Yocto Project to produce the modified image.
    </para>

    <para>
        You just need to follow these general steps:
        <orderedlist>
            <listitem><para><emphasis>Install the SDK for your target hardware:</emphasis>
                For information on how to install the SDK, see the
                "<link url='sdk-installing-the-sdk'>Installing the SDK</link>"
                section.</para></listitem>
            <listitem><para><emphasis>Download the Target Image:</emphasis>
                The Yocto Project supports several target architectures
                and has many pre-built kernel images and root filesystem
                images.</para>
                <para>If you are going to develop your application on
                hardware, go to the
                <ulink url='&YOCTO_MACHINES_DL_URL;'><filename>machines</filename></ulink>
                download area and choose a target machine area
                from which to download the kernel image and root filesystem.
                This download area could have several files in it that
                support development using actual hardware.
                For example, the area might contain
                <filename>.hddimg</filename> files that combine the
                kernel image with the filesystem, boot loaders, and
                so forth.
                Be sure to get the files you need for your particular
                development process.</para>
                <para>If you are going to develop your application and
                then run and test it using the QEMU emulator, go to the
                <ulink url='&YOCTO_QEMU_DL_URL;'><filename>machines/qemu</filename></ulink>
                download area.
                From this area, go down into the directory for your
                target architecture (e.g. <filename>qemux86_64</filename>
                for an <trademark class='registered'>Intel</trademark>-based
                64-bit architecture).
                Download kernel, root filesystem, and any other files you
                need for your process.
                <note>In order to use the root filesystem in QEMU, you
                need to extract it.
                See the
                "<link url='sdk-extracting-the-root-filesystem'>Extracting the Root Filesystem</link>"
                section for information on how to extract the root
                filesystem.</note></para></listitem>
            <listitem><para><emphasis>Develop and Test your
                Application:</emphasis>  At this point, you have the tools
                to develop your application.
                If you need to separately install and use the QEMU
                emulator, you can go to
                <ulink url='http://wiki.qemu.org/Main_Page'>QEMU Home Page</ulink>
                to download and learn about the emulator.
                You can see the
                "<ulink url='&YOCTO_DOCS_DEV_URL;#dev-manual-qemu'>Using the Quick EMUlator (QEMU)</ulink>"
                chapter in the Yocto Project Development Manual
                for information on using QEMU within the Yocto
                Project.</para></listitem>
        </orderedlist>
    </para>

    <para>
        The remainder of this manual describes how to use both the standard
        SDK and the extensible SDK.
        Information also exists in appendix form that describes how you can
        build, install, and modify an SDK.
    </para>
</section>

</chapter>
<!--
vim: expandtab tw=80 ts=4
-->