Как собрать программу из исходников linux

советы

Много лет назад, когда я только начинал пользоваться линуксом, я часто сталкивался с тем, что какой-нибудь нужной или интересной мне программы в моём дистрибутиве не было, или была, но какой-нибудь не той версии.. И тогда надо было собирать её из исходников. Это занятие мне казалось страшным и сложным.

Сейчас такая ситуация случается гораздо реже, благо установка и обновление программ в Debian больше напоминает заказ в ресторане: хочу это, хочу то — подождите — готово! Однако умение собирать программы из исходников рано или поздно пригождается практически любому пользователю свободного программного обеспечения. И сложного в этом ничего нет.

Достаточно один раз в жизни услышать волшебное заклинание: » configure , make , make install «. Дальше я объясню, что это значит.

Сборку программы можно сравнить с выпечкой пирога. Чаще всего, вначале надо взять все необходимые ингридиенты (исходники),
потом смешать их в нужном порядке (подготовить исходники к сборке, ./configure ), а затем залить в форму и поставить в печь (запустить сборку, make ). Спустя некоторое время из печи можно вынимать готовый к употреблению пирог (устанавливать готовую программу, make install ).

Следует отметить, что в данном случае для выпечки необходима кухня и печь. Также и для сборки программы необходимы инструменты разработчика. Обычно это включает в себя как минимум компилятор и сопутствующие ему программы, как например утилита make . Это и есть «печь». Потребуется и место, где можно всем этим заняться — командная строка (терминал) («кухня»). Если у вас есть и кухня, и печь, то можете начинать готовить.

Итак, все свободные программы доступны в виде исходного кода. Это полуфабрикат программы. Из него легко можно собрать саму программу, а можно и использовать для создания какой-нибудь новой программы. По-английски исходный код называется source code.

Шаг 1: берём исходники

Необходимо скачать и распаковать архив с исходным кодом программы. Например, можно скачать программу hello-2.1.1. Обычно исходники следует брать с сайта разработчиков программы.

Распаковать архив можно так:

(Не забывайте, что в большинстве случае нажатие клавиши Tab позволяет дополнить имя файла, введя лишь несколько первых символов). При этом содержимое архива будет распаковано в тот же каталог, в котором находится архив.

Перейдите в каталог с исходным кодом:

Шаг 2: configure (месим тесто)

Прочитайте файлы INSTALL и README , если они есть в архиве исходного кода. В них может содержаться важная информация о том, как устанавливать и использовать программу.

В большинстве случае для подготовки исходников к сборке потребуется выполнить только одну команду:

Она проверит наличие всех необходимых условий (библиотек и других программ) в Вашей системе, и приготовит исходный код к их использованию. Обратите внимание на символы » ./ » в начале команды. Они указывают, что необходимо выполнить команду configure из текущего каталога, то есть команду configure поставляемую вместе с исходным текстом программы, которую мы собираем.

На этом же этапе можно указать и куда именно надо ставить программу. Хотя в большинстве случаев рекомендуется ставить «самосборные» программы в каталог /usr/local , иногда это невозможно. Так, если у пользователя нет прав администратора, например на общественном компьютере, то установить программу можно только в свой домашний каталог. Чтобы установить программу в домашний каталог нужно указать дополнительный параметр команде configure :

Внимательно читайте что пишется на экране при подготовке исходников. Если всё нормально, то закончится она должна чем-нибудь вроде

Если же появляются какие-то сообщения об ошибках, значит чего-то на вашей «кухне» для приготовления этой программы видимо не хватает. Чаще всего какой-нибудь библиотеки. Какой — подскажет вывод программы configure

Шаг 3: make (в печь!)

Если предыдущая стадия закончилась нормально, то теперь можно ставить наш полуфабрикат в печь. То есть запускать процесс сборки программы. Обычно он происходит автоматически и управляется командой make :

Для больших программ этот процесс может занимать довольно много времени. Однако наша программа-пример hello должна собраться быстро.

Если сборка закончилась сообщением вроде этого:

то значит, что-то пошло не так, и сборка не получилась. Однако чаще всего сборка заканчивается без ошибок.

