Глава 22. Отладка, трассировка и оптимизация программ.

22.1. Ошибки и отладка.

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

Если же ваша программа содержит логическую ошибку — например, вы выбрали неправильный алгоритм или неправильно его использовали, — то компилятор может даже не выдать предупреждения. Вроде бы ошибок нет, программа работает, но результат выдает неправильный или в какой-то момент вообще рушится. Мне запомнился один афоризм: «Программа делает то, что вы ей сказали, но не то, что вам хочется». Это и есть самое удачное, на мой взгляд, описание логической ошибки.

Если вы заметили ошибку до того, как ваша программа «увидела свет», то можете считать, что вам повезло. Одно дело, когда программа бесплатная, другое, когда вы за нее получили деньги, а заказчик недоволен... А бывает и такое, что программа может работать один, два месяца и только потом ваша логическая ошибка «всплывает» наружу. Почему это произошло? Дать однозначный ответ сложно, даже когда видишь код программы: все зависит от ее специфики.

Например, если ваша программа использует какую-нибудь СУБД для обработки информации, вы могли установить размер поля меньший, чем нужно. Первые два месяца программа работала отлично, а в один прекрасный момент оператор ввел очень длинную фамилию очень важного клиента, и ваша программа не внесла эту информацию в базу. Но это тривиальная ошибка, и ее можно исправить очень быстро.

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

Какие же ошибки часто совершают начинающие (и не только) программисты? Самая тривиальная — неправильное использование операций инкремента и декремента. Например, следующие выражения не эквивалентны:

X = y++ + 10;

X = ++y + 10;

В первом случае переменной x будет присвоено значение 15, а во втором — 16.

Следующей по частоте является ошибка неучтенной единицы. Например, вам нужен массив, состоящий из 10 элементов, вы его объявляете:

Int а[10];

А затем инициализируете его с помощью цикла:

For (i=0;i<=10;i++) a[i] = 0;

Этот фрагмент кода попытается инициализировать несуществующий элемент — а[10].

Или еще один распространенный случай: программист забывает, что нумерация элементов массива начинается с 0, и не инициализирует первый элемент массива:

For (i=1;i<10;i++) a[i] = 0;

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

1) Неправильное использование операторов * и &. Это самая распространенная группа ошибок начинающих программистов. Вот характерный пример такой ошибки:

/* неправильно */

Char *s;

*s = (char *s)malloc(25);

/* правильно */

Char *s;

S = (char *s)malloc(25);

2) Выделение недостаточного для адресации объекта объема памяти. Например, мы получим такую ошибку, если попытаемся скопировать в строку s (вышеприведенный фрагмент кода) строку, состоящую из 30 символов,

3) Использование неинициализированных указателей. Такие ошибки часто встречаются при работе с динамическими структурами. Например, с линейными списками: вы забыли инициализировать главный элемент (head = NULL) и пытаетесь добавить в список новый элемент.

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

Для облегчения поиска ошибок были созданы специальные программы — отладчики. Одним из самых удачных отладчиков для Linux является gdb (The GNU Debugger). Этот отладчик входит в состав всех распространенных дистрибутивов (за исключением их «урезанных» версий — для рабочих станций), и для его установки достаточно установить пакет gdb.

С помощью gdb вы сможете:

♦ запустить вашу программу с определенными аргументами;

♦ запустить программу в пошаговом режиме;

♦ установить точки останова (breakpoint);

♦ установить условие останова программы;

♦ узнать, что случилось, если программа неожиданно завершилась.

22.2. Отладчик gdb.

Формат вызова отладчика gdb следующий:

Gdb [-help] [-nx] [-q] [-batch] [-cd=dir] [-f] [-b bps] [-tty=dev] [-s symfile] [-e prog] [-sе prog] [-c core] [-x cmds] [-d dir] [prog|core|procID]].

Ключи отладчика описаны в таблице 22.1.

Ключи командной строки gdb Таблица 22.1.

