224 |
Глава 13. Скорость |
Так как до определения single? была сделана глобальная inline-декла рация1, использование single? не будет приводить к реальному вызову функции. Если мы определим вызывающую ее функцию так:
(defun foo (x) (single? (bar x)))
то при компиляции foo код single? будет встроен в код foo так, как если бы мы написали:
(defun foo (x)
(let ((lst (bar x)))
(and (consp lst) (null (cdr lst)))))
Существует два ограничения на inline-встраиваемость функции. Ре курсивные функции не могут быть встроены. И если inline-функция переопределяется, должны быть перекомпилированы все другие функ ции, вызывающие ее, иначе в них останется ее старое определение.
Для того чтобы избежать вызовов функций, в некоторых более ранних диалектах Лиспа использовались макросы (см. раздел 10.2). В Common Lisp делать это необязательно.
Различные компиляторы Лиспа отличаются друг от друга возможно стями оптимизации. Чтобы узнать, какая работа реально проделана компилятором, полезно изучить скомпилированный код, который вы можете получить с помощью disassemble. Эта функция принимает функ цию или имя функции и отображает результат ее компиляции, то есть набор машинных инструкций, которые реализуют эту функцию. Даже если дизассемблерный листинг является для вас китайской грамотой, вы можете хотя бы визуально оценить количество сделанных оптими заций: скомпилируйте две версии – с оптимизирующими декларация ми и без них – и просто оцените разницу. С помощью аналогичной мето дики можно выяснить, были ли функции встроены построчно. В любом случае, перед подобными экспериментами убедитесь, что установлены необходимые параметры компиляции для получения максимально бы строго кода.°
13.3. Декларации типов
Если Лисп – не первый язык программирования, с которым вы сталки ваетесь, то вас может удивить, что до сих пор мы ни разу не использова ли то, что совершенно необходимо во многих других языках: деклара ции типов.
В большинстве языков для каждой переменной необходимо определить свой тип, и в дальнейшем переменная может содержать лишь значения этого типа. Такие языки называют языками с сильной типизацией.
1Чтобы inline-декларации были учтены, возможно, понадобится также уста новить параметры компиляции для генерации быстрого кода.
13.3. Декларации типов |
225 |
Такой подход заставляет программиста выполнять лишнюю работу и ограничивает его возможности: вы не можете писать функции, приме нимые к различным типам аргументов, а также хранить в структурах данных разные типы.° Однако преимуществом данного подхода являет ся упрощение задачи компилятора: если он видит функцию, то знает заранее, какие действия нужно совершить.
В разделе 2.15 упоминалось, что Common Lisp использует более гибкий подход, называемый декларативной типизацией (manifest typing).1 Ти пы имеют значения, а не переменные. Последние могут содержать объ екты любых типов.
Если бы мы на этом остановились, то вынуждены были бы платить ско ростью за гибкость. Поскольку функция + может принимать аргументы разных типов, при каждом выполнении она должна затрачивать допол нительное время на выяснение того, с данными каких типов она вызы вается.
Если, например, от функции требуется всего лишь сложение целых чи сел, отказ от ее оптимизации приведет к низкой производительности. Подход к решению данной проблемы в Common Lisp таков: сообщите все, что вам известно. Если вам заранее известно, что вы складываете два числа типа fixnum, то можно объявить их таковыми, и компилятор сгенерирует код целочисленного сложения такой же, как в С.
Таким образом, различие в подходе к оптимизации не приводит к раз нице в плане скорости. Просто первый подход требует всех деклараций типов, а второй – нет. В Common Lisp объявления типов совершенно не обязательны. Они могут ускорить работу программы, но (если, конеч но, они сами корректны) не способны изменить ее поведение.
Глобальные декларации выполняются с помощью declaim, за которой должна следовать хотя бы одна декларационная форма. Декларация типа – это список, содержащий тип символа, сопровождаемый именем типа и именами одной или более переменных. Таким образом, для объ явления типа глобальной переменной достаточно сказать:
(declaim (type fixnum *count*))
ANSI Common Lisp допускает декларации без использования слова type:
(declaim (fixnum *count*))
Локальные декларации выполняются с помощью declare, которая при нимает те же аргументы, что и declaim. Декларации могут начинать лю бое тело кода, в котором появляются новые переменные: defun, lambda,
1Применяемый в Лиспе подход к типизации можно описать двумя способа ми: по месту хранения информации о типах и по месту ее применения. Дек ларативная типизация подразумевает связывание информации о типе с объ ектом данных, а типизация времени выполнения (run-time typing) подразу мевает, что информация о типах используется лишь в процессе выполнения программы. По сути, это одно и то же.
226 |
Глава 13. Скорость |
let, do и другие. К примеру, чтобы сообщить компилятору, что парамет ры функции принадлежат типу fixnum, нужно сказать:
(defun poly (a b x) (declare (fixnum a b x))
(+ (* a (expt x 2)) (* b x)))
Имя переменной в декларации ссылается на переменную, действитель ную в том же контексте, где встречается сама декларация.
Вы можете также задать тип любого выражения в коде с помощью the. Например, если нам известно, что значения a, b и x не только принадле жат типу fixnum, но и достаточно малы, чтобы промежуточные выраже ния также принадлежали типу fixnum, вы можете указать это явно:
(defun poly (a b x) (declare (fixnum a b x))
(the fixnum (+ (the fixnum (* a (the fixnum (expt x 2)))) (the fixnum (* b x)))))
Выглядит довольно неуклюже, не так ли? К счастью, есть две причины, по которым вам редко понадобится шпиговать численный код объявле ниями the. Во-первых, это лучше поручить макросам.° Во-вторых, мно гие реализации используют особые трюки, чтобы ускорить целочислен ную арифметику независимо от деклараций.
В Common Lisp существует невероятное многообразие типов; их набор практически не ограничен, ведь вы можете самостоятельно объявлять собственные типы. Однако явно объявлять типы имеет смысл только в некоторых случаях. Вот два основных правила, когда это стоит делать:
1.Имеет смысл декларировать типы в тех функциях, которые могут работать с аргументами некоторых разных типов (но не всех). Если вам известно, что аргументы вызова функции + всегда будут fixnum или первый аргумент aref всегда будет массивом одного типа, декла рация будет полезной.
2.Обычно имеет смысл декларировать лишь те типы, которые нахо дятся внизу иерархии типов: объявления с fixnum или simple-array будут полезными, а вот декларации integer или sequence не принесут ощутимого результата.
Декларации типов особенно важны при работе со сложными объекта ми, включая массивы, структуры и экземпляры. Такие декларации не только приводят к более быстрому коду, но и позволяют более эффек тивно организовать объекты в памяти.
Если о типе элементов массива ничего неизвестно, то он представляется в памяти как набор указателей. Однако если тип известен и все элемен ты принадлежат к одному типу, скажем double-float, тогда массив мо жет быть представлен как набор чисел в формате double-float. Во-пер вых, такой массив будет более экономно использовать память. Во-вто рых, отсутствие необходимости переходить по указателям приведет к более быстрому чтению и записи элементов.
13.3. Декларации типов |
|
227 |
x = |
|
|
1.234d0 |
2.345d0 |
3.456d0 |
y = |
|
|
1.234d0 |
2.345d0 |
3.456d0 |
Рис. 13.1. Результат задания типа элементов массива |
|
|
Тип массива можно задать с помощью аргумента :element-type в makearray. Такой массив называется специализированным. На рис. 13.1 по казано, что будет происходить в большинстве реализаций при выполне нии следующего кода:
(setf x (vector 1.234d0 2.345d0 3.456d0)
y (make-array 3 :element-type ’double-float) (aref y 0) 1.234d0
(aref y 1) 2.345d0 (aref y 2) 3.456d0)
Каждый прямоугольник на рисунке соответствует машинному слову в памяти. Каждый из двух массивов содержит заголовок неопределен ной длины, за которым следует представление трех элементов. В масси ве x каждый элемент – указатель. В нашем случае все три указателя одновременно ссылаются на элементы double-float, но могут ссылаться на произвольные объекты. В массиве y элементы действительно явля ются числами double-float. Второй вариант работает быстрее и занима ет меньше места, но мы вынуждены платить за это ограничением на од нородность массива.
Заметьте, что для доступа к элементам y мы пользовались aref. Специа лизированный вектор больше не принадлежит типу simple-vector, по этому мы не можем ссылаться на его элементы с помощью svref.
При создании массива в коде, который его использует, необходимо по мимо специализации объявить размерность и тип элемента. Такая дек ларация будет выглядеть следующим образом:
(declare (type (vector fixnum 20) v))
Эта запись говорит о том, что вектор v имеет размерность 20 и специа лизирован для целых чисел типа fixnum.
Наиболее общая декларация включает тип массива, тип элементов и спи сок размерностей:
(declare (type (simple-array fixnum (4 4)) ar))
228 |
Глава 13. Скорость |
Массив ar теперь считается простым массивом 4×4, специализирован ным для fixnum.
На рис. 13.2 показано, как создать массив 1 000×1 000 элементов типа single-float и как написать функцию, суммирующую все его элементы. Массивы располагаются в памяти в построчном порядке (row-major order). Рекомендуется по возможности проходить по элементам масси вов в таком же порядке.
(setf a (make-array ’(1000 1000)
:element-type ’single-float :initial-element 1.0s0))
(defun sum-elts (a)
(declare (type (simple-array single-float (1000 1000)) a))
(let ((sum 0.0s0))
(declare (type single-float sum)) (dotimes (r 1000)
(dotimes (c 1000)
(incf sum (aref a r c))))
sum))
Рис. 13.2. Суммирование по массиву
Чтобы сравнить производительность sum-elts с декларациями и без них, воспользуемся макросом time. Он измеряет время, необходимое для вы числения выражения, причем в разных реализациях результаты его работы отличаются. Его применение имеет смысл только для скомпи лированных функций. Если мы скомпилируем sum-elts с параметрами, обеспечивающими максимально быстрый код, time вернет менее полсе кунды:
> (time (sum-elts a))
User Run Time = 0.43 seconds 1000000.0
Если же мы теперь уберем все декларации и перекомпилируем sum-elts, то те же вычисления займут больше пяти секунд:
> (time (sun-elts a))
User Run Time = 5.17 seconds 1000000.0
Важность деклараций типов, особенно при работе с массивами и отдель ными числами, сложно переоценить. В данном случае две строчки кода обеспечили нам двенадцатикратный прирост производительности.