Шаг 4: make install (кушать подано!)

Собственно всё. Пирог можно подавать к столу, а собранную программу устанавливать в систему. Делается это так:

Если на шаге подготовки исходников Вы выбрали вариант установки в домашний каталог (как я), то не забудьте добавить подкаталог

/bin в переменную PATH :

Можете запускать собранную программу:

Она пишет на экран «Здравствуй, мир!». Всё ОК.

Надеюсь, что эти инструкции будут понятны даже совсем начинающим пользователям линукс. Мне в своё время не хватало таких инструкций 🙂

P.S. Хочу, однако, заметить, что сборка из исходников несёт с собой целый ряд неудобств. Первое и наиболее существенное из них — удалять такую программу гораздо хлопотнее. В случае с hello это можно сделать с помощью команды

в каталоге с её исходным кодом, но не всегда этот каталог сохраняется в целостности, да и не все авторы программ должным образом готовят исходные тексты к make uninstall

Поэтому лучше пользоваться готовыми пакетами, поставляемые с Вашим дистрибутивом. Так, чтобы установить программу hello в Debian GNU/Linux достаточно всего одной команды:

Как собрать программу из исходников linux

Разное

Иногда получается что нет нужной программы в репозитории, или на сайте производителя нет сборки под ваш дистрибутив, но позарез нужен именно пакет данной версии, обычно так происходит с новыми релизами. Почему нет их репозиториях описывать не вижу смысла.

Тема собственно родилась по просьбе одного хорошего человека, который попросил вынести в отдельный топик. Буду собирать для примера geany на голом только что установленном дистрибутиве Debian squeeze с Gnome на борту. «Почему geany? Он же есть в репозитории.» — спросите вы. Просто это первая программа которую собрал в linux, так сказать ностальгия.

Readme

Так к чему я это? К тому что обычно пишется «как собрать» в файле Readme или Install, прежде чем делать что-то посмотрите в этот файл, наверняка там написан не только процесс установки, но и зависимости которые нужны для пакета.

Обычно все сводится к выполнению

Скачиваем geany

Можно скачать по ссылке, а можно воспользоваться консольной утилитой wget, если вы не выполняли команду «cd» до этого, то скачается в ваш корневой каталог пользователя /home/user.

Распаковываем

Можно распаковать как угодно, и каким угодно «архиватором», предлагаю сделать это так

Переходим в распакованную директорию

Установка необходимых пакетов для сборки

В дальнейшем ставить уже не надо будет

Сборка классическим make, make install

Конфигурация

Не буду описывать различные префиксы, их можно посмотреть в help, но если вы собираете впервые, то оно вам не нужно.
./configure —help. В большинстве случаев достаточно ./configure без префиксов.

Можно установить все сразу, но буду показывать процесс конфигурации т. к. не всегда очевидны все необходимые пакеты. Этот процесс может занять достаточно много времени, к этому надо быть готовым. Не всегда можно скомпилировать программу под любой дистрибутив т.к. можно упереться в цепь неразрешенных зависимостей, а иногда приходится их тоже собирать.

На данном этапе мы получили сообщение

Гуглим «ошибку» или ищем сразу в репозитории. Тут нужно поставить девелоперский пакет libgtk.

Выполняем поиск и смотрим список

Теперь повторяем опять

В итоге получили сообщение что все гуд, если нет, устанавливаем дальше необходимые пакеты по такому же принципу.

Сборка и установка

Переходим непосредственно к самой сборке, выполнив для компиляции

Получили примерно вот такой лог

Если с ошибкой, значит гуглим ошибку, потом повторяем. Но на этом этапе ошибки возможны как правило только с еще сильно нестабильным софтом, тут скорей всего помочь может только багрепорт разработчику.

Если все хорошо, теперь можно выполнить от root, или с префиксом sudo

Смотрим наш только что установленный редактор

На этом все. Архив tar.gz2 и каталог geany который был извлечен из архива можно удалить, выполнив последовательно

Перейти в корень /home/user

Сборка пакетов для установки при помощи пакетного менеджера

