ARM64 и Ты

в 2:36, , рубрики: a7, AArch64, arm64, iOS, objective-c, Процессоры, разработка под iOS

Несколько запоздалый перевод заинтересовавшего меня блогпоста о том, что в действительности дает 64-битность процессора в iPhone без маркетинговой шелухи. Если текст покажется вам слишком очевидным, пропустите часть «Базовые преимущества и недостатки».

Как только был анонсирован iPhone 5S, технические медия были переполнены недостоверными статьями. К сожалению, написание хороших статей занимает время, а мир технической журналистики больше ценит скорость, чем достоверность. Сегодня, по просьбе нескольких своих читателей, я кратко изложу, что дает 64-bit ARM в iPhone 5S в плане производительности, возможностей и разработки.

64 бита

Давайте для начала рассмотрим что, собственно, 64-битность означает. С этим термином связанно много путаницы, в основном из-за того, что нет единого устоявшегося определения. Однако, существует общие понимание этого термина. «Битность» обычно означает либо размер числового регистра, или размер указателя. К счастью, для большинства современных процессоров, их размер совпадает. Таким образом, 64-битность означает что процессор обладает 64-битными числовыми регистрами и 64-битными указателями.

Важно также отметить, что 64-битность не означает, т.к. и здесь есть много недопонимания. Итак, 64-битность не определяет:

  1. Размер адресуемой памяти. Количество бит, реально задействованных в указателе на связано с битностью процессора. Процессоры ARM использует от 26 до 40 бит, и это число может изменяться в отрыве от битности процессора.
  2. Ширину шины данных. Объем данных, запрашиваемых из RAM или кэша также не связано с битностью. Отдельные процессорные инструкции могут запрашивать произвольные объемы данных, но объем реально единовременно запрашиваемых данных может отличаться, либо разбивая запросы на части, или запрашивая больше чем необходимо. Уже в iPhone 5 размер запрашиваемого блока данных составляет 64 бита, а у PC доходит до 192 бит.
  3. Все что связано с вычислениями с плавающей запятой. Регистры FPU не связанны с архитектурой и процессоры ARM использовали 64-битные регистры задолго до ARM64.

Базовые преимущества и недостатки

Если вы будете сравнивать идентичные процессоры 32 и 64 битные CPU, вы не найдет больших различий, так что значительность перехода Apple на 64-битные ARM несколько преувеличена. Это важный шаг, но важный, в основном, из-за особенностей ARM и особенностью использования процессора компанией Apple. Тем не менее, некоторые различия имеются. Самым очевидным является 64-битные числовые регистры более эффективно работают с 64-битными числами. Вы можете работать с 64-битными числами и на 32-битном процессоре, но это обычно приводит к работе с двумя 32-битными частями, что работает ощутимо медленнее. 64-битные процессоры, обычно, выполняют операции над 64-битными числами также быстро как и над 32-битными, так что код активно использующий вычисления с 64-битными числами будет работать значительно быстрее.

Не смотря на то, что 64-битность не связана напрямую с объемом адресуемой памяти, она значительно облегчает использование большого объема RAM в рамках одной программы. Программа, запущенная на 32-битном процессоре может адресовать не больше 4GB адресного пространства. Часть памяти выделена под операционную систему и стандартные библиотеки, что оставляет 1-3GB на саму программу. Если у 32-битной системы больше 4GB RAM, то использование всего этого адресного пространства для программы значительно усложняется. Вам придется заняться махинациями вроде последовательного отображение разных частей RAM на часть виртуального адресного пространства или разбивание одной программы на несколько процессов.

Подобные трюки крайне трудозатраны и могут сильно замедлить систему, так что мало кто из программистов реально их использует. На практике, на 32-битных процессорах каждая программа используют до 1-3GB RAM, а вся ценность в обладании большего объема физической оперативной памяти заключается в возможности больше запускать программ одновременно и возможность кеширования больше данных с диска.

Увеличение объема адресного пространства полезно и для систем с небольшим объемом оперативной памяти — memory-mapped файлы, размеры которых могут быть  и больше доступной оперативной памяти, т.к. операционная система реально загружает только те части файла, к которым производились обращения и, кроме того, умеет «вытеснять» загруженные данные обратно в файл, освобождая оперативную память. На 32-битных системах нельзя отобразить файлы размером больше 1-3GB. На 64-битных системах, адресное пространство значительно больше, так что такой проблемы нет.

Увеличение размера указателя может быть и ощутимым минусом: таже программа будет использовать больше памяти (возможно, сильно больше) будучи запущенной на 64 битном процессоре. Увеличение используемой памяти также «забивает» кэш, что снижает производительность.

В двух словах: 64-битность может увеличить производительность некоторых частей года и упрощает некоторые техники, вроде memory-mapped файлов. Однако, производительность может и пострадать из-за увеличения используемой памяти.

ARM64