Ключ	Назначение
-help или -h	Вывод краткого описания всех параметров
-nx или -n	Не обрабатывать команды файла инициализации .gdbinit
-q	Не выводить приветствие и информацию об авторских правах
-batch	Командный режим. Отладчик возвращает 0, если были выполнены все команды, указанные в файле, заданном параметром -x (и файле .gdbinit, если его использование разрешено). Если же хотя бы одна из команд не выполнена, возвращается ненулевое значение
-cd=каталог	Установить рабочий каталог (по умолчанию используется текущий каталог)
-f или -fullname	Данная опция нужна, если вы планируете использовать интерфейс текстового процессора Emacs для отладки ваших программ с помощью gdb. Для более подробного описаний обратитесь к справочной системе
-b bps (bits per second)	Установить скорость обмена информацией по последовательному интерфейсу, если вы отлаживаете вашу программу удаленно
-tty=терминал	Установить терминал в качестве стандартного ввода и вывода для отлаживаемой программы.
-s файл или -symbols=файл	Читает таблицу символов из указанного файла
-write	Разрешить запись в исполняемые и core-файлы
-e программа	Использовать указанную программу в качестве фильтра дампа
-se=файл	Читать таблицу символов из указанного файла и использовать указанный файл в качестве исполнимого
-core=файл или -с файл	Указать файл дампа
-command=файл или -x файл	Выполнить указанные в файле команды (используется в командном режиме)
-d каталог	Добавить каталог к списку поиска исходных текстов
[prog|core|procID]	Последний параметр задает объект, который нужно отлаживать. Вы можете задать программу (prog), или дамп-файл (core), который будет создан в случае ошибки программы (Segmentation fault), или же подсоединиться к уже запущенному процессу (procID)
-p PID	Подключиться к уже запущенному процессу (данная опция стала доступной в версии gdb 5.2)

Чтобы использовать gdb для отладки вашей программы, нужно добавить в исполняемый файл отладочную информацию. Для этого откомпилируете вашу программу с опцией -g:

$ gcc -g -o prog prog.c.

Данная опция включает отладочную информацию в родном для операционной системы формате, с которым может работать gdb.

Затем нужно вызвать gdb так:

$ gdb prog.

Если после запуска вашей программы произошла ошибка и был создан дамп-файл (core), можно передать отладчику и этот файл:

$ gdb prog core.

Можно также подключиться к уже запущенному процессу, для этого нужно передать его PID:

$ gdb 1111.

Только убедитесь сначала в том, что у вас нет файла 1111, поскольку gdb сначала ищет исполняемый файл, затем core-файл, а уже затем PID.

После запуска отладчика в интерактивном режиме вы можете использовать команды, самые важные из которых перечислены в таблице 22.2. Об остальных можно узнать в справочной системе: man gdb.

Команды gdb Таблица 22.2.

Команда	Назначение
break [файл:]функция	Установить точку останова
run [аргументы]	Запустить программу и передать ей указанные аргументы
bt	Обратная трассировка: отобразить стек программы
print выражение	Вывести значение выражении, операндами могут быть переменные, объявленные в вашей программа
С	Продолжить выполнение программы (после останова)
Next	Выполнить следующую строку. Это так называемый шаг «над» (step over). Если следующая строка — вызов функции, то мы выполним ее за один шаг — «перешагнем» ее
Step	Выполнить следующую строку, Это так называемый шаг «в» (step into). Если следующая строка — вызов функции, то мы будем последовательно выполнять все операторы тела функции
help [имя]	Вывести справку о команде отладчика или вывести общую информацию о нем
Quit	Выход

В данной таблице приведены далеко не все команды. Если вас интересует более полная информация, обратитесь к руководству по gdb.

22.3. Пример отладки программы.

Давайте напишем программу, которая обнуляет элементы массива a[]. Да, программа ничего полезного не делает, но на ее примере можно продемонстрировать работу с отладчиком gdb.

Вот листинг программы:

Листинг 22.1. Демонстрационная программа, содержащая ошибку.