Говорят что после классической установки возможны проблемы с удалением программы. Не знаю, с этим не сталкивался все без проблем удалялось, но не утверждаю что это не имеет место быть.

Для решения этих проблем есть утилита checkinstall которая сначала создает пакет .deb, .rpm, а потом его уже устанавливает. После сборки пакета при помощи checkinstall не желательно давать его кому-то еще, эта утилита сделана исключительно для удобства работы на отдельно взятом компьютере.

Выполняем все то же, что и в классическом варианте, но с некоторыми изменениями.

Сheckinstall

Ставим сначала пакет checkinstall для сборки

Конфигурация

Конфигурируем, устанавливая необходимые пакеты как было выше.

Собираем пакет и устанавливаем

Теперь вместо make install выполняем checkinstall, конечно тоже от root или с префиксом sudo.

Далее нас попросят ответить на несколько вопросов

1. Enter
2. Enter
3. Заполняем, уточню, это не обязательные поля, можно смело пропустить, если пакет больше использоваться не будет.

• [0] Maintainer — пишем ваш email
• [10] Requires — Зависимости пакета, тут нужно указать не девелоперские пакеты (!-dev), в нашем случае это libgtk2.0 для любой другой программы этот список может быть достаточно большим.
  

4. Если решили что все в порядке, продолжаем нажав «Enter». Новый созданный пакет будет лежать в этой же директории, в нашем случае

/geany-0.20, а так же установлен в системе.

NOTE: Для checkinstall мне пришлось поставить еще apt-build т.к. его не было в системе.
FAQ по checkinstall

How to Use make and makefile in Linux

One of the main reasons why Linux is popular among C/C++ programmers is the support provided by Linux to them. This includes the g++ compiler suite and its related tools used for program development such as the make command.

In this tutorial, you will learn about the make command in Linux, its use, the basis of the makefile, and how it is used with the make command.

Table of Contents

What is the make command?

Large and complex software applications consist of hundreds of source code and other files. Compiling and linking these files is not easy and can be erroneous. During the build process of these applications, several object files are also created. To manage these files and the entire software development project, the make command is used in Linux.

Consider the case when the programmers have their projects in simple folders. They don’t have any IDE (Integrated Development Environment) such as Eclipse or Visual Studio available to compile and handle their project. The only available option is to use the terminal to compile the source code. Instead of remembering all the commands to compile their files manually, or keeping track of files that are changed and need to be recompiled, they can simply use the make command to handle things for them automatically.

Instead of performing the compilation steps individually and remembering the file names and commands, the make command can be used to automatically perform these tasks. In short, make allows you to automatically build, compile, execute or even install complex software applications using a single command. Thus, it makes the life of a C/C++ programmer easier.

Makefile

The basis of the make command is a text file called Makefile. The Makefile contains the instructions regarding options passed to the compiler.

Makefile is usually created as a text file without any extension, like this

In this file, you can write a set of commands to perform various tasks. For example,

You can consider Makefile as a simple bash script that contains commands to build, compile, and run your code files. Now if you enter the make command like this

it will execute the instructions (commands) written in the Makefile. In the example given above, it will first compile the main.cpp file and will create an executable file named ‘example_code’, then it will execute the ‘example_code’ file.

In this way, you can write multiple commands in the Makefile and execute them all using the simple make command.

Wait, you might be thinking that a Makefile is just like a simple bash script, so what is the big deal? No, the make command can do more than what you just thought, so keep on reading.

Structure of a Makefile

You can set up several targets in a Makefile, which you can then use with the make command. A target can be specified by writing its name followed by a colon ( : ), for example,

here ‘all’ and ‘run’ are targets. By default, the make command will execute the instructions written after the first target (‘all’ in this case).

If you want to execute instructions written after a specific target, you have to specify its name, for example,

This command will run the executable ‘example_code’, as mentioned after the target ‘run’ in the above example.

File dependency

The other important thing you can specify in a Makefile is file dependency. It means that Makefile can specify the code modules which are required to build the program. In addition, it can also specify the required source code files for a particular code module. Therefore, you can use a Makefile for dependency checking.