64-битнй процессора в iPhone 5S не просто ARM с увеличенным размером регистром, есть и существенные изменения.

Во-первых, отмечу название: официального название от ARM — «AArch64», однако это — глупое название, печатать которое меня раздражает. Apple называет архитектуру ARM64 и я буду называть также.

ARM64 увеличил в двое число целочисленных регистров. 32-битный ARM предоставляет 16 целочисленных регистров, из которых один — счетчик команд (program counter), еще два используются для указателя на стэк и регистра связи (link register) и 13 регистров общего назначение. В ARM64 32 целочисленных регистра, с выделенным нулевым регистром, регистром связи и регистром указателя кадра (frame pointer register). Еще один регистр зарезервирован платформой, что оставляет 28 регистров общего назначения.

ARM64 также увеличивает число регистров для чисел с плавающей запятой. Регистры в 32-битных ARM несколько странные, так что сложно сравнивать. У 32-битного ARM 32 32-битных регистров с плавающей запятой, которые могут быть представлены как 16 перекрывающихся 64-битных регистров. Кроме того, есть еще 16 независимых 64-битных регистров. ARM64 упрощает это до 32 неперекрывающихся 128-битных регистров, которые могут быть использован для данных меньшего размера.

Число регистров может значительно влиять на производительность. Память значительно медленнее процессора, и чтение/запись памяти занимает значительно больше времени, чем выполнение инструкций процессора. Процессор пытается исправить это при помощи кэшей, но даже самый быстрый кэш значительно медленнее регистров процессора. Больше регистров — больше данных могут храниться внутри процессора. Насколько это влияет на производительность зависит от конкретного кода и эффективности компилятора, который оптимизирует использование регистров. Когда архитектура Intel перешла от 32 к 64 битам, число регистров увеличилось с 8 до 16, и это было значительное изменение производительности. У ARM уже было больше регистров чем у 32-битной архитектуры Intel, так что увеличение регистров хоть  и меньше повлияет на производительность, но это изменение все еще будет заметно.

ARM64 также привнес существенные изменения помимо увеличения числа регистров.

Большинство 32-битных инструкций ARM могут выполняться/не выполняться в зависимости от состояние регистра-условия. Это позволяет транслировать условные выражения (if-statements) без использования ветвления. Предполагалось, что это увеличит  производительность, однако, судя по тому, что в ARM64 от этой возможности отказались, она порождала больше проблем, чем давала пользы.

В ARM64 набор SIMD (одна-инструкция-много-данных) NEON полностью поддерживает стандарт IEEE754 для чисел с плавающей запятой с двойной точностью, в то время как 32-битная версия NEON поддерживала только одинарную точность и не в точности следовала стандарту для некоторых битов.

В ARM64 добавили специализированные инструкции для AES шифрования и SHA-1 & SHA-256 хешей. Не слишком полезное в общем, однако существенный бонус если вы занимаетесь именно этими вопросами.

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

Совместимость с 32-битным приложениями

Важно отметить, что A7 включает в себя 32-битный режим совместимости, который позволяет запускать 32-битные приложения без каких либо изменений. Это означает, что iPhone 5S может исполнять любые старые приложения без какого-то влияния на производительность.

Изменения в системе периода исполнения

Apple использует преимущества новой архитектуры в своих библиотеках. Так как им нет надобности беспокоиться об бинарной обратной совместимости при таких изменениях, это отличное время чтобы внести изменения которые в противном случае «поломали» уже существующие приложения.

В Max OS X 10.7 Apple ввела меченные указатели (tagged pointers). Меченные указатели позволяют хранить некоторые классы с небольшим количеством данных в экземпляре напрямую в указателе. Это позволяет избежать выделений памяти в некоторых случаях, например NSNumber и может дать существенный прирост производительности. Меченные указатели поддерживаются только на 64-битной платформе, частично из-за вопроса производительности, а частично из-за того что в 32-битном указателе не так много остается места под «метки». Видимо по-этому, у iOS не было поддержки меченных указателей. Таким образом, в ARM64 в рантайме Objective-C включена поддержка меченных указателей, что дает те же преимущества, что в Mac.

Не смотря на то, что размер указателя составляет 64 бита, не все эти биты на самом деле используются. В Mac OS X на x86-64 используется только 47 битов. В iOS на ARM64 используется еще меньше — только 33 бита. Если маскировать эти биты каждый раз перед использованием то можно использовать остальные биты чтобы хранить дополнительные данные. Это позволило внести одно из самых значительных изменений в рантайм Objective-C за всю его историю.

Переосмысленние укозателя isa

Большая часть информации в этой секции почерпана из статьи Грега Паркера. Во первых, для освежения памяти: объекты в Objective-C представляют выделенные блоки памяти. Первый часть, размером с указатель, это isa. Обычно, isa это указатель на класс объекта. Чтобы узнать больше о том, как объекты хранятся  в памяти, читайте мою другую статью.