#include <stdio.h>

Int main() {

 char developer[]="Denis";

 int a[10];

 int i;

 do {

  a[i]=0;

  i++;

 } while (i<10);

 return 0;

}

Назовем нашу программу test.c и откомпилируем ее:

$ gcc -g -o test test.с.

Опция -g добавляет отладочную информацию для отладчика gdb, а опция -o указывает имя результирующего файла.

Просмотрите листинг программы. Программа не делает ничего подозрительного — она всего лишь в цикле do обнуляет все элементы массива — сначала нулевой элемент a[0] становится нулем, потом первый, второй и так далее.

Попробуйте запустить программу, и вы увидите сообщение: Segmentation fault. В чем же причина? Попробуем выяснить ее с помощью отладчика gdb. Запустите отладчик с параметром test (это имя нашего исполняемого файла):

$ gdb test.

В отладчике gdb введем команду run для запуска программы. И что мы видим? Что программа получила сигнал SIGSEGV, то есть имеет место ошибка Segmentation fault. Эта ошибка произошла в строке 12: a[i]=0. Но что может быть опасного в этом операторе? Ошибка Segmentation fault может произойти по нескольким причинам, одной из которых является выход за пределы массива. Проверим это: введите команду print i.

Команда print выводит значение указанной переменной (или выражения). Ого! Оказывается, мы пытаемся обнулить не нулевой элемент массива, а 715910728-ой! Почему же так произошло? Может быть, это gdb нагло врет и вместо значения переменной i выводит непонятно что? Для проверки на лживость введите команду print developer, которая выведет на экран значение переменной developer. С переменной developer все нормально — ее значение «Denis» (рис. 22.1).

Рис. 22.1. Сессия gdb.

Так что же произошло? Так как переменная i не является глобальной, ее значение не обнуляется при запуске программы. Чтобы избежать подобной ошибки, нужно инициализировать переменную при объявлении:

Int i = 0;

Вот мы и нашли ошибку!

Что же еще можно сделать с помощью gdb? Можно установить breakpoint, то есть точку останова, прерывающую выполнение программы в указанном месте. Это нужно для того, чтобы проследить состояние некоторых переменных и/или стека программы перед запуском какой-нибудь функции или же для пошаговой трассировки программы. Для пошаговой трассировки программы установите точку останова для функции main:

Break main.

Для установки точки останова на другую функцию введите команду break и в качестве аргумента укажите имя функции. Теперь запустите программу на выполнение (команда run). Команде run можно передать также аргументы, с которыми должна запускаться программа, например, run /home/denis/report.txt.

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

Для отображения стека программы предназначена команда bt (backtrace). Команда list используется для отображения исходного текста программы (рис. 22.2).

Рис. 22.2. Команда list.

Естественно, весь текст программы не поместится на экране, поэтому отладчик отобразит только его часть. Чтобы еще раз не вводить команду list, просто нажмите Enter, и gdb выполнит предыдущую команду.

Команда help предназначена для отображения справки по командам отладчика, а программа quit — для выхода из него.

Возможности программы gdb этим не ограничиваются. Отладчик gdb — это очень мощная программа, и я советую вам почаще использовать команду help — узнаете много полезного для себя.

Если вам удобнее использовать графический интерфейс, чем символьный, вы можете воспользоваться одним из интерфейсов к программе gdb. Один из них — KDbg. Все, что мы только что проделали с помощью команд отладчика gdb, вы можете сделать, используя меню интерфейса KDbg (рис. 22.3).

Рис. 22.3. Программа KDbg.

Программа KDbg понравилась мне еще тем, что позволяет удобно просматривать регистры, потоки, память, стек и прочее, имеющее непосредственное отношение к процессу отладки. Однако имейте в виду, что интерфейс KDbg сильно ограничивает возможности отладки, потому что позволяет выполнять лишь базовые функции.