In a Makefile, you can specify a dependency after the target name is separated by a space, like this

The above line says that the object file ‘main.o’ has a dependency on ‘main.cpp’. In other words, to execute this target the ‘main.cpp’ must exist.

Using make command to delete files

You can use the make command to delete all object and executable files created during the build process. For that, you have to create a target in the Makefile similar to the example given below.

this target when executed (using $ make clean ) will delete all object files and the executable named ‘example_code’.

The use of variables

You can declare and use variables in a Makefile to represent values that might change. For instance, you can represent the name of the compiler using a variable like this

Suppose you want to change the compiler (say to gcc), then you need to change only this value if you are using a variable. There would be no need to change it in all the occurrences in the Makefile because there the name of the variable is used.

You can see a variable is specified with the help of a $ sign. You can also specify options using variables, like

And then use them as shown below:

Remember before using the make command

• The make command can be used with a simple Makefileor with complex Makefilescontaining several macros or commands. The use of macros with the make command brings application portability. It means the application can be used on other operating systems.
• If no file is specified, the default Makefilewill be used. If you want to use your Makefilethen you have to specify its name using the -f option.

• The make command can also be used to install a program. For that you need to specify a target in the Makefile, mentioning the program and pathname in the install command, like the one shown below:

Now, it is also possible to build and install a program in a single step (i.e., by executing the make command). If you want only installation, you can use the following command.

• If you change any element of a target (such as a source code file), the make command will rebuild the target automatically.

Advantages

Here are some advantages of the make command and the Makefile, which will show you, its importance.

• It makes the codes easier and clearer to read and removes errors from them.
• If you make any changes in the program files, you do not need to compile them again and again. Instead, the make command will automatically compile those files only where changes have been done.
• Makefileis also used to present a project in a more systematic, organized, and efficient way. You can divide a large application program into smaller parts and use the Makefileto handle these smaller parts in different ways.
• Make command allows us to compile multiple files at once so that all the files can be compiled in a single step which is time-efficient as well.
• In the case of compiling multiple files, there is no need to type the names of all the files at the command prompt. Remembering their names is difficult and typing their names can be an error-prone task. So, it is easy to write their names once in the Makefileand let the make command handle everything.

Conclusion

In this tutorial, you have studied the make command and Makefile in detail. The make command is used to manage large development projects comprising of tens of source code files. The Makefile is simply a text file that is being used by the make command to set up targets. It allows us to represent the whole project systematically and efficiently thereby making it easier and more readable to debug.

Name already in use

lor / dump / Сборка-программ.wiki

• Go to file T
• Go to line L
• Copy path
• Copy permalink

• Open with Desktop
• View raw
• Copy raw contents Copy raw contents

Copy raw contents

Copy raw contents

Table of Contents

Зачем мне (не)нужно собирать программу из исходников ?

Для начала задайтесь вопросом, а что Вы собственно хотите получить, собирая программу из исходных кодов? Большинство дистрибутивов являются бинарными, где программы поставляются уже в компилированнои виде и не требуют сборки. То, что отсутствует на установочном диске обычно можно найти в официальных или сторонних репозиториях (хранилищах пакетов), подключение репозитория и установка программы и ее зависимостей возможно сэкономит вам и время и нервы. Мотивацией за сборку может стать — отсутствие программы или ее нужной версии (например Вам нужна старая или самая новая версия) в репозиториях, недостаточное доверие к сторонним репозиториям, необходимость использования специальных возможностей сборки. Мотивацией против — недостаток опыта, времени, необходимость установки -dev пакетов, компилятора и других зависимостей.

Как собрать программу из исходников? Как установить программу из tar.gz/tar.bz2?

Скорее всего в tar.gz/tar.bz2 лежит не программа, а ее исходники. Прежде чем ее поставить, необходимо ее собрать. Для этого нужно выполнить (не бросайтесь сразу это делать):