Использовать весь размер указателя на указатель isa несколько расточительно, особенно на 64-битной платформе, которая не использует все 64-бита. ARM64 на iOS реально использует 33 бита, оставляя 31 бит для других вещей. Классы в памяти выровнены по границе 8 байт, так что последние 3 бита можно отбросить, что дает 34 бита из isa доступные для хранения дополнительной информации. И Apple-овский рантайм в ARM64 использует это для повышения производительности.

Наверно, самой важной оптимизацией стало встраивание (inline) счетчика ссылок. Практически все объекты в Objective-C обладают счетчиком ссылок (за исключение неизменяемых объектов, таких как литералы NSString) и операции retain/release, которые меняют этот счетчик случаются очень часто. Это особенно критично для ARC, который вставляет вызовы retain/release чаще, чем бы это делал программист. Таким образом, высокая производительность retain/release методов крайне важна.

Обычно, счетчик ссылок не хранится в самом объекте. Можно было бы хранить счетчик ссылок в самом объекте, но это заняло бы слишком много места. Это не так важно сейчас, но тогда, давно, это было весьма существенно. Из-за этого, счетчик ссылок хранится во внешней хеш-таблице. Каждый раз при вызове retain, производятся следующие действия:

  1. Получить глобальную хещ-таблицу счетчиков указателей
  2. Заблокировать хеш-таблицу, чтобы операция была потокобезопасной
  3. Найти в хеш-таблице счетчик для заданного объекта
  4. Увеличить счетчик на один и сохранить его обратно в таблицу
  5. Отпустить блокировку хеш-таблицы

Достаточно медленно! Реализация хеш-таблицы счетчиков сделана очень эффективной, для хеш-таблицы, но это все еще значительно медленнее прямого доступа к памяти. В ARM64, 19 бит указателя isa используются для хранения счетчика ссылок. Это означает, что вызов retain упрощается до:

  1. Произвести атомарное увеличение части isa-поля

И все! Это должно быть гораздо, гораздо быстрее.

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

  1. Последний бит в isa говорит, используются ли дополнительные биты в isa для хранения счетчика ссылок. Если нет, используется старый алгоритм с хеш-таблицами.
  2. Если объект уже удаляется, ничего не выполняется
  3. Если счетчик переполняется (что случается редко, но вполне возможно при 19 битах), используется старый алгоритм с хеш-таблицей
  4. Произвести атомарное изменение isa на новое значение

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

Использование оставшихся неиспользованных под счётчик ссылок биты в isa позволило ускорить деаллокацию объектов. Теоретически, нужно совершить кучу действий когда объект в Objective-C удаляется и возможность пропустить ненужные может значительно увеличить производительность.  Эти шаги:

  1. Если у объекта не было ассоциированных объектов, установленных используя objc_setAssociatedObject, их не надо удалять.
  2. Если объект не обладает C++-деструктором (который вызывается при dealloc), его тоже не нужно вызывать.
  3. Если на объект ни разу не ссылались слабым (__weak) указателем, то эти указатели не надо обнулять.

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

Суммарно, это существенный выигрыш. Мои бенчмарки показали, что создание и удаление простого объекта  занимает 380нс на 5S в  32-битном режиме, в то время как в 64-битном только 200нс. Если хоть один экземпляр когда-либо имел слабую ссылку на себя, то в 32-битном режим время удаления для всех увеличивалось до 480нс, в то время как в 64-битном режиме время не осталось в районе 200нс для всех экземпляров, на которых слабых ссылок не было.

Короче говоря, улучшения в рантайме таковы, что в 64-битном режиме время аллокации занимают 40-50% от времени аллокации в 32-битном режиме. Если ваше приложение создает и удаляет много объектов, это может оказаться существенным.

Заключение

64-битность A7 не просто маркетинговая уловка, но это и не поражающий воображение прорыв который позволит создавать новый класс приложений. Истина, как всегда, лежит посередине.

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

Архитектура ARM изменилась не только в 64-битности. Увеличенное число регистров и пересмотренный, модернизированный набор инструкций дает неплохой прирост производительности по сравнению с 32-битным ARM.

Apple использовала переход на новую архитектуру для улучшения в рантайме. Основное изменение — встраиваемый (inlined) счетчик ссылок, который позволяет избежать дорогого поиска по хеш-таблице. Так операции retain/release очень часты в Objective-C, это существенный выигрыш. Удаление ресурсов в зависимости от флагов делает удаление объектов почти вдвое быстрее. Меченные (tagged) указатели также добавляют производительность и уменьшают потребление памяти.

AMD64 — приятное добавление от Apple. Мы все знали, что это рано или поздно случится, но мало кто ожидал что так скоро. Но оно есть, и это отлично.

Автор: meta4

Источник

Поделиться

* - обязательные к заполнению поля