Существуют и другие оболочки для отладчика gdb, например, DDD. Эта оболочка обладает чуть большими возможностями, чем KDbg, но все же она является лишь надстройкой над gdb. Оболочек много, a gdb — один. Вы можете выбрать оболочку на свой вкус, а я вообще предпочитаю gdb без всяких оболочек.

Рис. 22.4. Оболочка DDD.

22.4. Трассировка системных вызовов.

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

Проследить, какие системные вызовы использует наша программа, позволяет программа strace. Для ее установки нужно установить пакет strace.

Формат вызова команды strace следующий:

Strace [-dffhiqrtttTvxx] [-acolumn] [-eexpr] ... [-ofile] [-ppid] ... [-sstrsize] [-uusername] [command | arg ...]].

Ключи программы перечислены в таблице 22.3.

Ключи командной строки strace Таблица 22.3.

Ключ	Назначение
-с	Подсчитывать время, затраченное на каждый вызов и обработку ошибок. В конце трассировки будет представлен подробный отчет
-d	Выводить отладочные сообщения самой программы strace на стандартный вывод ошибки
-f	Трассировать дочерние процессы, созданные уже трассируемыми процессами
-ff	Данная опция применятся только вместе с опцией -o имя_файла. Каждый трассируемый процесс будет записан в файл имя_файла.pid
-F	Следовать вызовам vfork(). Данную опцию нельзя использовать вместе с опцией -f
-h	Вывести справку
-i	Выводить указатель инструкции во время системного вызова
-q	«Тихий режим». Подавляет вывод некоторых сообщений
-r	Выводить относительную метку времени для каждого вызова
-t	Перед каждой строкой выводить текущее время
-tt	То же, что и -t, но будут выводиться также микросекунды
-T	Показывать время, потраченное на системный вызов (то есть разницу между временем запуска и временем завершения вызова). Для каждого вызова
-v	Получение дополнительной информации
-V	Вывести номер версии strace
-X	Выводить не-ASCII строки в шестнадцатеричном формате
-XX	Выводить все строки в шестнадцатеричном формате
-a столбец	Выровнять возвращаемые вызовами значения в указанном столбце (по умолчанию 40)
-e выражение	Позволяет задать отслеживаемые события. За более подробной информацией обратитесь к справочной системе
-e trace=набор	Определить набор отслеживаемых вызовов. Например, trace=open,close,read,write
-e trace=file	Будут отслеживаться только вызовы для работы с файлами (open, stat, chmod, unlink и т.д.)
-e trace=process	Отслеживаются вызовы для работы с процессами (fork, exec, wait и др.)
-e trace=network	Отслеживаются сетевые вызовы
-e trace=signal	Отслеживаются вызовы для работы с сигналами
-e trace=ipc	Отслеживаются IPC-вызовы
-e abbrev=набор	Сокращает вывод каждого члена структуры. Например, abbrev=all или abbrev=none
-e verbose=набор	Различать структуры различных системных вызовов, по умолчанию verbose=all
-e raw=set	Выводит не декодированные значения аргументов системных вызовов. Данный аргумент полезен, если вы не доверяете декодированию или хотите знать точное числовое представление аргумента
-e signal=набор	Определяет набор трассируемых сигналов. По умолчанию signal=all. Вы можете использовать восклицательный знак для отрицания, например, signal=!SIGIO означает, что сигнал SIGIO не будет трассирован
-e read=набор	Выполнять полный шестнадцатиричный и ASCII-дамп всех прочитанных вызовом read() данных. Например, чтобы видеть все данные, поступающие через дескрипторы 2 и 7, введите read=2,7
-e write=набор	То же, что и -e read, но только для записи
-o имя_файла	Перенаправить вывод программы в указанный файл. Данный файл будет полезен для дальнейшего анализа трассировки
-p pid	Присоединиться к процессу с PID=pid и начать трассировку
-s размер	Установить максимальный размер строки (по умолчанию 32). Имена файлов не рассматриваются как строки, поэтому всегда будут напечатаны полностью
-S критерий	Сортирует вывод гистограммы, которая выводится опцией -с, по заданному критерию: time (время), calls (вызовы), name (имя) и nothing (без сортировки)
-u имя_пользователя	Запустить программу от имени указанного пользователя. Эта опция будет полезной, если вы, зарегистрировавшись как root, будете проверять корректность работы программы, если бы она была запущена под другим пользователем