Поскольку при таком способе установки информация о том, что ставилось и куда, остается только в памяти админа (которая частенько еще какая временная :), лучше для контроля этого процесса использовать checkinstall или похожие программы (почему выше и мы говорили не выполнять команды сразу). После того, как вы, прочитав документацию, установите ее и настроите конфиг, на этапе установки программного обеспечения вместо make install будете писать checkinstall. Checkinstall соберет «настоящий» пакет для указанной (tgz, rpm и deb в зависимости от настроек), установит его в систему и поместит в указанный в конфигурационном файле каталог (удобно для централизованного обновления нескольких машин). Удаление установленных таким образом программ осуществляется стандартными средствами дистрибутива, например, removepkg для Slackware или dpkg для Debian/Ubuntu.

В rpm-based дистрибутивах собирайте программы из srpm или с использованием spec-файлов (для создания rpm). Не превращайте свою систему в помойку. В Slackware программы легко и непринуждённо собираются с помощью простого скрипта SlackBuild. Да и в потомках Debian’a тоже есть штатная система сборки программ в дистрибутивные пакеты и лучше пользоваться ей.

Как удалить программу, собранную из исходников?

Это неоднозначный вопрос. Дело в том, что если вы просто собрали программу с помощью ./configure && make && make install, то все зависит лишь от того, позаботился ли автор об удалении.

Для того, чтобы удалить программу, нужно зайти в каталог ее исходников, из которого она собиралась, и сделать make uninstall. Если каталог не сохранился, распакуйте исходники, запустите ./configure с теми же параметрами, с которыми собирали программу, и выполните make uninstall. А чтобы не полагаться на приличия автора, рекомендуется посмотреть предыдущий вопрос.

Почему после ручной сборки из исходников у программ получается большой размер?

По умолчанию программы собираются с отладочной информацией. Это, соответственно, увеличивает их размер, но на быстродействие и занимаемую оперативную память не влияет.

Можно собрать программу без отладочной информации, указав соответствующий ключ — ./configure —disable-debug

Удалить секции с отладочной информацией из уже собранной программы можно командой strip progfile. Посмотреть, что вышло можно командой file progfile, она напишет — stripped или not stripped.

А можно сделать более правильно:

Что прописать в настройках rpm, чтобы для всех собираемых программ выполнялся strip?

Создаем файл /etc/rpm/macros с таким содержанием:

В будущем при смене версии rpm, не придется ничего править в самих макросах из rpm.

Что делать если configure говорит, что XXX не установлен, а на самом деле он установлен?

Для сборки нужны заголовочные файлы (headers). Во многих дистрибутивах библиотеки и программы поделены на два пакета — foo и foo-devel (Fedora, Mandriva) или foo-dev (Debian, Ubuntu). Соответственно нужно поставить foo-devel (foo-dev). Иногда надо вручную запустить ldconfig чтобы увиделись свежеустановленные библиотеки.

Примечание: в пакетах Slackware почти всё вместе.

Я поставил пакет XXX-dev/XXX-devel, а configure все равно говорит, что XXX не установлен

Бывает так, что configure находит пакет XXX, но при попытке использовать файлы из него (в частности, собрать тестовую программу с заголовочными файлами из пакета) происходит какая-нибудь ошибка. configure не может точно определить, что происходит, и считает, что пакет просто не установлен.

Вам нужно искать информацию о происходящей ошибке в файле config.log. Скорее всего, будут какие-то сообщения об ошибках компилятора при сборке тестовых программ.

Если не разбираетесь в формате этого протокола, посмотрите, какое последнее сообщение об ошибке попало в консоль (обычно от компилятора или линкера, но не о том, как make выходит из директорий), а потом ищите его поиском по тексту в логе. Выше или ниже будет нужная информация.

Как собрать rpm пакет из src.rpm (srpm)?

В зависимости от дистрибутива rpm —rebuild название_пакета.src.rpm или rpmbuild —rebuild название_пакета.src.rpm

Кроме того ALT’овцы рекомендуется не собирать пакеты на работающей системе, а использовать hasher

Если вместо ожидаемого результата, на экран выводится список параметров командной строки, нужно установить rpm-devel. Ну а если все получилось, то пакеты будут лежать в /usr/src/название_дистрибутива/BUILD/название_архитектуры_процессора, например /usr/src/redhat/BUILD/i386.

Помогите собрать ядро

— русское пошаговое описание для новичков — архив параметров ядра, разница между разными версиями

Как собрать ядро из src.rpm? Как собрать собственное ядро из src.rpm?

Поскольку у меня (jackill) Fedora, то рассматривать мы будем именно ядра этого дистрибутива. Для других дистрибутивов чуть-чуть будут отличаться пути в /usr/src и, возможно, названия spec-файлов.

Самый простой случай

Мы скачали пакет вида kernel-2.x.x-1.xxx.src.rpm. Нас устраивает конфигурация по умолчанию, но не устраивает сборка под i386. Поэтому пишем:

и забираем готовый пакет из /usr/src/redhat/RPMS/i686

Собираем собственное ядро

Далее перейдем в каталог /usr/src/redhat/SPECS и распакуем сами исходники, наложив при этом все патчи: Теперь переходим в каталог /usr/src/redhat/BUILD/kernel-2.x/linux-2.6, это исходники ядра с соответствующим конфигом. Здесь выполним две команды: Теперь мы можем выставить желаемые параметры. В качестве помощи можете воспользоваться этим разделом. Я обычно включаю поддержку NTFS, выбираю свой тип процессора, убираю поддержку 4ГБ памяти, ставлю соответствующие параметры для samba, а если машина в домене MS Windows 2003, то добавляю поддержку CIFS, а лишнее убиваю.

После того, как вы закончили выставлять параметры, мы переименовываем наш файл конфигурации .config, например в kernel-2.6.8-i686.config и переписываем в каталог /usr/src/redhat/SOURCES.

Далее в kernel-2.x.spec выставляем какое нам нужно собрать ядро (обычное или smp), нужно ли собирать пакет с исходниками и пакет с документацией:

После делаем как обычно.

Если нужно добавить патч

Накладываем этот патч на распакованные исходники, конфигурируем ядро, переписываем так же получившийся конфиг, затем прописываем патч в kernel.spec (в двух местах: в одном сам патч, например Patch10002: vesafb-tng-0.9-rc4-r3-2.6.9-rc3.patch, во втором способ его наложения, например, Patch10002 -p1 — все увидите и сделаете по аналогии).

Если после этого на сборке ядро вылетает, придется сделать make oldconfig для всех файлов конфигурации (повод научиться писать скрипты ;), или убить все конфиги, кроме нужного вам, после чего повторить сборку.

Правда все просто?

Как накладывать патчи? Как накладывать патчи на ядро? (patch, diff)? Как убирать патчи?

Вообще было бы неплохо просто сделать man patch и все стало бы ясно (кстати, сделайте). А как накладывать патчи на ядро написано в самом README к ядру. Тем не менее.

p1 — уровень. Т.е. я захожу в каталог, где непосредственно находятся нужные мне файлы, копирую туда патч и оттуда запускаю эту команду. p0 — нулевой уровень вложенности

Сжатый патч. Это патчи вида mypatch.gz и mypatch.bz2, соответственно:

Чтобы откатить патч, нужно добавить в команду ключик -R

Или можно проще

Нужно ли накладывать промежуточные патчи на ядро?

Есть ядро версии 2.6.6. Нужно получить ядро 2.6.9. Нужно ли накладывать ли patch-2.6.7 и patch-2.6.8? Нужно.

Есть ядро версии 2.6.17.3. Нужно получить ядро 2.6.17.5. Надо откатится обратно до 2.6.17 (patch -p1 -R) и наложить патч до 2.6.17.5

При сборке ядра make menuconfig ругается, что ncurses не установлен.

Установите ncurses-devel или как он там называется в вашем дистрибутиве.

Зачем собирать модули? Почему бы не сделать монолит?

Монолит хорош только тем, что у атакующего нет возможности подменить модуль своим. На этом плюсы кончаются. Ни скоростью работы, ни чем-либо другим ядро с модулями не отличается от ядра без модулей.