Вы даже не можете себе представить, какие системные вызовы использует такая маленькая программка:

Листинг 22.2. Файл prog.с.

#include <stdio.h>

Int main() {

 printf("Hello\n");

 return 0;

}

Откомпилируйте эту программу ( gcc -o prog prog.c) и запустите strace:

$ strace prog.

Вы увидите следующий вывод:

Execve("./a.out", ["./а.out"], [/* 21 vars */]) = 0.

Uname((sys="Linux", node="localhost.localdomain", ...}) = 0.

Brk(0) = 0x80495b4.

Open("/etc/ld.so.preload", O_RDONLY) = -1 ENOENT (No such file or directory).

Open("/etc/ld.so.cache", O_RDONLY) = 7.

Fstat64(7, {st_mode=S_IFREG|0644, st_size=31578, ...}) = 0.

Old_mmap(NULL, 31578, PROT_READ, MAP_PRIVATE, 7, 0) = 0x40014000.

Close(7) = 0.

Open("/lib/i686/libc.so.6", O_RDONLY) =7.

Read(7, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0`u\1В4\0"..., 1024) = 1024.

Fstat64(7, {st_mode=S_IFREG|0755, st_size=1401027, ...}) = 0.

Old_mmap(0x42000000, 1264928, PROT_READ|PROT_EXEC, MAP_PRIVATE, 7, 0) = 0x42000000.

Mprotect(0x4212c000, 36128, PROT_NONE) = 0.

Old_mmap(0x4212c000, 20480, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 7, 0x12c000) = 0x4212c000.

Old_mmap(0x42131000, 15648, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x42131000.

Close(7) = 0.

Munmap(0x40014000, 31578) = 0.

Brk(0) = 0x80495b4.

Brk(0x80495e4) = 0x80495e4.

Brk(0x804a000) = 0x804a000.

Fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0.

Mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40014000.

Write(1, "Hello\n", 6) =6.

Munmap(0x40014000, 4096) = 0.

_exit(0) = ?

Читать вызовы нужно так:

Имя системного вызова = возвращаемое значение.

В нашем случае мы вывели на консоль шесть символов, поэтому вызов write() возвратит значение 6.

В случае, если системный вызов завершился неудачно (обычно код ошибки -1), программа strace выводит не только код, но и описание ошибки:

Open("/foo/bar", O_RDONLY) = -1 ENOENT (No such file or directory).

Стандартные константы выводятся в их символьном представлении:

Open("file.dat", O_WRONLY|O_APPEND|O_CREAT, 0666) = 3.

Сигналы также выводятся в символьном представлении, например:

Sigsuspend([] <unfinished ...>

--- SIGINT (Interrupt) ---

+++ killed by SIGINT +++

Структуры, точнее члены структур, заключаются в фигурные скобки и выводятся в формате имя_члена=значение, например:

Lstat("/dev/null", {st_mode=S_IFCHR|0666, st_rdev=makedev(1, 3), ...}) =0.

Символьные указатели печатаются как строки в С, то есть их значения заключены в двойные кавычки:

Read(3, "root::0:0:System Administrator:/"..., 1024) = 422.

22.5. Оптимизация программ. Профайлер gprof.

Ваша программа работает медленно? Скорее всего, причина кроется в неэффективном, медленном алгоритме. Существуют программы, позволяющие определить время работы каждой функции вашей программы и всей программы в целом. Программы такого рода называются профайлерами. В вашем дистрибутиве может присутствовать один из профайлеров gprof, prof, profiler.

Сейчас мы рассмотрим программу gprof (The GNU Profiler), позволяющую определить время работы каждой функции. Основные ключи программы представлены в таблице 22.3.

Ключи командной строки gprof Таблица 22.3.

Ключ	Назначение
-а	He выводить информацию о статических функциях
-b	Не выводить описание каждого поля в итоговой таблице
-с	Включить эвристический анализ текстового сегмента объектного файла с целью создания статического графика вызовов
-e имя_функции	На выводить отчет о работе указанной функции и обо всех функциях, которые из нее вызываются
-E имя функции	Не обрабатывать указанную функцию и все функции, которые она вызывает
-f имя_функции	выводить информацию только об указанной функции и обо всех функциях, которые из нее вызываются
-F имя_функции	Обрабатывать только указанную функцию и все функции, которые из нее вызываются
-k func1 func2	Не выводить информацию о вызове функции func2 из функции func1
-s	Создание итогового файла gmon.sum
-z	Вывести функции с нулевым процессорным временем

22.5.1. Использование профайлера.

Для использования профайлера нужно скомпилировать программу с опцией компилятора -pg и без опции -о. так как профайлер по умолчанию работает с файлом a.out. После этого запустите файл a .out, чтобы он создал файл gmon.out. Теперь запустите профайлер с параметром --nograph:

$ gcc -pg 1.с.

$ ./а.out.

$ gprof -b –no-graph.

Без ключа -b профайлер выведет описание полей итоговой таблицы:

♦ Time: время работы функции в процентном соотношении;

♦ cumulative seconds: сумма числа секунд этой функции и вызывающих ее функций;

♦ self seconds: число секунд, потраченное на работу этой функции в отдельности;

♦ Calls: число вызовов;

♦ self ms/calls: количество миллисекунд, на протяжении которых функция выполнялась;

♦ total ms/calls: количество секунд, на протяжении которых выполнялась функция и все функции, которые вызываются данной функцией;

♦ name: имя функции.

Рис. 22.5. Программа gprof.

Чтобы было понятно, что означает каждое поле, рассмотрим листинг 22.3.

Листинг 22.3. Демонстрационная программа.

#include <stdio.h>

Int function2() {

 int i;

 /* генерируем задержку */

 for (i=0;i<9999999;i++) ;

 return 777;

}

Double function(void) {

 int i;

 double x = 7.2323232323, y=324343.3434;

 /* генерируем задержку */

 for (i=0;i<9999999;i++) x/y;

 function2();

 return x/y;

}

Int main() {

 int i;

 double l;

 for (i=0;i<10;i++) {

  printf("%d\b",i);

  l=function();

 }

 return 0;

}

Как видно из листинга, функция function() вызывается 10 раз (см. поле calls). В свою очередь, она вызывает функцию function2(), следовательно, число вызовов этой функции тоже равно 10. Функция function() выполняется 1.09 секунд (self seconds), а так как ее никто не вызывает (кроме main), то поле cumulative seconds также равно 1.09. Функция function2() работает 1.07 секунд, но ее вызывает функция function(), которая работает 1.09 секунд. Следовательно, поле cumulative seconds для второй функции равно 1,09+1.07=2.16. Поле self ms/call эквивалентно полю self seconds, только его величина представлена в миллисекундах. Поле total ms/call обратно полю cumulative call и содержит время выполнения этой функции и всех дочерних функций, в то время как поле cumulative call содержит время этой функции и всех родительских.

22.5.2. Как оптимизировать программу.

В качестве оптимизации программы могу вам порекомендовать предпринять следующие действия:

1. Запустите профайлер, и пусть он определит время работы всех функций.

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

3. Когда алгоритм изменить невозможно, можно попытаться переписать часть кода функции на языке ассемблера, если, конечно, это не противоречит идеологии вашей программы (возможно, вы хотите, чтобы она запускалась на как можно большем количестве разных платформ — тут без С не обойтись). Если переработка функции невозможна или помогла мало, то попробуйте оптимизировать программу с помощью опций компилятора. Прежде всего выключите отладочную информацию (не указывайте опцию —g) — и размер программы станет меньше. Используйте одну из опций оптимизации -O.