У модулей, однако, есть преимущество. Модулю можно передать параметры. Яркий пример — модуль bttv. В случае монолитного ядра параметр придется передавать через загрузчик. Модули так же можно выгружать.

Как правильно собрать Gnome из исходников?

Можно использовать jhbuild, для старых версий garnome.

Как собрать KDE из исходников?

В первую очередь убедитесь что у Вас установлены достаточно новые версии пакетов Qt , soprano, akonadi, boost , также могут потребоваться (для плазмоидов) Google Gadgets, для графического пакета потребуется exiv2, для pim (почтовый клиент, адресная книга и.т.п) — gpg, gpgme,

Большую часть исходников для предзависимостей КДЕ (KDE4) можно скачать с SVN командой

Также Вам потребуется cmake

Порядок сборки — kdelibs , kdepimlibs , kdebase-runtime , kdebase-workspace , все остальные пакеты можно собирать в произвольном порядке.

собирается достаточно тривиально:

распаковываем пакет

создаем папку для сборки внутри распакованой папки

конфигурируем с помощью cmake , обязательным аргументом является путь к исходникам, в данном случае ..

команда cmake в отличие от ./configure воспринимает параметры в виде -DCMAKE_INSTALL_PREFIX=/usr (например вместо —prefix=/usr), можно также воспользоваться ccmake или cmake-gui

дальше обычная сборка (-j2 — использовать два потока сборки, для четырехъядерных процессоров можно задавать -j4 и так далее)

после чего можно установить собраные программы с помощью

make install или make install DESTDIR=/путь/установки для последующего создания пакета

Что делать если программа не имеет скрипта configure?

Часто бывает так, что исходный код, загруженный из систем контроля версий не содержит скрипта configure. Иногда его нет и в обычных тарболлах, но есть autogen.sh. Запускаем сначала его, а потом при необходимости — ./configure. Если же отсутствует и он, но есть файлы configure.ac, Makefile.am, Makefile.in., то можно сделать так — autoreconf -v —install

Возможно, что программа использует другую систему сборки, например, scons или qmake (в случае qmake в исходниках будут присутствовать файлы .pro). Если используется cmake , то присутствует CMakeLists.txt и конфигурирование осуществляется командой cmake . (путь к исходникам обязателен, в случае если Вы собираете в корне распакованых исходников текущий путь указывается просто точкой, впрочем, некоторые программы Вам это сделать не дадут и попросят создать отдельный каталог.)

Читайте документацию, она рулит, скорее всего всё, что нужно, написано в README.

Я не успеваю прочитать все сообщения на экране. Похоже там какие-то ошибки

Во время компиляции или запуска различных команд на экране быстро появляется множество различных сообщений, ошибок. Их трудно, почти невозможно прочитать, сохранить.

Для решения этой проблемы воспользуйтесь командой «script».

В текущем каталоге появится файл typescript. Он будет содержать все сообщения которые появлялись на экране. Также можно использовать программу tee.

Как запустить, протестировать, посмотреть программу до установки ее в систему ?

Данное решение работает для множества программ, но не для всех.

Программу можно установить в каталог $HOME/usr. Для этого вместо команды «make install» воспользуйтесь командой

Далее нужно изменить файл $HOME/.bash_profile добавив в него эти строки :

После этого вам нужно перелогиниться в систему.

Будет доступен вызов программ, программы смогут найти свои библиотеки, можно будет вызывать их страницы man, info.

Как запустить программу не устанавливая её, сразу же после компиляции ?

Если программа при запуске требует библиотеки из других каталогов, то для этого скомпилированный elf-файл программы и её библиотеки положите в один каталог.

В этой папке создайте такой файл для запуска программы :

Что такое сборка с обратной связью (FDO/PGO/LWP) ?

Современные компиляторы (GCC => 4.3 или Intel C/C++) позволяют использовать автоматическое профилирование (в отличие от ручного (с помощью gprof, например) поиска наиболее интенсивно нагружающих процессор функций и их переписывания более оптимальным образом), такая оптимизация называется оптимизацией с обратной связью (feedback directed optimization — FDO), легковесным профилированием (LWP — lightweight profiling, в отличие от «тяжеловесного» с помощью gprof и переписывания кода), оптимизацией ведомой профилем (PGO — profile guided optimization). Процедура состоит из 3 фаз, одна из которых может являться интерактивной, т.е. требующей действий от пользователя.

Этап 1: Сборка инструментированных бинарных файлов

Используются ключи компилятора -fprofile-gen (GCC) или -prof-gen (ICC) , целевые бинарные файлы будут содержать много служебного кода, который будет использоваться для сбора статистики во время выполнения программы, инструментированные бинарные файлы имеют низкую производительность сгенерированного кода.

Этап 2: Интерактивная фаза сбора статистики

Программа устанавливается обычным образом (или в отдельный префикс) и используется пользователем, во время работы программы собирается статистика промахов в кеш процессора, использования или неиспользования функций, переменных и так далее. В эту фазу важно постараться использовать программу максимальным образом, например и кодирование и декодирование разных форматов в случае с медиа кодеками, компрессию и декомпрессию с разными опцииями в случае архиваторов, использовать все пункты в меню и открыть все типы документов в случае программы с графическим интерфейсом, для неиспользованных функций информация по профилю собрана не будет. Файлы статистики обычно пишутся в каталог с файлами исходного кода или можно (например для Gentoo portage, при использовании стандартых ebuild’ов) задавать каталог с помощью ключей -fprofile-dir=путь (GCC) или -prof-dir путь (для ICC) на первом этапе.

Этап 3: Пересборка программы с учетом собранной статистики

Производится очистка собраных объектных файлов и пересборка с использованием собраной статистики, используются ключи компилятора -fprofile-use (GCC) или -prof-use (ICC), результирующие бинарные файлы обычно имеют максимально достигаемую с помощью опций компилятора оптимизацию под процессор. В случае с Mozilla Firefox 3.6 оптимизация сборкой под процессор Intel Pentium IV повышает производительность в тестах Peacekeeper на 10%, в случае использования FDO получаем еще 10%, т.е. суммарное ускорение по тестам достигает 20%, неплохой результат не так ли?

Что говорит против использования FDO для сборки программ ?

Сборка длительна и трудоемка, возможно требует активных действий от пользователя.

GCC достаточно плохо реагирует на коллизии в статистике возникающие при многопоточности (или просто нескольких одновременных запусках) программы.

И наконец, какой ужас! Собранные бинарные файлы будут привязаны к типу процессора (конвееру, размеру кешей, конкретным ключам сборки, например -mfpmath=sse) , что может проявиться снижением производительности на других процессорах, особенно с меньшим кешем, типом конвеера (in order execution на Intel Atom например), что существенно ограничивает распространение собранных данным методом программ.

Многие алгоритмы уже были отпрофилированы авторами кода вручную, и некоторые даже переписаны на язык assembler, поэтому не удивляйтесь , если потратив уйму времени на профилирование вашего любимого медиа-кодека вы получите прирост менее 1% .

Какие пакеты поддерживают легкую сборку с профилированием?

Mozilla Firefox (make profiledbuild), существует также PKGBUILD для Arch Linux и (в багзилле) ebuild для Gentoo

x264 (make fprofiled VIDS=»список файлов») интерактивная фаза тут не требует вмешательства пользователя,кодек будет отпрофилирован на указанных пользователем файлах с использованием различных настроек кодирования и декодирования.

GCC (make profiledbootstrap) в процессе сборки GCC будет собран backend компилирующий код на C на 7% быстрее , чем без профилирования (для ветки 4.5 пока не работает)

Другие пакеты вам придется собирать по описанной выше трехэтапной схеме, вручную меняя CFLAGS, CXXFLAGS

Как на 64-битной ОС собирать для 32-битной ?

Обмануть автоматическое определение архитектуры помогает утилита setarch, вызвать ее можно как i386 для установления 32-битности ОС. После вызова нужно заново задать переменные окружения, не забудьте и про добавление -m32 в флаги компилятора , а также другие значения, например —libdir=/usr/lib32 для ./configure (если ваша система содержит 32 битные библиотеки в /lib32)