Введение

Камера Intel® RealSense™ SR300— последняя модель камеры переднего обзора в нашей линейке продуктов. В камерах SR300 реализован целый ряд новых и улучшенных возможностей по сравнению с камерами первого поколения Intel® RealSense™ F200. В модели SR300 дальность действия камеры увеличена до 1,5 м и поддерживается запись динамичного движения, повышена точность данных глубины, снижен расход электроэнергии, повышено качество и стабильность программного обеспечения. В камерах SR300 улучшена поддержка Skype*. Разрешение составляет 1080p FullHD при скорости 30 кадров в секунду или 720p при скорости 60 кадров в секунду. SR300 поддерживает приложения, разработанные для камеры Intel® RealSense™ F200, и работу с цветным изображением. В Intel® RealSense™ SDKдобавлен новый трехмерный режим Cursor, улучшена сегментация фона и функция трехмерного сканирования объектов для камеры SR300. В статье Сравнение камер переднего обзора Intel® RealSense™ SR300 и F200перечислены различия между моделями SR300 и F200 и доводы в пользу перехода на SR300.

Рисунок 1.Камера SR300

Размеры камеры SR300 составляют 110 x 12,6 x 3,8–4,1 мм, вес — 9,4 г. Благодаря компактному размеру и малому весу камеру можно устанавливать на крышку мобильного устройства или на монитор настольного ПК, получая стабильную видеосъемку. В 2016 году камера SR300 будет встраиваться в различные устройства, включая ПК, моноблоки, ноутбуки и трансформеры. Камера SR300 может использовать Intel RealSense SDK для Windows или ПО librealsense. Поддержка камер SR300 добавлена в SDK версии 2016 R1 и более поздних версий.

Новые и улучшенные возможности

• Режим Cursor
• Отслеживание человека

• Повышенная дальность и боковая скорость
• Повышенное качество цветопередачи при съемке с недостаточным освещением, улучшенные трехмерные текстуры для трехмерного сканирования
• Улучшенная синхронизация потоков цветного изображения и глубины
• Пониженное потребление электроэнергии

См. страницу Сравнение камер переднего обзора Intel® RealSense™ SR300 и F200для получения дополнительных сведений об ускоренном режиме VGA и других новых и улучшенных возможностях.

Дополнительные функции Intel® RealSense™ SDK, запланированные для камеры SR300

В дальнейших выпусках Intel® RealSense™ SDK будут реализованы новые и обновленные возможности: автоматическое определение расстояния, режим расширенного динамического диапазона и карта достоверности.

Запланировано на вторую половину 2016 года

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

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

Режим расширенного динамического диапазона (HDR)

В этом режиме расширяется динамический диапазон изображения. Динамический диапазон — это соотношение между самой светлой и самой темной областями изображения. При включенном режиме HDR повышается детализация изображений. Режим HDR полезно использовать при съемке в условиях недостаточного освещения или при съемке против света. При этом сохраняется достаточная кадровая скорость.

При включенном режиме HDR на изображении повышается детализация волос при обычном освещении и с подсветкой.

Рисунок 2. Больше данных о волосах

Рисунок 3. Улучшенное распознавание освещенных волос

В режиме расширенного динамического диапазона повышается точность распознавания в сложных случаях, например когда черный объект переднего плана находится на черном фоне. За счет этого повышается качество сегментации фона (BGS). Режим расширенного динамического диапазона будет доступен только для сегментации фона, его пока нельзя будет использовать одновременно с другими компонентами. Дополнительные сведения будут доступны в следующей версии Intel RealSense SDK.

Рисунок 4. Черные волосы на черном фоне

Карта достоверности

Функция карты достоверности выдает значения достоверности для карты глубины в диапазоне от 0 до 15. При малых значениях (0–4) обеспечивается более точное измерение глубины, большие значения можно использовать для сегментации объектов BLOB, обнаружения краев и заполнения промежутков.

Предполагаемое использование SR300

• Отслеживание скелета всей руки, распознавание жестов
• Режим Cursor
• Отслеживание головы
• Сегментация трехмерного изображения и удаление фона
• Дополненная реальность с расширенным отображением глубины
• Голосовое управление
• Трехмерное сканирование лиц и объектов
• Распознавание лиц

Области применения камеры

Динамическая сегментация фона

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

Трехмерное сканирование

В камерах SR300 значительно повышено качество цветопередачи при недостаточном освещении по сравнению с камерами F200; в результате повышается качество текстур, которые можно накладывать на трехмерные модели для их визуализации. Обе камеры переднего обзора могут сканировать лицо пользователя или небольшие предметы. При этом у камер SR300 дальность съемки увеличена до 70 см при 50 кадрах в секунду, а также повышена детализация по сравнению с камерами F200. Можно использовать Intel RealSense SDK для создания трехмерного изображения, а затем выложить его на Facebook* с помощью Sketchfab*. Дополнительные сведения о Sketchfab см. в статьях Реализация входа Sketchfab в приложенияхи Интеграция Sketchfab. Модуль трехмерного сканирования встраивается в игры уровня AAA для съемки и использования лица пользователя у игровых персонажей.

Распознавание жестов руки: режим Cursor поддерживается только камерой SR300

Модуль отслеживание рук поддерживает три основных режима: режим Cursor, режим конечностей и режим полной кисти руки. Режим Cursor — новая функция, поддерживается только камерой SR300. Этот режим возвращает единственную точку для руки, что позволяет очень точно отслеживать трехмерное положение указателя и выполнять жесты. Режим Cursor используется в случаях, когда для работы с приложением достаточно более быстрого, компактного и точного отслеживания руки в сочетании с несколькими достоверно распознаваемыми жестами. В режиме Cursor поддерживается отслеживание движения руки и жеста щелчка. При этом, по сравнению с режимом отслеживания всей кисти руки, вдвое увеличена дальность и скорость, отсутствуют задержки, снижено потребление электроэнергии.

Рисунок 1. Режим Cursor

Два микрофона

Камера Intel RealSense SR300 оборудована сдвоенным микрофоном для ввода звука в клиентскую систему. Применение двух микрофонов повышает надежность работы голосового модуля в шумной обстановке.

Характеристики камеры Intel® RealSense™ SR300

Драйвер DCM

Для камеры SR300 требуется Intel® RealSense™ Depth Camera Manager (DCM) версии 3.x. На момент написания этой статьи для SR300 доступна «золотая» версия DCM 3.0.24.59748, а обновления будут распространяться с помощью Центра обновления Windows 10. Посетите страницу загрузки Intel RealSense SDK, чтобы загрузить последнюю версию DCM. Дополнительные сведения о DCM см. в разделе Обзор камер Intel RealSense и DCM.

Обновление микропрограммы

Камера Intel RealSense поддерживает обновление микропрограммы с помощью драйвера DCM. Если требуется обновление микропрограммы, драйвер DCM отобразит соответствующее уведомление, которое должно быть принято пользователем перед продолжением.

Требования к оборудованию

Для поддержки пропускной способности, необходимой камере Intel RealSense, в клиентской системе должен быть порт USB 3.0 с питанием. Для камеры SR300 требуется компьютер с процессором Intel® Core™ 6-го или более позднего поколения под управлением операционной системы Windows 10. Подробные сведения о требованиях к системе и о поддерживаемых операционных системах для камер SR300 и F200 см. на странице Купить комплект разработчика.

Заключение

В этом документе приводится описание новых возможностей камеры переднего обзора Intel RealSense SR300, поддерживаемых в текущей и в последующих версиях Intel RealSense SDK. Перейдите на эту страницудля загрузки последней версии Intel RealSense SDK. Заказать новую камеру можно по адресу http://click.intel.com/intel-realsense-developer-kit.html

Справочные материалы

Вот несколько полезных ссылок на Intel RealSense DCM и SDK, включая заметки к выпускам и инструкции по установке и обновлению программного обеспечения.

• Intel® Developer Zone:
  https://software.intel.com/en-us/realsense/home
  https://software.intel.com/en-us/forums/realsense
• Intel RealSense SDK:
  https://software.intel.com/en-us/intel-realsense-sdk/download
• Сравнение камер Intel RealSense SR300 и F200:
  https://software.intel.com/en-us/articles/a-comparison-of-intel-realsensetm-front-facing-camera-sr300-and-f200
• Камера Intel RealSense R200:
  https://software.intel.com/en-us/articles/realsense-r200-camera
• Intel RealSense Depth Camera Manager:
  https://software.intel.com/en-us/blogs/2015/10/18/intel-realsense-depth-camera-manager-dcm-overview?wapkw=DCM%20overview
• Intel RealSense SDK:
  https://software.intel.com/en-us/blogs/2016/01/28/new-realsense-v8
• Приложения Intel® RealSense™:
  https://appshowcase.intel.com/en-us/realsense

Об авторе

Нэнси Ле (Nancy Le) — инженер по программному обеспечению в подразделении Software and Services Group корпорации Intel. Она работает над проектами по масштабированию с процессорами Intel® Atom™.

**Расстояния указаны приблизительно.

Введение

Камера SR300 — камера переднего обзора Intel® RealSense™ второго поколения, поддерживающая операционную систему Microsoft Windows* 10. Как и в камере F200, в модели SR300 используется технология цветового кодирования глубины для создания высококачественного трехмерного видеопотока глубины на небольшом расстоянии. Камера SR300 включает источник инфракрасной (ИК) подсветки, высокоскоростную ИК-камеру с разрешением VGA и обычную цветную двухмегапиксельную камеру со встроенным цифровым процессором изображений. В модели SR300 для съемки глубины используется высокоскоростной режим VGA вместо обычного режима VGA, который применялся в модели F200. В новом режиме съемки глубины снижено время экспозиции, поддерживается динамическое движение со скоростью до 2 м/с. Такая камера открывает новые способы использования платформы за счет предоставления синхронизированных данных цветного изображения, глубины и ИК-видео в клиентскую систему. Эффективная дальность распознавания глубины составляет от 0,2 до 1,2 м, это оптимальные значения для использования в помещениях.

Рисунок 1:Камера SR300

Камера SR300 может использовать Intel® RealSense™ SDKдля Windows. Поддержка камеры SR300 реализована в SDK версии 2015 R5 или более поздней. Камера SR300 будет поставляться в 2016 году как в виде автономного устройства, так и встраиваться в различные устройства, включая ПК, моноблоки, ноутбуки и трансформеры. В модели SR300 реализованы новые и усовершенствованные возможности по сравнению с F200.

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

* По данным на 19 февраля 2016 г.

Новые возможности, поддерживаемые только камерой SR300

Режим Cursor

Отличительная особенность камеры SR300 — режим Cursor. Этот режим отслеживания возвращает единственную точку для руки, что позволяет очень точно отслеживать трехмерное положение указателя и выполнять основные жесты. В режиме Cursor производительность повышена более чем на 50 % по сравнению с режимом отслеживания всей кисти, но при этом отсутствуют задержки и не требуется калибровка. Дальность увеличена до 85 см, а допустимая скорость движения — до 2 м/с. В режиме Cursor поддерживается жест щелчка, имитирующий щелчок мыши указательным пальцем.

Рисунок 2:Жест щелчка

Отслеживание человека

Еще одна новая функция модели SR300 — отслеживание человека. Этот режим также поддерживается камерой заднего обзора R200, но недоступен для камеры F200. В этом режиме происходит отслеживание трехмерного движения тела в реальном времени. Поддерживается три основных режима отслеживания: движение тела, суставы скелета, распознавание лиц.

• Движение тела: обнаружение тела, контура головы и туловища.
• Суставы скелета: возвращает расположение суставов человеческого тела в двухмерных и трехмерных данных.
• Распознавание лиц: сравнение текущего лица с базой данных зарегистрированных пользователей для идентификации пользователя.

Повышенная дальность и боковая скорость

В камерах SR300 появился новый режим съемки глубины — ускоренный VGA. В этом режиме съемка происходит с половинным разрешением VGA, а отснятые кадры интерполируются до полного разрешения VGA перед передачей клиенту. В этом новом режиме глубины снижено время экспозиции и поддерживается скорость движения руки до 2 м/с, тогда как в камерах F200 с обычным режимом VGA допустимая скорость движения не должна была превышать 0,75 м/с. В модели SR300 также повышена дальность действия по сравнению с F200. В режиме отслеживания рук дальность действия камеры SR300 увеличена до 85 см (по сравнению с 60 см у камеры F200). Дальность сегментации рук увеличена до 110 см у камеры SR300 по сравнению со 100 см у камеры F200.

Дальность распознавания лица увеличена с 80 см у камеры F200 до 150 см у камеры SR300.

В модели SR300 улучшено наложение цветных текстур и достигается более точное трехмерное сканирование. Дальность трехмерного сканирования увеличена до 70 см, при этом также повышена детализация. В режиме отслеживания Blob скорость отслеживания увеличена до 2 м/с, а дальность — до 150 см.

Дальность съемки глубины увеличена у камеры SR300 на 50–60 %. На расстоянии 80 см обе камеры (и SR300, и F200) четко обнаруживают руки. При увеличении расстояния свыше 120 см камера SR300 по-прежнему обнаруживает руки, а камера F200 уже не может распознать их.

Рисунок 3:Дальность датчиков глубины камер SR300 и F200

Повышенное качество цветопередачи при съемке с недостаточным освещением, улучшенные трехмерные текстуры для трехмерного сканирования

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

Улучшенная синхронизация потоков цветного изображения и глубины

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

Пониженное потребление электроэнергии

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

Обратная совместимость с приложениями для камеры F200

Intel RealSense Depth Camera Manager (DCM) 3.x дает возможность камере SR300 работать в качестве камеры F200, обеспечивая обратную совместимость для приложений, разработанных для камеры F200. DCM имитирует ресурсы камеры F200, поэтому все существующие приложения SDK будут работать и с камерой SR300. Возможности камеры SR300 поддерживаются в SDK R5 2015 или более поздней версии.

Когда запрос на поточную передачу поступает от приложения SDK, скомпилированного в SDK версии до R5 2015, DCM автоматически задействует режим совместимости и будет отправлять вызовы через конвейер F200 вместо SR300. Большинство приложений будут работать с новой камерой SR300 без каких-либо изменений настройки.

Совместимость инфракрасных данных

Камера SR300 поддерживает 10-разрядный формат данных инфракрасного изображения, тогда как F200 поддерживает 8-разрядный формат таких данных. Драйвер DCM обеспечивает совместимость, добавляя или удаляя 2 разряда к данным для получения нужного формата.

Физический разъем

Устройство материнской платы и кабелей у камер F200 и SR300 идентично. Кабель камеры F200 можно подключить в разъем камеры SR300. Поэтому для камер SR300 можно использовать кабель от камер F200. Для обеих моделей требуется интерфейс USB 3.0.

API SDK

Большинство API SDK являются общими для камер SR300, F200 и даже R200 (в некоторых случаях). Модули SDK предоставляют соответствующий интерфейс, в зависимости от того, какая модель камеры была обнаружена во время выполнения. Аналогичным образом простая передача потоков цветного изображения и глубины, где не требуется определенное изображение или определенный формат пикселей, будет работать без каких-либо изменений.

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

Поскольку все описанные параметры автоматически изменяются в зависимости от камеры, важно, чтобы каждое приложение проверяло модель камеры и ее конфигурацию во время выполнения. См. раздел «Настройки установщика» в документации SDK.

DCM

На момент написания этой статьи для SR300 доступна «золотая» версия DCM 3.0.24.59748, а обновления будут распространяться с помощью Центра обновления Windows. Посетите сайт https://software.intel.com/en-us/intel-realsense-sdk/downloadдля получения последней версии DCM. Дополнительные сведения о DCM см. в разделе Обзор камер Intel® RealSenseTM и DCM.

Требования к оборудованию

Для поддержки пропускной способности, необходимой камере Intel RealSense, в клиентской системе должен быть порт USB 3. Подробные сведения о требованиях к системе и о поддерживаемых операционных системах для камер SR300 и F200 см. по адресу https://software.intel.com/en-us/RealSense/Devkit/

Заключение

В этом документе описываются новые и улучшенные возможности камеры переднего обзора Intel RealSense 3D SR300 по сравнению с возможностями камеры F200. Эти новые возможности поддерживаются в SDK 2015 R5 и DCM 3.0.24.51819 или более поздней версии. Новую камеру можно заказать по адресу http://click.intel.com/realsense.html.

Справочные материалы

Вот несколько полезных ссылок на Intel® RealSense™ DCM и SDK, включая заметки к выпускам и инструкции по установке и обновлению программного обеспечения.

• Developer Zone:
  https://software.intel.com/en-us/realsense/home
  https://software.intel.com/en-us/forums/realsense
• F200
  https://software.intel.com/en-us/articles/realsense-r200-camera
• DCM:
  https://software.intel.com/en-us/blogs/2015/10/18/intel-realsense-depth-camera-manager-dcm-overview?wapkw=DCM%20overview
• SDK
  https://software.intel.com/en-us/blogs/2016/01/28/new-realsense-v8

Об авторе

Нэнси Ле (Nancy Le) — инженер по программному обеспечению в подразделении Software and Services Group корпорации Intel. Она работает над проектами по масштабированию с процессорами Intel® Atom™.

Введение

Процессоры Intel® Core™ 6-го поколения (Skylake) появились в 2015 году. Благодаря целому ряду усовершенствований на уровне ядра, «системы на кристалле» и на уровне платформы, по сравнению с 14-нм процессором предыдущего поколения (Broadwell), процессор Skylake пользуется огромной популярностью в устройствах самых разных типов, предназначенных для работы, творчества и игр. В этой статье приводится обзор основных возможностей и усовершенствований Skylake, а также новые модели использования, такие как пробуждение по голосовым командам и вход в систему по биометрическим данным в ОС Windows* 10.

Архитектура Skylake

Процессоры Intel Core 6-го поколения производятся по 14-нм технологии с учетом более компактного размера процессора и всей платформы для использования в устройствах разных типов. При этом также повышена производительность архитектуры и графики, реализованы расширенные средства безопасности. На рис. 1 показаны эти новые и улучшенные возможности. Фактическая конфигурация в устройствах ОЕМ-производителей может различаться.

Рисунок 1.Архитектура Skylake и сводка усовершенствований [1].

Основные направления развития процессоров

Производительность

Повышение производительности напрямую обусловлено предоставлением большего количества инструкций исполняющему блоку: за каждый тактовый цикл выполняется больше инструкций. Такой результат достигается за счет улучшений в четырех категориях [Ibid].

• Улучшенный внешний интерфейс. Благодаря более точному предсказанию ветвления и повышенной вместимости увеличивается скорость декодирования инструкций, упреждающая выборка работает быстрее и эффективнее.
• Улучшенное распараллеливание инструкций. За каждый такт обрабатывается больше инструкций, при этом параллельное выполнение инструкции улучшено благодаря более эффективной буферизации.
• Улучшенные исполняющие блоки (ИБ). Работа исполняющих блоков улучшена по сравнению с прежними поколениями за счет следующих мер:
  • Укорочены задержки.
  • Увеличено количество ИБ.
  • Повышена эффективность электропитания за счет отключения неиспользуемых блоков.
  • Повышена скорость выполнения алгоритмов безопасности.
• Улучшенная подсистема памяти. В дополнение к улучшению внешнего интерфейса, параллельной обработке инструкций и исполняющих блоков усовершенствована и подсистема памяти в соответствии с пропускной способностью и требованиями производительности перечисленных выше компонентов. Для этого использованы следующие меры:
  • Повышенная пропускная способность загрузки и сохранения.
  • Улучшенный модуль упреждающей выборки.
  • Хранение на более глубоком уровне.
  • Буферы заполнения и обратной записи.
  • Улучшенная обработка промахов страниц.
  • Повышенная пропускная способность при промахах кэша второго уровня.
  • Новые инструкции управления кэшем.

Рисунок 2.Схема микроархитектуры ядра Skylake

На рис. 3 показано улучшение параллельной обработки в процессорах Skylake по сравнению с процессорами прежних поколений (Sandy Bridge — второе, а Haswell — четвертое поколение процессоров Intel® Core™).

Рисунок 3.Улучшенное распараллеливание по сравнению с прежними поколениями процессоров

Благодаря усовершенствованиям, показанным на рис. 3, производительность процессора возросла на 60 % по сравнению с ПК пятилетней давности, при этом перекодирование видео осуществляется в 6 раз быстрее, а производительность графической подсистемы выросла в 11 раз.

Рисунок 4.Производительность процессора Intel® Core™ 6-го поколения по сравнению с ПК пятилетней давности

1. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте SYSmark* 2014.
2. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте Handbrake с QSV.
3. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте 3DMark* Cloud Gate.

Подробные результаты сравнения производительности настольных ПК и ноутбуков см. по следующим ссылкам:

Производительность настольных компьютеров: http://www.intel.com/content/www/us/en/benchmarks/desktop/6th-gen-core-i5-6500.html

Производительность ноутбуков: http://www.intel.com/content/www/us/en/benchmarks/laptop/6th-gen-core-i5-6200u.html

Экономия электроэнергии

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

В устаревших системах используется технология Intel® SpeedStep® для балансировки производительности и расхода электроэнергии с помощью алгоритма подключения ресурсов по запросу. Этот алгоритм управляется операционной системой. Такой подход неплох для постоянной нагрузки, но неоптимален при резком повышении нагрузки. В процессорах Skylake технология Intel® Speed Shift передает управление оборудованию вместо операционной системы и дает возможность процессору перейти на максимальную тактовую частоту примерно за 1 мс, обеспечивая более точное управление электропитанием[3].

Рисунок 5.Сравнение технологий Intel® Speed Shift и Intel® SpeedStep®

На приведенном ниже графике показана скорость реагирования процессора Intel® Core™ i5 6200U с технологией Intel Speed Shift по сравнению с технологией Intel SpeedStep.

• Скорость реагирования выросла на 45 %.
• Обработка фотографий на 45 % быстрее.
• Построение графиков на 31 % быстрее.
• Локальные заметки на 22 % быстрее.
• Средняя скорость реагирования выросла на 20 %.

[Согласно результатам теста WebXPRT* 2015 компании Principled Technologies*, в котором измеряется производительность веб-приложений в целом и в отдельных областях, таких как обработка фотографий, создание заметок, построение графиков. Дополнительные сведения см. на сайте www.principledtechnologies.com.]

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

Мультимедиа и графика

Видеоадаптер Intel® HD Graphics воплощает целый ряд усовершенствований с точки зрения обработки трехмерной графики, обработки мультимедиа, вывода изображения на экран, производительности, электропитания, возможности настройки и масштабирования. Это весьма мощное устройство в семействе встроенных в процессор графических адаптеров (впервые появившихся в процессорах Intel® Core™ второго поколения). На рис. 6 сравниваются некоторые из этих усовершенствований, обеспечивающих повышение производительности графики более чем в 100 раз[2].

[Пиковое значение FLOPS шейдера при частоте 1 ГГц]

Рисунок 6.Возможности графической подсистемы в разных поколениях процессоров

Рисунок 7.Улучшение обработки графики и мультимедиа в разных поколениях

Микроархитектура 9-го поколения

Графическая архитектура 9-го поколения аналогична микроархитектуре графики 8-го поколения процессоров Intel® Core™ Broadwell (5-го поколения), но улучшена с точки зрения производительности и масштабируемости. На рис. 8 показана блок-схема микроархитектуры поколения 9[8], состоящей из трех основных компонентов.

• Экран.С левой стороны.
• Вне среза. L-образная часть в середине. Включает поточный обработчик команд, глобальный диспетчер потоков и графический интерфейс (GTI).
• Срез.Включает исполняющие блоки (ИБ).

По сравнению с 8-м поколением микроархитектура 9-го поколения отличается более высокой максимальной производительностью на 1 Вт, повышенной пропускной способностью и отдельным контуром электропитания/тактов для компонента вне среза. Это позволяет более эффективно управлять электропитанием в таких режимах использования, как при воспроизведении мультимедиа. Срез является настраиваемым компонентом. Например, GT3 поддерживает до двух срезов (каждый срез с 24 исполняющими блоками), GT4 (Halo) может поддерживать до 3 срезов (цифра после букв GT означает количество исполняющих блоков на основе их использования: GT1 поддерживает 12 исполняющих блоков, GT2 — 24, GT3 — 48, а GT4 — 72 исполняющих блока). Архитектура допускает настройку в достаточно широких пределах, чтобы использовать минимальное количество исполняющих блоков в сценариях с низкой нагрузкой, поэтому потребление электроэнергии может составлять от 4 до более чем 65 Вт. Поддержка API графических процессоров 9-го поколения доступна в DirectX* 12, OpenCL™ 2.x, OpenGL* 5.x и Vulkan*.

Рисунок 8.Архитектура графических процессоров 9-го поколения

Подробнее об этих компонентах см. по адресу (ссылка IDF https://software.intel.com/sites/default/files/managed/c5/9a/The-Compute-Architecture-of-Intel-Processor-Graphics-Gen9-v1d0.pdf)

В число усовершенствований и возможностей обработки мультимедиа входят следующие[2]:

• Потребление менее 1 Вт, потребление 1 Вт при проведении видеоконференций.
• Ускорение воспроизведения необработанного видео с камеры (в формате RAW) с помощью новых функций VQE для поддержки воспроизведения видео RAW с разрешением до 4K60 на мобильных платформах.
• Новый режим New Intel® Quick Sync Video с фиксированными функциями (FF).
• Поддержка широкого набора кодеков с фиксированными функциями, ускорение декодирования с помощью ГП.

На рис. 9 показаны кодеки графического процессора поколения 9.

Примечание.Поддержка кодеков мультимедиа и обработки может быть доступна не во всех ОС и приложениях.

Рисунок 9.Поддержка кодеков процессорами Skylake

В число усовершенствований и возможностей работы экрана входят следующие:

• Смешение, масштабирование, поворот и сжатие изображения.
• Поддержка высокой плотности пикселей (разрешение свыше 4K).
• Поддержка передачи изображения по беспроводному подключению с разрешением вплоть до 4K30.
• Самостоятельное обновление (PSR2).
• CUI X.X — новые возможности, повышенная производительность.

В процессорах Intel® Core™ I7-6700K предусмотрены следующие возможности для геймеров (см. рис. 10). Также поддерживается технология Intel® Turbo Boost 2.0, технология гиперпоточности Intel® и возможность разгона. Прирост производительности по сравнению с ПК пятилетней давности достигает 80 %. Дополнительные сведения см. на этой странице: http://www.intel.com/content/www/us/en/processors/core/core-i7ee-processor.html

1. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i7-6700K и Intel® Core™ i7-875K в тесте SPECint*_rate_base2006 (коэффициент копирования 8).
2. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i7-6700K и Intel® Core™ i7-3770K в тесте SPECint*_rate_base2006 (коэффициент копирования 8).
3. Описываемые возможности доступны в отдельных сочетаниях процессоров и наборов микросхем. Предупреждение. Изменение тактовой частоты и/или напряжения может: (i) привести к снижению стабильности системы и снижению срока эксплуатации системы и процессора; (ii) привести к отказу процессора и других компонентов системы; (iii) привести к снижению производительности системы; (iv) привести к дополнительному нагреву или к другим повреждениям; (v) повлиять на целостность данных в системе. Корпорация Intel не тестирует и не гарантирует работу процессоров с техническими параметрами, отличными от установленных.

Рисунок 10.Возможности процессоров Intel® Core™ i7-6700K

Масштабируемость

Микроархитектура Skylake — это настраиваемое ядро: единая конструкция для двух направлений, одно — для клиентских устройств, другое — для серверов без ущерба для требований по мощности и производительности обоих сегментов. На рис. 11 показаны различные модели процессоров и их эффективность с точки зрения мощности для использования в устройствах разного размера и разных типов — от сверхкомпактных Compute Stick до мощных рабочих станций на основе Intel® Xeon®.

Рисунок 11.Доступность процессоров Intel® Core™ для различных типов устройств

Расширенные возможности безопасности

Расширения Intel® Software Guard Extensions (Intel® SGX): Intel SGX — это набор новых инструкций в процессорах Skylake, дающий возможность разработчикам приложений защищать важные данные от несанкционированных изменений и доступа посторонних программ, работающих с более высоким уровнем прав. Это дает приложениям возможность сохранять конфиденциальность и целостность конфиденциальной информации [1], [3]. Skylake поддерживает инструкции и потоки для создания безопасных анклавов, позволяя использовать доверенные области памяти. Дополнительные сведения о расширениях Intel SGX см. на этой странице: https://software.intel.com/en-us/blogs/2013/09/26/protecting-application-secrets-with-intel-sgx

Расширения защиты памяти Intel® (Intel® MPX): Intel MPX — новый набор инструкций для проверки переполнения буфера во время выполнения. Эти инструкции позволяют проверять границы буферов стека и буферов кучи перед доступом к памяти, чтобы процесс, обращающийся к памяти, имел доступ лишь к той области памяти, которая ему назначена. Поддержка Intel MPX реализована в Windows* 10 с помощью встроенных функций Intel MPX в Microsoft Visual Studio* 2015. В большинстве приложений C/C++ можно будет использовать Intel MPX: для этого достаточно заново скомпилировать приложения, не изменяя исходный код и связи с устаревшими библиотеками. При запуске библиотек, поддерживающих Intel MPX, в системах, не поддерживающих Intel MPX (процессоры Intel® Core™ 5-го поколения и более ранних), производительность никак не изменяется: ни повышается, ни снижается. Также можно динамически включать и отключать поддержку Intel MPX [1], [3].

Мы рассмотрели усовершенствования и улучшения архитектуры Skylake. В следующем разделе мы рассмотрим компоненты Windows 10, оптимизированные для использования преимуществ архитектуры Intel® Core™.

Новые возможности Windows 10

Возможности процессоров Intel Core 6-го поколения дополняются возможностями операционной системы Windows 10. Ниже перечислены некоторые основные возможности оборудования Intel и ОС Windows 10, благодаря которым платформы Intel® под управлением Windows 10 работают эффективнее, стабильнее и быстрее[3].

Ϯ Ведется совместная работа Intel и Майкрософт для реализации дальнейшей поддержки в Windows.

Рисунок 12.Возможности Skylake и Windows* 10

Кортана

Голосовой помощник Кортана корпорации Майкрософт доступен в Windows* 10 и дает возможность управлять компьютером с помощью голоса после произнесения ключевой фразы «Привет, Кортана!». Функция пробуждения по голосовой команде использует конвейер обработки звука на ЦП для повышения достоверности распознавания, но можно передать эту функцию на аппаратный цифровой сигнальный процессор звука со встроенной поддержкой Windows 10[3].

Windows Hello*

С помощью биометрического оборудования и Microsoft Passport* служба Windows Hello поддерживает различные механизмы входа в систему с помощью распознавания лица, отпечатков пальцев или радужки глаз. Система без установки каких-либо добавочных компонентов поддерживает все эти возможности входа без использования пароля. Камера переднего обзора Intel® RealSense™ (F200/SR300) поддерживает биометрическую проверку подлинности на основе распознавания лица[3].

Рисунок 13.Windows* Hello с технологией Intel® RealSense™

Фотографии на рис. 13 показывают, как реперные точки, обнаруженные на лице камерой F200, используются для идентификации пользователя и входа в систему. На основе расположения 78 реперных точек на лице создается шаблон лица при первой попытке пользователя войти в систему с помощью распознавания лица. При следующей попытке входа сохраненное расположение реперных точек, полученное камерой, сравнивается с сохраненным шаблоном. Возможности службы Microsoft Passport в сочетании с возможностями камеры позволяют добиться уровня безопасности с показателями ложного допуска в систему в 1 из 100 000 случаев и ложного отказа в допуске в 2–4 % случаев.

Ссылки

1. Intel’s next generation microarchitecture code-named Skylake by Julius Mandelblat: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150818_spcs001/index.html
2. Next-generation Intel® processor graphics architecture, code-named Skylake, by David Blythe: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150818_spcs003/index.html
3. Intel® architecture code-named Skylake and Windows* 10 better together, by Shiv Koushik: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150819_spcs009/index.html
4. Skylake for gamers: http://www.intel.com/content/www/us/en/processors/core/core-i7ee-processor.html
5. Intel’s best processor ever: http://www.intel.com/content/www/us/en/processors/core/core-processor-family.html
6. Skylake Desktop Performance Benchmark: http://www.intel.com/content/www/us/en/benchmarks/desktop/6th-gen-core-i5-6500.html
7. Skylake Laptop Performance Benchmark: http://www.intel.com/content/www/us/en/benchmarks/laptop/6th-gen-core-i5-6200u.html
8. The compute architecture of Intel® processor graphics Gen9: https://software.intel.com/sites/default/files/managed/c5/9a/The-Compute-Architecture-of-Intel-Processor-Graphics-Gen9-v1d0.pdf

Аннотация

После появления камеры Intel® RealSense™ (SR300) и пакета Intel® RealSense™ SDK 2016 R появился новый режим взаимодействия с помощью жестов — режим указателя (Cursor), доступный только при использовании камеры SR300. В этом учебном руководстве описываются изменения кода, необходимые для задействования этой новой функциональности..

Введение

До выпуска пакета Intel RealSense SDK 2016 R1 приложения, в которых нужно управлять движением указателя и обнаруживать действия щелчков, использовали режим Hand, а для определения щелчков применяли распознавание жестов. Эта функциональность режима Hand теперь превратилась в новый режим Cursor. Приложения, использующие прежнюю функциональность, после переделки кода смогут воспользоваться более высокой точностью и более широкими возможностями управления указателем в режиме Cursor.

Обратите внимание, что режим Cursor доступен только для устройств с камерой Intel RealSense SR300. Разработчикам приложений Intel® RealSense™, использующим камеры SR300, необходимо обновить операционную систему до Windows* 10 и использовать Intel RealSense SDK версии 2016 R1.

Учебное руководство

Скорее всего, у вас уже есть приложение, написанное для камеры F200 с помощью Intel RealSense SDK R4 (v6.0). Как двинуться дальше и использовать новый режим Cursor? Это учебное руководство состоит из следующих частей.

Часть 1

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

PXCSenseManager *pSenseMgr = new PXCSenseManager::CreateInstance();
if( !pSenseMgr ) {< continue on to creating the modes >
}

Часть 2

Ранее, в режиме Hand на камерах F200, для получения чего-либо, хотя бы отдаленного напоминающего указатель, требовалось задействовать модуль Hand и отслеживать руки в различных конфигурациях. Код при этом мог выглядеть примерно так (обратите внимание, что следующий код приведен для справки, он не будет компилироваться непосредственно в том виде, в котором он показан здесь):

PXCHandModule *pHandModule;
PXCHandData *pHandData;
int confidence;
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
	status = pSenseMgr->EnableHand()
	if(status == pxcStatus::PXC_STATUS_NO_ERROR) {
	// Get an instance of PXCHandModule
handModule = pSenseMgr->QueryHand();
// Get an instance of PXCHandConfiguration
PXCHandConfiguration handConfig = handModule
handConfig->EnableGesture("cursor_click");
handConfig->ApplyChanges();
	. . . <дополнительные параметры конфигурации> . . .
}
}

Часть 3

В Intel RealSense SDK начиная с версии 2016 R1 реализован новый режим Cursor, действия с указателем отделены от режима Hand. Это означает, что необходимо переработать прежний код, запрашивавший режим Hand в Sense Manager. Новый код будет выглядеть так:

PXCHandCursorModule *pCursorModule;
PXCCursorData::BodySideType bodySide;
// обратите внимание, что значений Confidence больше нет
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
// Enable handcursor tracking
status = pSenseMgr::EnableHandCursor();
	if(status == pxcStatus.PXC_STATUS_NO_ERROR) {
	// Get an instance of PXCCursorModule
pCursorModule = pSenseMgr->QueryHandCursor();
// Get an instance of the cursor configuration
PXCCursorConfiguration *pCursorConfig = CursorModule::CreateActiveConfiguration();

// Make configuration changes and apply them
pCursorConfig.EnableEngagement(true);
pCursorConfig.EnableAllGestures();
pCursorConfig.ApplyChanges();
	. . . <дополнительные параметры конфигурации> . . .

}
}

Часть 4

Реализация примеров основных вычислительных циклов для синхронных и асинхронных функций см. в документации Intel RealSense™ SDK 2016 R1в разделе Реализация основного вычислительного цикла «Модуль Cursor [SR300]».

Асинхронный (рекомендуемый) подход будет выглядеть так:

class MyHandler: public PXCSenseManager::Handler {
public:
    virtual pxcStatus PXCAPI OnModuleProcessedFrame(pxcUID mid, PXCBase *module, PXCCapture::Sample *sample) {
       // check if the callback is from the hand cursor tracking module
       if (mid==PXCHandCursorModule::CUID) {
           PXCHandCursorModule *cursorModule=module->QueryInstance<PXCHandCursorModule>();
               PXCCursorData *cursorData = cursorModule->CreateOutput();
           // process cursor tracking data
       }

       // return NO_ERROR to continue, or any error to abort
       return PXC_STATUS_NO_ERROR;
    }
};
. . . <объявление SenseManager> . . .
// Initialize and stream data
MyHandler handler; // Instantiate the handler object

// Register the handler object
pSenseMgr->Init(&handler);

// Initiate SenseManager’s processing loop in blocking mode
// (function exits only when processing ends)
pSenseMgr ->StreamFrames(true);

// Release SenseManager resources
pSenseMgr ->Release()

Заключение

В Intel RealSense SDK 2016 R1 изменилась реализация и доступ к указателю руки, но все изменения однородны, что упрощает переделку кода. В приведенном выше примере кода демонстрируется эта простота: показано, что структура программы при инициализации, настройке и покадровом выполнении может остаться неизменной, при этом программа будет использовать расширенные возможности нового режима Cursor.

Напомним, что новый режим Cursor доступен только для систем с камерой SR300 (камера может быть встроенной или подключаться в виде отдельного периферийного устройства) и с версией RealSense™ SDK 2016 R1. Возможность кода обнаруживать модель камеры и поддерживать одновременно камеры F200 и SR300 будет описана в других учебных руководствах.

Аннотация

В этой статье описывается создание кода для приложения с виртуальным джойстиком (см. рис. 1), использующего новый модуль Hand Cursor в составе Intel® RealSense™ SDK. Проект разрабатывается на C#/XAML, его можно собрать с помощью Microsoft Visual Studio* 2015.

Рисунок 1. Приложение RS Joystick, управляющее имитацией полета в Google Earth*

Введение

В Intel RealSense SDK R5появилась поддержка новой модели камеры Intel® RealSense™ SR300. Камера SR300 — развитие модели на F200, в ней усовершенствован ряд возможностей и добавлен новый режим работы Hand Cursor.

Согласно описанию в документации SDKмодуль Hand Cursor возвращает одну точку для положения руки, что позволяет добиться высокой точности и скорости отслеживания. Цель этого модуля — упростить работу с элементами управления пользовательского интерфейса с помощью руки при поддержке ограниченного набора жестов.

RS Joystick — программный эмулятор джойстика, описанный в этой статье. Это приложение сопоставляет трехмерные данные руки, предоставляемые пакетом SDK, в виртуальные элементы управления джойстиком, что дает возможность взаимодействия с приложениями, управляемыми при помощи джойстика.

Приложение RS Joystick использует следующие компоненты модуля Hand Cursor.

• Тип Body Side:приложение оповещает пользователя о том, какая из рук управляет виртуальным джойстиком (на основе порядка от ближнего к дальнему).
• Жест Cursor-Click:пользователь может переключать состояние ВКЛЮЧЕНО/ВЫКЛЮЧЕНО кнопки 1 на виртуальном джойстике с помощью жеста щелчка пальцами.
• Адаптивное отслеживание точки:приложение отображает нормализованную трехмерную точку внутри воображаемой «ограничительной рамки», заданной модулем Hand Cursor, и использует эти данные для управления виртуальным джойстиком по осям X, Y и Z.
• Данные оповещений:приложение использует оповещения Cursor Not Detected, Cursor Disengagedи Cursor Out Of Borderдля изменения цвета джойстика с зеленого на красный, когда рука пользователя находится вне дальности действия камеры SR300.

(Дополнительные сведения о модуле Hand Cursor см. в статье “Что можно делать в режиме Intel RealSense Cursor?”)

Предварительные требования

Требуются некоторые знания C# и понимание базовых действий в Visual Studio, таких как сборка исполняемого файла. Также пригодится опыт добавления сторонних библиотек в индивидуальные программные проекты. Впрочем, даже если раньше вы этого не делали, трудностей возникнуть не должно, поскольку в этом руководстве приводятся подробные инструкции необходимых действий. В системе должна быть камера переднего обзора SR300, последние версии SDK и Intel® RealSense™ Depth Camera Manager (DCM). Кроме того, система должна отвечать требованиям к оборудованию, перечисленным здесь. И наконец, компьютер должен работать под управлением Microsoft Windows* 10 Threshold 2.

Стороннее программное обеспечение

В этом проекте, помимо пакета Intel RealSense SDK, используется сторонний драйвер виртуального джойстика под названием vJoy* и несколько библиотек динамической компоновки (DLL). Эти программные компоненты не входят в распространяемый код, связанный с этим проектом, поэтому сведения по загрузке и установке драйвера устройства приводятся ниже.

Установите Intel RealSense SDK

Загрузите и установите DCM и SDK по адресу https://software.intel.com/en-us/intel-realsense-sdk/download. На момент написания этой статьи последними версиями компонентов были следующие:

• Intel RealSense Depth Camera Manager (SR300) v3.1.25.1077
• Intel RealSense SDK v8.0.24.6528

Установите драйвер устройства vJoy и SDK

Загрузите и установите драйвер устройства vJoy: http://vjoystick.sourceforge.net/site/index.php/download-a-install/72-download. При получении соответствующей инструкции перезагрузите компьютер, чтобы завершить установку.

После установки драйвер устройства vJoy появится в разделе «Устройства HID» в диспетчере устройств (см. рис. 2).

Рисунок 2.Диспетчер устройств

Откройте в Windows 10 меню «Пуск» и выберите Все приложения. Вы увидите несколько установленных компонентов vJoy, как показано на рис. 3.

Рисунок 3.Меню «Пуск» в Windows

Чтобы открыть браузер по умолчанию и перейти на страницу загрузки, нажмите кнопку vJoy SDK.

После загрузки скопируйте ZIP-файл во временную папку и найдите DLL-библиотеки C# в папке \SDK\c#\x86.

Мы добавим эти DLL-библиотеки в проект Visual Studio после его создания (см. описание ниже).

Создайте новый проект Visual Studio

• Запустите Visual Studio 2015.
• В меню выберите Файл, Создать, Проект….
• На экране «Создание проекта» разверните «Шаблоны» и выберите Visual C#, Windows.
• Выберите Приложение WPF.
• • Укажите расположение проекта и его имя. Для этого проекта мы используем расположение C:\, а имя приложения — RsJoystick.

На рис. 4 показаны настройки этого проекта.

Рисунок 4.Настройки нового проекта в Visual Studio*

Нажмите кнопку ОК, чтобы создать проект.

Скопируйте библиотеки в проект

Для создания приложений Intel® RealSense™ на языке C# требуются две библиотеки.

• libpxcclr.cs.dll – управляемая DLL-библиотека интерфейса C#.
• libpxccpp2c.dll – неуправляемая DLL-библиотека C++ P/Invoke.

Еще две библиотеки дадут возможность приложению обмениваться данными с драйвером устройства vJoy.

• vJoyInterface.dll – библиотека API на языке C.
• vJoyInterfaceWrap.dll – оболочка C# для библиотеки API на языке C.

Чтобы упростить структуру проекта, мы скопируем все четыре библиотеки в папку проекта.

• Щелкните проект RsJoystick правой кнопкой мыши и выберите Добавить, Существующий элемент…
• Перейдите в папку библиотек vJoy (\SDK\c#\x86) и выберите vJoyInterface.dll и vJoyInterfaceWrap.dll. Примечание. В поле типа файлов может потребоваться выбрать Все файлы (*.*), чтобы DLL-библиотеки стали видны.
• Нажмите кнопку Добавить.

Аналогичным образом скопируйте в проект DLL-библиотеки Intel RealSense SDK.

• Щелкните проект RsJoystick правой кнопкой мыши, выберите Добавить, Существующий элемент…
• Перейдите в папку библиотек x86, это папка C:\Program Files (x86)\Intel\RSSDK\bin\win32, если пакет SDK был установлен в папку по умолчанию.
• Выберите libpxcclr.cs.dll и libpxccpp2c.dll.
• Нажмите кнопку Добавить.

Теперь все четыре файла должны быть видны в обозревателе решений в проекте RsJoystick.

Создайте ссылки на библиотеки

Если необходимая библиотека физически скопирована в проект Visual Studio, необходимо создать ссылки на управляемыебиблиотеки (.NET), чтобы приложение могло их использовать. Щелкните правой кнопкой мыши «Ссылки» (под проектом RsJoystick) и выберите Добавить ссылку…В окне диспетчера ссылок нажмите кнопку Обзори перейдите в папку проекта (c:\RsJoystick\RsJoystick). Выберите файлы libpxcclr.cs.dll и vJoyInterfaceWrap.dll, затем нажмите кнопку Добавить. Нажмите кнопку OKв диспетчере ссылок.

Для правильной работы управляемых DLL-библиотек оболочки необходимо скопировать неуправляемые DLL-библиотеки в выходную папку проекта перед запуском приложения. В обозревателе решений щелкните файл libpxccpp2c.dll, чтобы выбрать его. В окне свойств будут показаны свойства файла libpxccpp2c.dll. Найдите поле Копировать в выходной каталоги выберите в раскрывающемся списке Всегда копировать. Повторите этот шаг для файла vJoyInterface.dll. За счет этого неуправляемые DLL-библиотеки будут скопированы в выходную папку проекта при сборке приложения.

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

• Найдите ссылку на диспетчер конфигураций в раскрывающемся списке в меню (см. рис. 5).
• Выберите Диспетчер конфигураций.
• В окне диспетчера конфигураций разверните раскрывающийся список в столбце Платформаи выберите Новая.
• Выберите x86в качестве новой платформы и нажмите кнопку OK.
• Закройте окно диспетчера конфигураций.

Рисунок 5. Диспетчер конфигураций

На этом этапе проект должен быть собран и запущен без каких-либо ошибок или предупреждений. Кроме того, если изучить содержимое выходной папки (c:\RsJoystick\RsJoystick\bin\x86\Debug), вы увидите, что в нее скопированы все четыре библиотеки.

Пользовательский интерфейс

В пользовательском интерфейсе (см. рис. 6.) отображаются следующие сведения:

• Рука пользователя, управляющая виртуальным джойстиком (на основе порядка доступа от ближнего к дальнему; ближайшая к камере рука считается управляющей).
• Состояние ВКЛЮЧЕНО/ВЫКЛЮЧЕНО кнопки 1 на виртуальном джойстике (управляется с помощью жеста щелчка пальцами).
• Эллипс, в котором отслеживается относительное положение руки пользователя по осям X и Y; диаметр изменяется на основе оси Z в соответствии с расстоянием между рукой и камерой.
• Данные Adaptive Point по осям X, Y и Z из SDK представлены в виде нормализованных значений, диапазон — от 0 до 1.
• Цветная рамка, цвет которой меняется с зеленого на красный, когда рука пользователя выходит за пределы дальности действия камеры SR300.
• С помощью ползунка регулируется чувствительность для каждой оси.

Рисунок 6. Пользовательский интерфейс

Полный исходный код XAML представлен в таблице 1. Его можно скопировать и вставить непосредственно в код MainWindow.xaml, автоматически сформированный при создании проекта.

Таблица 1.Исходный код XAML: MainWindow.xaml

<Window x:Class="RsJoystick.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:RsJoystick"
        mc:Ignorable="d"
        Title="RSJoystick" Height="420" Width="420" Background="#FF222222" Closing="Window_Closing"><Window.Resources><Style x:Key="TextStyle" TargetType="TextBlock"><Setter Property="Foreground" Value="White"/><Setter Property="FontSize" Value="14"/><Setter Property="Text" Value="-"/><Setter Property="Margin" Value="4"/><Setter Property="HorizontalAlignment" Value="Center"/></Style></Window.Resources><StackPanel VerticalAlignment="Center" HorizontalAlignment="Center" Width="320"><TextBlock x:Name="uiBodySide" Style="{StaticResource TextStyle}"/><TextBlock x:Name="uiButtonState" Style="{StaticResource TextStyle}"/><Border x:Name="uiBorder" BorderThickness="2" Width="200" Height="200" BorderBrush="Red" Margin="4"><Canvas x:Name="uiCanvas" ClipToBounds="True"><Ellipse x:Name="uiCursor" Height="10" Width="10" Fill="Yellow"/><Ellipse Height="50" Width="50" Stroke="Gray" Canvas.Top="75" Canvas.Left="75"/><Rectangle Height="1" Width="196" Stroke="Gray" Canvas.Top="100"/><Rectangle Height="196" Width="1" Stroke="Gray" Canvas.Left="100"/></Canvas></Border><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiX" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderX" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiY" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderY" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiZ" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderZ" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel></StackPanel></Window>

Исходный код программы

Полный исходный код приложения RSJoystick на языке C# представлен в таблице 2. Его можно скопировать и вставить непосредственно в код MainWindow.xaml.cs, автоматически сформированный при создании проекта.

Таблица 2.Исходный код C#: MainWindow.xaml.cs

//--------------------------------------------------------------------------------------
// © Intel Corporation, 2016.
// Все права защищены.
//
// Предоставляется разрешение на использование, создание, распространение и подготовку производных работ
// этого программного обеспечения для любых целей без уплаты отчислений при условии, что приведенное выше уведомление об авторских правах
// и данное уведомление сохранятся во всех копиях. Корпорация Intel не делает никаких заявлений относительно
// пригодности этого программного обеспечения для любых целей. ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ».
// КОРПОРАЦИЯ INTEL НЕ ПРЕДОСТАВЛЯЕТ НИКАКИХ ГАРАНТИЙ, ЯВНЫХ И ПОДРАЗУМЕВАЕМЫХ,
// ВКЛЮЧАЯ ГАРАНТИЮ ОТСУТСТВИЯ ОПОСРЕДОВАННЫХ ИЛИ ИНЫХ НЕПРЯМЫХ УБЫТКОВ В СВЯЗИ С ИСПОЛЬЗОВАНИЕМ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ,
// ВКЛЮЧАЯ ГАРАНТИЮ НЕНАРУШЕНИЯ КАКИХ-ЛИБО ПРАВ СОБСТВЕННОСТИ И ВКЛЮЧАЯ
// ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ ИЛИ ПРИГОДНОСТИ ДЛЯ КАКОЙ-ЛИБО ЦЕЛИ. Корпорация Intel не
// несет ответственности за любые ошибки, которые могут быть в этом программном обеспечении, и не принимает
// никаких обязательств относительно обновления этого программного обеспечения.
//--------------------------------------------------------------------------------------
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using vJoyInterfaceWrap;
using System.Threading;
using System.Windows.Shapes;

namespace RsJoystick
{
    /// <сводка>
    /// Логика взаимодействия для MainWindow.xaml
    /// </сводка>
    public partial class MainWindow : Window
    {
        private PXCMSenseManager sm;
        private PXCMHandCursorModule cursorModule;
        private PXCMCursorConfiguration cursorConfig;
        private vJoy joystick;
        private Thread update;
        private double joySensitivityX;
        private double joySensitivityY;
        private double joySensitivityZ;
        private const uint joyID = 1;
        private const uint MaxSensitivity = 16384;

        public MainWindow()
        {
            InitializeComponent();

            // Configure the sensitivity controls
            uiSliderX.Maximum = MaxSensitivity;
            uiSliderY.Maximum = MaxSensitivity;
            uiSliderZ.Maximum = MaxSensitivity;
            joySensitivityX = uiSliderX.Value = MaxSensitivity / 2;
            joySensitivityY = uiSliderY.Value = MaxSensitivity / 2;
            joySensitivityZ = uiSliderZ.Value = MaxSensitivity / 2;

            // Создание экземпляра джойстика
            joystick = new vJoy();
            joystick.AcquireVJD(joyID);

            // Configure the cursor mode module
            ConfigureRealSense();

            // Запуск потока Update
            update = new Thread(new ThreadStart(Update));
            update.Start();
        }

        public void ConfigureRealSense()
        {
            // Создание экземпляра SenseManager
            sm = PXCMSenseManager.CreateInstance();

            // Включение отслеживания указателя
            sm.EnableHandCursor();

            // Получение экземпляра модуля Hand Cursor
            cursorModule = sm.QueryHandCursor();

            // Получение экземпляра конфигурации указателя
            cursorConfig = cursorModule.CreateActiveConfiguration();

            // Создание и применение изменений конфигурации
            cursorConfig.EnableEngagement(true);
            cursorConfig.EnableAllGestures();
            cursorConfig.EnableAllAlerts();
            cursorConfig.ApplyChanges();

            // Инициализация конвейера SenseManager
            sm.Init();
        }

        private void Update()
        {
            bool handInRange = false;
            bool joyButton = false;

            // Запуск цикла AcquireFrame-ReleaseFrame
            while (sm.AcquireFrame(true).IsSuccessful())
            {
                PXCMCursorData cursorData = cursorModule.CreateOutput();
                PXCMPoint3DF32 adaptivePoints = new PXCMPoint3DF32();
                PXCMCursorData.BodySideType bodySide;

                // Получение текущих данных указателя
                cursorData.Update();

                // Проверка наличия данных оповещений
                for (int i = 0; i < cursorData.QueryFiredAlertsNumber(); i++)
                {
                    PXCMCursorData.AlertData alertData;
                    cursorData.QueryFiredAlertData(i, out alertData);

                    if ((alertData.label == PXCMCursorData.AlertType.CURSOR_NOT_DETECTED) ||
                        (alertData.label == PXCMCursorData.AlertType.CURSOR_DISENGAGED) ||
                        (alertData.label == PXCMCursorData.AlertType.CURSOR_OUT_OF_BORDERS))
                    {
                        handInRange = false;
                    }
                    else
                    {
                        handInRange = true;
                    }
                }

                // Проверка срабатывания жеста щелчка
                PXCMCursorData.GestureData gestureData;

                if (cursorData.IsGestureFired(PXCMCursorData.GestureType.CURSOR_CLICK, out gestureData))
                {
                    joyButton = !joyButton;
                }

                // Отслеживание указателя: находится ли он в пределах допустимой дальности
                int detectedHands = cursorData.QueryNumberOfCursors();

                if (detectedHands > 0)
                {
                    // Получение данных указателя с помощью индекса на основе порядка
                    PXCMCursorData.ICursor iCursor;
                    cursorData.QueryCursorData(PXCMCursorData.AccessOrderType.ACCESS_ORDER_NEAR_TO_FAR,
                                               0,
                                               out iCursor);

                    adaptivePoints = iCursor.QueryAdaptivePoint();

                    // Получение управляющей стороны тела (т. е. правая или левая рука)
                    bodySide = iCursor.QueryBodySide();

                    // Управление виртуальным джойстиком
                    ControlJoystick(adaptivePoints, joyButton);
                }
                else
                {
                    bodySide = PXCMCursorData.BodySideType.BODY_SIDE_UNKNOWN;
                }

                // Обновление пользовательского интерфейса
                Render(adaptivePoints, bodySide, handInRange, joyButton);

                // Возобновление обработки следующего кадра
                cursorData.Dispose();
                sm.ReleaseFrame();
            }
        }

        private void ControlJoystick(PXCMPoint3DF32 points, bool buttonState)
        {
            double joyMin;
            double joyMax;

            // Масштабирование данных по оси X
            joyMin = MaxSensitivity - joySensitivityX;
            joyMax = MaxSensitivity + joySensitivityX;
            int xScaled = Convert.ToInt32((joyMax - joyMin) * points.x + joyMin);

            // Масштабирование данных по оси Y
            joyMin = MaxSensitivity - joySensitivityY;
            joyMax = MaxSensitivity + joySensitivityY;
            int yScaled = Convert.ToInt32((joyMax - joyMin) * points.y + joyMin);

            // Масштабирование данных по оси Z
            joyMin = MaxSensitivity - joySensitivityZ;
            joyMax = MaxSensitivity + joySensitivityZ;
            int zScaled = Convert.ToInt32((joyMax - joyMin) * points.z + joyMin);

            // Обновление настроек джойстика
            joystick.SetAxis(xScaled, joyID, HID_USAGES.HID_USAGE_X);
            joystick.SetAxis(yScaled, joyID, HID_USAGES.HID_USAGE_Y);
            joystick.SetAxis(zScaled, joyID, HID_USAGES.HID_USAGE_Z);
            joystick.SetBtn(buttonState, joyID, 1);
        }

        private void Render(PXCMPoint3DF32 points,
                            PXCMCursorData.BodySideType bodySide,
                            bool handInRange,
                            bool buttonState)
        {
            Dispatcher.Invoke(delegate
            {
                // Изменение отображения границы, чтобы указать, находится ли рука в пределах допустимой дальности
                uiBorder.BorderBrush = (handInRange) ? Brushes.Green : Brushes.Red;

                // Масштабирование данных указателя для отображения
                double xScaled = uiCanvas.ActualWidth * points.x;
                double yScaled = uiCanvas.ActualHeight * points.y;
                uiCursor.Height = uiCursor.Width = points.z * 100;

                // Перемещение указателя по экрану
                Canvas.SetRight(uiCursor, (xScaled - uiCursor.Width / 2));
                Canvas.SetTop(uiCursor, (yScaled - uiCursor.Height / 2));

                // Обновление отображаемых значений данных
                uiX.Text = string.Format("X Axis: {0:0.###}", points.x);
                uiY.Text = string.Format("Y Axis: {0:0.###}", points.y);
                uiZ.Text = string.Format("Z Axis: {0:0.###}", points.z);
                uiBodySide.Text = string.Format("Controlling Hand: {0}", bodySide);
                uiButtonState.Text = string.Format("Button State (use 'Click' gesture to toggle): {0}",
                                                    buttonState);
            });
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            update.Abort();
            cursorConfig.Dispose();
            cursorModule.Dispose();
            sm.Dispose();
            joystick.ResetVJD(joyID);
            joystick.RelinquishVJD(joyID);
        }

        private void sldSensitivity_ValueChanged(object sender,
                                                 RoutedPropertyChangedEventArgs<double> e)
        {
            var sliderControl = sender as Slider;

            switch (sliderControl.Name)
            {
                case "uiSliderX":
                    joySensitivityX = sliderControl.Value;
                    break;
                case "uiSliderY":
                    joySensitivityY = sliderControl.Value;
                    break;
                case "uiSliderZ":
                    joySensitivityZ = sliderControl.Value;
                    break;
            }
        }
    }
}

Сведения о коде

Чтобы код был как можно проще, все методы заключены в один класс. Как показано в исходном коде в таблице 2, класс MainWindow состоит из следующих методов:

• MainWindow(): несколько частных классов и членов-переменных объявляются в начале класса MainWindow. В конструкторе MainWindow создаются экземпляры этих объектов и происходит инициализация переменных.
• ConfigureRealSense():этот метод обрабатывает создание объекта SenseManager и работу модуля Hand Cursor, а также настраивает модуль Cursor.
• Update(): согласно описанию в Справочном руководстве Intel RealSense SDKинтерфейс SenseManager может быть использован либо вызовами процедур, либо обратными вызовами событий. В приложении RSJoystick мы используем вызовы процедур в качестве методики взаимодействия. Они получают и высвобождают запуски циклов кадров в потоке Update() независимо от основного потока пользовательского интерфейса. Этот поток работает непрерывно; в нем мы получаем данные указателя, жестов и оповещений.
• ControlJoystick(): этот метод вызывается из метода Update() при обнаружении руки пользователя. Этому методу передаются данные Adaptive Point вместе с состоянием кнопки виртуального джойстика (оно переключается жестом CURSOR_CLICK). Данные Adaptive Point масштабируются на основе значений, полученных от ползунков регулировки чувствительности. С помощью ползунка и расчета масштабирования пользователь может выбирать масштаб значений, передаваемых в метод vJoy SetAxis(). Этот метод ожидает значения в диапазоне от 0 до 32 768. Если ползунок регулировки чувствительности установлен в максимальное положение, то соответствующие данные указателя будут преобразованы в значение в диапазоне от 0 до 32 768. При снижении чувствительности этот диапазон будет сужен для такой же траектории руки. Например: от 8192 до 24 576.
• Render(): этот метод вызывается из потока Update() и использует метод Dispatcher.Invoke() для выполнения операций с потоком пользовательского интерфейса. Это касается обновления положения эллипса на полотне и обновления значений данных в элементах управления TextBlock.
• sldSensitivity_ValueChanged(): этот обработчик событий срабатывает при регулировке положения ползунков.

Использование приложения

Можно проверить работу приложения, запустив vJoy Monitor в меню «Пуск» в Windows 10 (см. рис. 3). Как показано на рис. 7, можно отслеживать эффекты перемещения руки вдоль трех осей и выполнения жеста щелчка для переключения виртуальной кнопки 1.

Рисунок 7. Тестирование приложения с vJoy Monitor

Чтобы попробовать приложение в более интересном контексте, можно запустить симулятор полета в программе Google Планета Земля* (см. рис. 1). Согласно описанию на сайте, «Google Планета Земля — это виртуальные путешествия по всем уголкам Земли, спутниковые изображения, карты местности, трехмерные здания и самые разные объекты — от галактик в космосе до океанских впадин». (https://www.google.com/earth).

После загрузки и установки программы Google Планета Земля ознакомьтесь с инструкциями, приведенными здесь, для запуска симулятора полета. Сначала следует снизить чувствительность для осей X и Y в RSJoystick, чтобы движения руки не слишком сильно влияли на перемещение виртуального самолета. Для оси Z необходимо установить ползунок в максимальное положение. Немного привыкнув, вы сможете управлять виртуальным самолетом при помощи плавных движений руки.

Заключение

В этой статье приведено простое пошаговое руководство, в котором описывается создание приложения-эмулятора джойстика с помощью Intel RealSense SDK и использование модуля Hand Cursor, который поддерживается камерой SR300.

О технологии Intel RealSense

Дополнительные сведения о пакете Intel RealSense SDK для Windows см. по адресу https://software.intel.com/en-us/intel-realsense-sdk.

Об авторе

Брайан Браун (Bryan Brown) — инженер по разработке программных приложений в подразделении Software and Services Group корпорации Intel.  

Download PDF 1.38 MB

Введение

Unreal Game Engine 3 (UE3) компании Epic Games (https://epicgames.com/) — популярный модуль или «движок» для создания игр для ПК. Технология Intel® RealSense™используется для распознавания лиц и движения рук, чтобы расширить игровые возможности. В среде UE3 единственной рекомендацией является использование сценария Unreal в пакете Unreal Development Kit (UDK); настраиваемые функции следует добавлять в UDK в качестве подключаемого модуля, но в составе Intel® RealSense™ SDKнет подключаемого модуля для UDK.

В этой статье описывается добавление возможностей Intel RealSense SDK в средства управления игровыми персонажами в играх жанра MMORPG (массовые многопользовательские сетевые ролевые игры) в UE3 с помощью C++, а не сценариев Unreal. Определение и изменение структуры лица персонажа называется «монтажом лиц». Существует несколько способов монтажа лиц в игре, но мы рассмотрим применение Intel RealSense SDK в качестве способа изменения структуры лицевых костей игровых персонажей, в том числе вопросы производительности и нагрузки.

В этой статье содержится следующее.

• Описание способа монтажа лиц.
• Использование Autodesk 3ds Max* вместе с Unreal Engine.
• Описание систем координат в Unreal: X-Y-Z, эйлеровы углы (поворот вокруг продольной, поперечной и вертикальной осей) и кватернионы.
• Включение Intel RealSense SDK в Unreal Engine.
• Соединение алгоритма Intel RealSense SDK с игровым движком.

Монтаж лиц в игре

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

• Анимация с использованием сценариев. Заранее просчитанная анимация широко распространена в играх, но ее сложно применить для монтажа лиц в реальном времени. Впрочем, если нужно, чтобы выражение лица изменилось в соответствии с какой-либо простой эмоцией, это наилучший и самый простой способ. Для управления анимацией используется сценарий Unreal или Matinee.
• Коммерческая программа для монтажа лиц — FaceFX*. FaceFX — коммерческий инструмент для монтажа лиц компании OC3 Entertainment (https://www.facefx.com), поддерживающий Unreal. Этот инструмент предварительно лицензирован в Unreal Engine 3. В FaceFX поддерживается монтаж всего тела и изменение лиц персонажей.
• Целевая трансформация. В предыдущем образце кода Intel RealSense SDK с монтажом лиц в Unity (Angie) использовалась трансформация Morph. Это простой способ применения Intel RealSense SDK в игре, но при этом необходимо создавать цель трансформации для каждого персонажа. В MMORPG-играх обычно бывает от трех до шести рас или племен, при этом игрок может изменять и лицо, и тело своего персонажа, поэтому суммарное количество возможных сочетаний измеряется тысячами. При этом потребуется несколько тысяч Morph-ресурсов лица, а производительность ниже по сравнению с управлением костями.
• Управление костями. Если Intel RealSense SDK может определять координаты костей, этот метод вполне применим в играх. Даже при наличии нескольких тысяч возможных сочетаний персонажей существует сравнительно немного лицевых структур (количество рас, умноженное на два пола). Кроме того, этот метод не повлияет на отображение и на производительность игры.

Например, в MMORPG-игре Bless* (http://bless-source.com/, http://bless.pmang.com/) существует 10 племен, но только 8 типов лицевых костей: у эльфов (двух полов), волков (двух полов), людей (двух полов) и расы «маску» (двух полов). Полный список наименований костей см. в разделе «Структура костей лица» в конце этого документа.

Рисунок 1. Игровые персонажи в MMORPG-игре

Среда

• Компьютер для тестирования: процессор Intel® Core™ i7-5775C, 16 ГБ ОЗУ DDR, твердотельный накопитель (SSD) объемом 256 ГБ. Рекомендуемая конфигурация: мощный ЦП, например Intel® Core™ i7 6-го поколения (Skylake), мощный внешний графический адаптер и твердотельный накопитель с достаточным объемом пустого пространства (не менее 50 ГБ). Рекомендуется использовать твердотельные накопители вместо жестких дисков для повышения скорости ввода-вывода. Камера Intel® RealSense™ (F200) или обычная веб-камера.
• Microsoft Windows* 7, 64-разрядная версия
• Autodesk 3ds Max 2014
• Исходный код Epic Games Unreal Engine 3 source code (требуется лицензия)
• Microsoft Visual Studio* 2010
• Intel RealSense SDK 6.0.21.6598 и Intel® RealSense™ Depth Camera Manager 1.4.27.41944

Установка

1. Установите 64-разрядную версию Windows 7 на компьютер, обновите драйверы для всех устройств.
2. Скопируйте исходный код UE3 на локальный диск.
3. Установите и обновите Microsoft Visual Studio 2010. Если требуется отладка в Visual Studio 2010, необходимо включить сценарий отладки. См. автоматическое расширение установки отладчика.
4. (Необязательно) Установите Autodesk 3ds Max 2014, если нужно экспортировать FBX-файл из MAX-файла.

Экспорт MAX-файла в формат FBX для импорта в UE3

В большинстве распространенных программ трехмерного моделирования, таких как Autodesk 3ds Max или Maya*, поддерживается экспорт трехмерных моделей в Unreal Engine или Unity* посредством файлов в формате FBX.

Описанные действия предназначены для Autodesk 3ds Max 2014.

1. Откройте MAX-файл со структурой костей. Показано расположение костей и внешний вид.

   
   Рисунок 2.Откройте MAX-файл

2. Экспортируйте этот файл в формат FBX. Если появится предупреждение о том, что режим by-layer не поддерживается, включите режим by-object для правильного экспорта.

   
   Рисунок 3.Экспорт в формат FBX

3. Выберите все объекты, щелкните правой кнопкой мыши и выберите Object Properties.

   
   Рисунок 4.Параметры экспорта

4. Нажмите кнопку By Object для переключения режима by-layer.

   
   Рисунок 5.Параметры экспорта: режим by-layer

5. Выберите Menu, затем выберите Export. Введите имя экспортируемого файла в поле FBX. Можно выбрать animation и bake animation для проверки анимации в UE3.

   
   Рисунок 6.Экспорт с анимацией

Импортируйте FBX-файл в UE3 Editor
Если вы используете автономную версию UE3 в стандартной конфигурации (DirectX* 9, 32-разрядная версия), можно использовать редактор Unreal Editor.

1. Запустите UE3 Editor с помощью следующих команд.

   Выполните команду CMD и перейдите в папку UE3 (в моем случае это папка C:\UE3).
   Перейдите в папку \Binaries\Win32\.
   Выполните команду examplegame.exe editor -NoGADWarning.

   
   Рисунок 7. Запуск Unreal Editor

2. В окне Content Browser щелкните Importи выберите FBX file. Нажмите кнопку OKдля импорта. После импорта можно просмотреть объекты Animset, SkeletonMesh и прочие.

   
   Рисунок 8.Unreal Editor: окно Content Browser

3. Чтобы проверить импортированный FBX-файл, щелкните правой кнопкой мыши Animsetи выберите Edit Using AnimSet Viewer.

   
   Рисунок 9.Unreal editor - AnimSet Viewer

4. Можно отрегулировать размер и положение лица с помощью кнопок мыши (левая кнопка — поворот, средняя кнопка — положение, правая кнопка — масштаб). Слева отображаются наименования костей, справа — скелеты. При воспроизведении анимации также будет показано время кадра и разница положения и поворота.

   
   Рисунок 10.AnimSet Viewer.

   
   Рисунок 11.AnimSet Viewer: регулировка масштаба

5. Выберите нужную кость (на этих рисунках выбрана кость BN_Ear_R 53) и систему координат X-Y-Z. Для перемещения перетащите вдоль осей X, Y или Z.

   
   Рисунок 12.AnimSet Viewer: проверка кости

6. Для проверки в системе координат с эйлеровыми углами (поворот вокруг поперечной, продольной и вертикальной осей) нажмите пробел. При смене системы координат у правого уха будет показана эйлерова система координат. Для регулировки поворота перетаскивайте окружности P-Y-R.

   
   Рисунок 13.Смена системы координат

Создание карт и уровней в UE3 Editor

Пропустите этот раздел, если вы планируете использовать существующий файл карты или уровня. Действия, перечисленные в этом разделе, приведут к созданию простых кубов, источника света, камеры и актера (лицевой кости).

1. Запустите UE3 Editor с помощью следующих команд.
   
   Выполните команду CMD и перейдите в папку UE3 (в моем случае это папка C:\UE3).
   Перейдите в папку \Binaries\Win32\.
   Выполните команду examplegame.exe editor -NoGADWarning.

2. Используйте один из уровней шаблона или самостоятельно создайте простой уровень. Нажмите кнопку BSP Cubeправой кнопкой мыши. Во всплывающем окне введите 1024 в качестве значения для параметров X, Y, Z и установите флажок Hollow?. Затем на панели инструментов слева щелкните Add.

   
   Рисунок 14. Unreal Editor: создание слоя

3. Для передвижения куба используйте клавиши WASD или клавиши со стрелками и мышь. Также можно использовать перетаскивание, удерживая нажатыми левую, среднюю или правую кнопки мыши для перемещения камеры.

   
   Рисунок 15. Unreal Editor: начальное расположение

4. Чтобы добавить начальное расположение в игру, щелкните пол правой кнопкой мыши, выберите Add Actor, затем выберите Add Playerstart.

5. Чтобы добавить источник света, щелкните стену правой кнопкой мыши, выберите Add Actor, затем выберите Add Light(Point).

   
   Рисунок 16. Unreal Editor: добавление света

6. Чтобы добавить лицевую кость актера, нажмите клавишу Tabдля перемещения обозревателя содержимого и перетащите трехмерную модель скелета в UE Editor.

   
   Рисунок 17. Unreal Editor: добавление актера

7. Для регулировки размера введите коэффициент масштабирования в правом нижнем углу.

8. Для регулировки положения выберите значок Translation modeв левом верхнем углу. Для перемещения персонажа используйте координаты X-Y-Z.

9. Для регулировки поворота выберите значок Rotation modeв левом верхнем углу. Для перемещения персонажа используйте координаты P-Y-R.

   
   Рисунок 18: Unreal Editor: регулировка поворота

10. Сохраните уровень, указав его имя. Например, я использовал test.umap в папке \ExampleGame\Content\Maps.

    
    Рисунок 19. Unreal Editor: сохранение

11. Скомпилируйте весь проект. В меню выберите Build, затем выберите Build All.

12. Чтобы проверить карту, щелкните Playили нажмите клавиши Alt+F8.

    
    Рисунок 20. Unreal Editor: сборка

13. Сохраните файл и закройте UE Editor.

Можно продолжить изучение использования этого файла карты в качестве источника при добавлении функций Intel RealSense SDK в статье Учебное руководство: использование технологии Intel® RealSense™ в Unreal Engine 3. Часть 2..

Об авторах

Чангйин Ким (Chunghyun Kim) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Он занимается оптимизацией игр и графики в архитектуре Intel®.

Питер Хонг (Peter Hong) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Его специализация — применение Intel RealSense SDK для отслеживания лица и рук, трехмерного сканирования и других целей.

Download PDF 854 KB

GoTutorial: Использование технологии Intel® RealSense™ в Unreal Engine* 3. Часть 1 

В первой части мы создали простую карту игры со структурой костей лица в редакторе Unreal 3. Здесь, во второй части, мы покажем, как использовать возможности Intel RealSense SDKв игре на движке Unreal.

Настройка Visual Studio 2010 для образца игры

Приведенные ниже действия настраивают ваш файл карты в качестве карты по умолчанию для примера игры путем редактирования файла INI.

1. Перейдите в папку \ExmapleGame\Config.
2. Откройте файл DefaultEngine.ini и отредактируйте его, как показано ниже.

[URL]

MapExt=umap

Map=test.umap

LocalMap=BLrealsense_Map.umap

TransitionMap=BLrealsense_Map.umap

EXEName=ExampleGame.exe

DebugEXEName=DEBUG-ExampleGame.exe

GameName=Example Game

GameNameShort=EG

1. Откройте файл ExampleEngine.ini и отредактируйте его, как показано ниже.

   [URL]

   Protocol=unreal

   Name=Player

   Map=test.umap

   LocalMap=BLrealsense_Map.umap

   LocalOptions=

   TransitionMap=BLrealsense_Map.umap

   MapExt=umap

   EXEName=ExampleGame.exe

   DebugEXEName=DEBUG-ExampleGame.exe

   SaveExt=usa

   Port=7777

   PeerPort=7778

   GameName=Example Game

   GameNameShort=EG

2. Откройте файл проекта или решения UE3 Visual Studio в папке \Development\Src – UE3.sln либо откройте UE3.sln в Visual Studio.
   
   Рисунок 1. Microsoft Visual Studio* 2010.

3. Соберите и запустите приложение, как описано ранее. Появится начальное окно Unreal и ваша игра.

Использование системы координат в Unreal Engine

Перед компоновкой с Intel® RealSense™ SDKважно понять систему координат в Unreal.

Положение отслеживается по осям X-Y-Z (см. классы Origin и RotOrigin в исходном коде UE3), а поворот — по эйлеровым углам (P-Y-R) и кватернионам (дополнительные сведения см. в статье https://en.wikipedia.org/wiki/Quaternion for more detail). 

Рисунок 2. Система координат

У кватерниона поворота вокруг поперечной оси — один скалярный множитель и три векторных множителя.

Для преобразования эйлеровых углов в кватернионы

Углы X-Y-Z

Автоматическое расширение установки отладчика в Visual Studio 2010 (необязательно)

Символы отладки массива структуры костей, расположения и поворота изначально были зашифрованы и не отображаются в Visual Studio в доступном для чтения виде. Для просмотра символов отладки выполните перечисленные ниже действия.

1. Найдите файл Autoexp.dat.
    

   В Visual Studio под управлением 64-разрядной версии Windows 7 он находится в папке C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\Packages\Debugger.

2. Найдите сценарий отладки и откройте его.
    

   Папка UE3\ Development/External/Visual Studio Debugging/AUTOEXP.DAT_addons.txt

3. Скопируйте все разделы [AutoExpand] и [Visualizer] в файл Autoexp.dat.

Включение поддержки Intel® RealSense™ SDK в Unreal Engine 3

В этом разделе описываются изменения в Unreal Engine 3, связанные с Intel RealSense SDK. Эти изменения необходимо применить после установки Intel RealSense SDK и Depth Camera Manager. API отслеживания реперных точек на лице и положения головы в Intel RealSense SDK используются для обработки выражения лица и движения головы персонажа. Отслеживание положения головы осуществляется интуитивно, поскольку значения поворота вокруг продольной, поперечной и вертикальной осей можно использовать в Unreal Engine 3 без дополнительных изменений. Отслеживание реперных точек на лице выполняется несколько сложнее.

Рисунок 3.Повороты вокруг трех осей

Intel RealSense SDK предоставляет 76 отслеживаемых точек на лице. Для каждого выражения лица (например, для подмигивания или открытого рта) у соответствующих точек есть определенный диапазон значений. Например, если глаз закрыт, то расстояние между точками 12 и 16 будет близко к 0, а при открытом глазе это расстояние будет больше 0, причем оно будет различаться у разных людей.

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

Рисунок 4.Реперные точки на лице и их номера в Intel® RealSense™ SDK

<UE3> — папка, в которую установлен UE3. Необходимо изменить следующие четыре файла.

• <UE3>\Development\Src\UnrealBuildTool\Configuration\UE3BuildConfiguration.cs
• <UE3>\Development\Src\UnrealBuildTool\Configuration\UE3BuildWin32.cs
• <UE3>\Development\Src\Engine\Inc\UnSkeletalMesh.h
• <UE3>\Development\Src\Engine\Src\UnSkeletalComponent.cpp

UE3BuildConfiguration.cs (необязательно)

public static bool bRealSense = true;

Важные для RealSense коды заключены во фразу «#if USE_REALSENSE». Это предложение используется для определения фразы «#if USE_REALSENSE» в файле UE3BuildWin32.cs. Если изменить код, указав значение false, ссылка на соответствующий код RealSense не будет задействована при компиляции. Это необязательно.

UE3BuildWin32.cs

if (UE3BuildConfiguration.bRealSense)
{
SetupRealSenseEnvironment();
}

void SetupRealSenseEnvironment()
{
      GlobalCPPEnvironment.Definitions.Add("USE_REALSENSE=1");
      String platform = (Platform == UnrealTargetPlatform.Win64 ? "x64" : "Win32");

      GlobalCPPEnvironment.SystemIncludePaths.Add("$(RSSDK_DIR)/include");
      FinalLinkEnvironment.LibraryPaths.Add("$(RSSDK_DIR)/lib/" + platform);

      if (Configuration == UnrealTargetConfiguration.Debug) {
           FinalLinkEnvironment.AdditionalLibraries.Add("libpxc_d.lib");
      } else {
           FinalLinkEnvironment.AdditionalLibraries.Add("libpxc.lib");
      }
}

Определение USE_REALSENSE, которое будет использовано для включения или отключения Intel RealSense SDK в исходном коде (необязательно).

Поскольку Unreal Engine 3 работает на основе makefile, необходимо добавлять файл заголовка Intel RealSense SDK и путь к библиотеке в раздел include проекта и в путь к библиотекам.

UnSkeletalMesh.h

#if USE_REALSENSE
	PXCFaceData* faceOutput;
	PXCFaceConfiguration *faceConfig;
	PXCSenseManager *senseManager;

	void InitRealSense();
	void ReleaseRealSense();
#endif

Это часть объявления классов и функций Intel RealSense SDK. Фрагмент, отвечающий за работу со структурой костей, находится в разделе UpdateSkelPos() файла UnSkeletalComponent.cpp.

UnSkeletalComponent.cpp

#if USE_REALSENSE
	#include "pxcfacedata.h"
	#include "pxcfacemodule.h"
	#include "pxcfaceconfiguration.h"
	#include "pxcsensemanager.h"

	FLOAT rsEyeMin = 6;
	FLOAT rsEyeMax = 25;

	FLOAT rsMouthMin = 5;
	FLOAT rsMouthMax = 50;

	FLOAT rsMouthWMin = 40;
	FLOAT rsMouthWMax = 70;

	FLOAT chMouthMin = -105;
	FLOAT chMouthMax = -75;
……
#endif

Включите файлы заголовков Intel RealSense SDK. Определяет минимальные и максимальные значения пользователя и игровых персонажей. Начинается с rs (значение пользователя) или с ch (значение игрового персонажа). Эти значения должны изменяться в соответствии с внешним видом пользователя и игрового персонажа. Например, при моргании определяется расстояние при открытом и при закрытом глазе, и в соответствующей пропорции эти данные применяются к персонажу игры.

void USkeletalMeshComponent::Attach()
{
……
#if USE_REALSENSE
	senseManager = NULL;
	InitRealSense();
#endif

Функция Attach() вызывает функцию InitRealSense() для инициализации классов, относящихся к Intel RealSense SDK и настройки камеры.

#if USE_REALSENSE
void USkeletalMeshComponent::InitRealSense() {
	if (senseManager != NULL) return;

	faceOutput = NULL;

	senseManager = PXCSenseManager::CreateInstance();
	if (senseManager == NULL)
	{
 // обнаружена ошибка
	}

	PXCSession *session = senseManager->QuerySession();
	PXCCaptureManager* captureManager = senseManager-> QueryCaptureManager();

Функция InitRealSense() указывает, какая камера будет использоваться, и создает соответствующие экземпляры классов для распознавания лиц.

void USkeletalMeshComponent::UpdateSkelPose( FLOAT DeltaTime, UBOOL bTickFaceFX )
{
……
#if USE_REALSENSE
if (senseManager->AcquireFrame(false) >= PXC_STATUS_NO_ERROR) {
	faceOutput->Update();
	int totalNumFaces = faceOutput->QueryNumberOfDetectedFaces();
	if (totalNumFaces > 0) {

Функция UpdateSkelPose() используется для отслеживания положения головы и реперных точек на лице.

// Голова
FVector v(yaw, roll, pitch);

LocalAtoms(6).SetRotation(FQuat::MakeFromEuler(v));
LocalAtoms(6).NormalizeRotation();

Отслеживание положения головы осуществляется интуитивно, поскольку значения поворота вокруг продольной, поперечной и вертикальной осей из Intel RealSense SDK можно использовать без каких-либо дополнительных изменений и вычислений.

Рисунок 5. Реперные точки на лице и номера, используемые при различных выражениях лица (мимика рта, открытые или закрытые глаза)

Для моргания используются реперные точки 12, 16 и 20, 24, а для мимики рта — 47, 51, 33, 39 (подробности реализации зависят от предпочтений разработчиков).

// Рот
FLOAT mouthOpen = points[51].image.y - points[47].image.y;
mouth = chMouthMax - (mouthOpen - rsMouthMin) * mouthRatio;

mouthOpen = points[47].image.x - points[33].image.x;
rMouthWOpen = chMouthWMin + (mouthOpen - rsMouthWMin) * mouthWRatio;

mouthOpen = points[39].image.x - points[47].image.x;
lMouthWOpen = chMouthWMin + (mouthOpen - rsMouthWMin) * mouthWRatio;

cMouth = chMouthCMax - (mouthOpen - rsMouthWMin) * mouthCRatio;

// Левый глаз
FLOAT eyeOpen = points[24].image.y - points[20].image.y;
lEyeInner = chEyeInnerMin + (eyeOpen - rsEyeMin) * innerEyeRatio;
lEyeOuter = chEyeOuterMin + (eyeOpen - rsEyeMin) * outerEyeRatio;
lEyeUpper = chEyeUpperMin + (eyeOpen - rsEyeMin) * upperEyeRatio;

// Правый глаз
eyeOpen = points[16].image.y - points[12].image.y;
rEyeInner = chEyeInnerMin + (eyeOpen - rsEyeMin) * innerEyeRatio;
rEyeOuter = chEyeOuterMin + (eyeOpen - rsEyeMin) * outerEyeRatio;
rEyeUpper = chEyeUpperMin + (eyeOpen - rsEyeMin) * upperEyeRatio;
rEyeLower = chEyeLowerMin + (eyeOpen - rsEyeMin) * lowerEyeRatio;

BN_Lips_Corner_R, BN_Lips_Corner_L, BN_Jaw_Dum используются для мимики рта, а BN_Blink_UpAdd, BN_Blink_Lower, BN_Blink_Inner, BN_Blink_Outer — для моргания. (Номера всех костей см. в разделе «Структура костей лица в примерах персонажей».)

// Рот
FVector m(90, 0, mouth);
LocalAtoms(59).SetRotation(FQuat::MakeFromEuler(m));

LocalAtoms(57).SetTranslation(FVector(mouthWXZ[2], rMouthWOpen, mouthWXZ[3])); // Правая сторона
LocalAtoms(58).SetTranslation(FVector(mouthWXZ[4], lMouthWOpen * -1, mouthWXZ[5])); // Левая сторона

// Левый глаз
LocalAtoms(40).SetTranslation(FVector(eyeXY[0], eyeXY[1], lEyeUpper)); // Верхняя часть
LocalAtoms(41).SetTranslation(FVector(eyeXY[2], eyeXY[3], lEyeLower)); // Нижняя часть
LocalAtoms(42).SetTranslation(FVector(eyeXY[4], eyeXY[5], lEyeInner)); // Внутренняя часть
LocalAtoms(43).SetTranslation(FVector(eyeXY[6], eyeXY[7], lEyeOuter)); // Внешняя часть

// Правый глаз
LocalAtoms(47).SetTranslation(FVector(eyeXY[8], eyeXY[9], rEyeLower)); // Нижняя часть
LocalAtoms(48).SetTranslation(FVector(eyeXY[10], eyeXY[11], rEyeOuter)); // Внешняя часть
LocalAtoms(49).SetTranslation(FVector(eyeXY[12], eyeXY[13], rEyeInner)); // Внутренняя часть
LocalAtoms(50).SetTranslation(FVector(eyeXY[14], eyeXY[15], rEyeUpper)); // Верхняя часть

void USkeletalMeshComponent::ReleaseRealSense() {
	if (faceOutput)
		faceOutput->Release();

	faceConfig->Release();
	senseManager->Close();
	senseManager->Release();
}

Закройте и высвободите все экземпляры соответствующих классов Intel RealSense SDK.

Структура костей лица в примерах персонажей

В этом примере лицо состоит из 58 костей. На рисунке каждый прямоугольник соответствует одной кости. Ниже следует полный список наименований костей.

Рисунок 6.Наименования костей

Заключение

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

Об авторах

Чангйин Ким (Chunghyun Kim) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Он занимается оптимизацией игр и графики в архитектуре Intel®.

Питер Хонг (Peter Hong) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Его специализация — применение Intel RealSense SDK для отслеживания лица и рук, трехмерного сканирования и других целей.

Дополнительные сведения

Epic Unreal Engine
https://www.unrealengine.com

Intel RealSense SDK
http://software.intel.com/realsense

Часть 1

Сложность профилей настройки технологии Intel® Active Management (Intel® AMT)зависит от задействованных компонентов. При интеграции Intel AMT в консоль управления прежде всего необходимо определить, какие компоненты должна поддерживать консоль.

Изучить различные варианты настройки можно в мастере ACU. Эта программа входит в состав загружаемого пакета Intel® Setup and Configuration Software (Intel® SCS). Дополнительные сведения о доступных вариантах см. в документации к Intel SCS, входящей в состав загружаемого пакета Intel SCS.

Интеграция настройки на основе хоста в консоль

Чаще всего при интеграции в консоль используется настройка на основе хоста. В этом методе применяется ОС хоста (Windows* 7 или более поздней версии) и сценарий для проведения настройки.

В этой статье показано, как мастер ACU создает образец профиля настройки. Профиль предоставляет нужный XML-код, поэтому консоль может создавать и шифровать настройку для развертывания на устройствах Intel AMT.

Примечание. Если консоль создает XML-файл профиля, следует зашифровать этот файл с помощью программы SCSEncryption.exe перед развертыванием на устройстве Intel AMT. Если не использовать шифрование, файл будет отправлен клиенту в виде обычного текста, при этом все пароли в файле profile.xml будут уязвимы.

Для автоматизации процесса настройки нужно создать файл profile.xml и сценарий, выполняющий настройку. Вот основные действия.

1. Скопируйте папку Configurator и файл profile.xml из папки загрузки SCS в расположение, доступное для клиента Intel AMT (в локальную папку, в сетевую папку, на USB-накопитель и т. д.).
2. Откройте командную строку с правами администратора, перейдите в папку acuconfigи выполните следующую команду: "acuconfig.exe configamt <profile.xml> /decryptionpassword <PASSWORD>"
3. Настройка считается успешной при выходе программы с кодом 0.

Настройка на основе хоста, как описано выше, обладает одним существенным недостатком: невозможно настроить устройство Intel AMT в режим управления администратора. Незначительно изменив профиль настройки, можно организовать доступ микропрограммы к серверу установки и настройки, к сертификату подготовки. Дополнительные сведения о режиме управления администратора и режиме управления клиента см. в разделе Установка и настройка интеграции Intel vPro.

Использование мастера ACU

Мастер ACU поддерживает несколько методов настройки устройств Intel AMT. В рамках этой статьи нам нужен лишь один из способов для получения нашего образца XML-файла. Чтобы создать файл profile.xml с помощью мастера ACU, выполните следующие действия.

1. Создайте профиль. Для этого откройте мастер ACU и выберите Создать параметры для настройки нескольких систем. option.
   
2. Откроется окно Intel® AMT Configuration Utility: Profile Designer.
3. Щелкните зеленый плюс.
4. Когда откроется мастер профилей настройки, нажмите кнопку Далее.
5. Когда откроется окно дополнительных параметров мастера профилей настройки, нажмите кнопку Далее.
6. Откроется окно системных параметров мастера профилей настройки.
   1. Введите пароль RFB, если включено шифрование (не обязательно).
      1. RFB — это протокол удаленного кадрового буфера, он также называется RFB5900. Если включить пароль RFB, можно будет использовать стандартное средство просмотра VNC, использующее порт 5900, вместо средства просмотра VNC, предназначенного для Intel AMT, которое также использует порт 16994 или 16995.
   2. Введите пароль в поле Использовать следующий пароль для всех систем.
   3. Для изменения параметров сети нажмите кнопку Задать... button.
      1. Если в ОС хоста включен протокол DHCP, изменения не требуются. Обратите внимание на изменения, которые необходимы, если в ОС используется статический IP-адрес.
      2. Нажмите кнопку Отмена.
   4. Нажмите кнопку Далее.
      
7. Откроется окно «Мастер профилей настройки — готово».
   1. Введите нужное имя профиля, например «profile».
   2. Зашифруйте XML-файл, добавив и подтвердив пароль.
   3. Нажмите кнопку Готово.
      
8. Откроется окно Intel® AMT Configuration Utility: Profile Designer.
   1. Обратите внимание на путь к профилю, показанный на экране.
      1. Он должен выглядеть примерно так: <имя пользователя>\documents\SCS_Profile.
   2. Закройте мастер ACU.

Примечание. Подробные инструкции по использованию мастера ACU см. в документации в загружаемом пакете Intel® SCS.

Использование файла Profile.xml

Итак, у нас есть зашифрованный файл profile.xml. Теперь нужно расшифровать этот файл, чтобы раскрыть параметры настройки, с помощью программы SCSEncryption.exe, входящей в состав загружаемого пакета Intel SCS. После расшифровки можно будет открыть файл в программе просмотра XML и увидеть XML-теги.

Синтаксис расшифровки:

>SCSEncryption.exe Decrypt <имя входного файла> <пароль> /Output <имя выходного файла>

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

Выбор режима управления

В процессе настройки устройство Intel AMT будет переведено в один из двух режимов: режим управления клиента или режим управления администратора. Основное различие заключается в том, что в режиме управления клиентатребуется согласие пользователядля операций перенаправления, а в режиме управления администратора оно не нужно.

Согласие пользователя

Функция согласия пользователей обеспечивает дополнительный уровень безопасности для удаленных пользователей. Требуется отправка кода согласия пользователя, если возникает необходимость перенаправления или управления удаленным клиентом. Например, доступ через удаленный KVM-коммутатор или выполнение команды IDEr считается операцией перенаправления, а получение состояния электропитания или перезагрузка не считаются такими операциями.

Дополнительные ресурсы

• Дополнительные сведения о режиме управления администратора и режиме управления клиента.
• Загрузить Intel® SCS.
• Руководство по внедрению и справочное руководство Intel® AMT.
• Модуль PowerShell Intel® AMT.
• Загрузить Intel® AMT SDK.
• Установка и настройка интеграции Intel vPro.

Заключение

При управлении устройствами, поддерживающими Intel AMT, одной из наиболее важных задач является настройка. Процесс настройки достаточно прост при использовании ACUconfig.exe, но процесс создания профиля требует более подробного рассмотрения.

С помощью ACUWizard.exe можно создать образец файла profile.xml, демонстрирующий возможности создания динамических консольных профилей, поэтому нет необходимости использовать какой-либо определенный статический профиль. Это дает нам возможность управлять устройствами Intel AMT в более широких пределах, настраивать согласие пользователей, беспроводные профили, списки управления доступом Active Directory и т. д.

Об авторе

Джо Остер (Joe Oster) работает в корпорации Intel с 2006 года, он занимается технологиями Intel® vPro™ и Intel AMT. Свободное время он проводит на ферме своей семьи или управляет дронами и радиоуправляемыми самолетами.

Веление времени: развитие управления с помощью жестов

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

Управление с помощью жестов достаточно интенсивно развивается в области игр, а технология Intel® RealSense™ — одна из передовых разработок в этом направлении. Интеграция управления жестами в настольные ПК была вопросом времени. Привычная клавиатура и мышь были дополнены расширенной системой голосовых команд и жестов. Представьте все доступные возможности. Можно запустить или остановить воспроизведение фильма, произнеся соответствующие команды вслух, а для приостановки и перемотки достаточно простого набора жестов. Также можно управлять сложным трехмерным объектом в системе автоматического проектирования на большом настенном экране с помощью рук, передавая различные элементы модели коллегам.

Такова концепция компании Ideum из города Корралес, шт. Нью-Мексико, США. Эта компания создает современные системы взаимодействия с пользователями. Компания была образована свыше 15 лет назад и занималась проектированием и внедрением мультисенсорных столов, киосков и настенных панелей. Решения этой компании используются в ведущих учреждениях, в том числе в Чикагском музее естественной истории им. Филда, в Смитсоновском музее поселений американских индейцев, в музее современного искусства в Сан-Франциско. Для работы над решением GestureWorks Fusion * разработчики Ideum решили задействовать технологию Intel RealSense.

В программе GestureWorks Fusion специалисты Ideum стремятся совместить удобство и простоту управления с помощью жестов и голоса с возможностью управления широким набором приложений для настольных ПК, начиная с воспроизведения поточного мультимедиа. Вопросы и возможности, с которыми столкнулись разработчика Ideum, можно считать общими для всех новшеств в области взаимодействия человека и компьютера.

В этом примере описываются решение GestureWorks и использование многорежимного ввода для создания мощной и интуитивной системы, способной интерпретировать жесты и голосовые команды. Показано, как разработчики Ideum использовали Intel® RealSense™ SDKи новый режим Cursor, позволяющий им быстро и удобно взаимодействовать с традиционными приложениями, разработанными для клавиатуры и мыши. Кроме того, в статье описываются проблемы, с которыми столкнулись проектировщики и разработчики, и описываются подходы к решению этих проблем при помощи сочетания технологий Intel и Ideum.

Представляем GestureWorks Fusion *

GestureWorks Fusion — это приложение, использующее камеру Intel® RealSense™ SR300для получения многорежимного ввода, например жестов и голосовых команд. В первоначальной версии этого программного продукта пользователи могут интуитивно управлять работой веб-сайтов для воспроизведения поточного видео, таких как YouTube *. Используя традиционные элементы управления графического пользовательского интерфейса, пользователи могут воспроизводить, приостанавливать, перематывать видео, не дотрагиваясь до мыши, клавиатуры и экрана. Благодаря прямой обратной связи система очень удобна в использовании и освоении.

GestureWorks Fusion * дает возможность удобно и интересно использовать веб-сайты поточного видео, например YouTube *, используя для управления интуитивные голосовые команды и жесты, если система оборудована камерой Intel® RealSense™ SR300.

Камера Intel RealSense SR300 является усовершенствованием камеры Intel RealSense F200, которая в свое время была одной из первых и самых компактных камер со встроенными модулями съемки двухмерного изображения и глубины. Как и в модели F200, в камере Intel RealSense SR300 реализована возможность съемки цветного изображения высокой четкости с разрешением 1080p и расширенные возможности трехмерной съемки, причем увеличена допустимая дальность действия. Вместе с микрофоном эта камера является идеальным решением для отслеживания головы и рук, а также для распознавания лица. «В камере Intel RealSense SR300 нас привлекает то, что эта камера может делать все это одновременно, очень быстро и исключительно надежно», — поясняет Пол Лейси (Paul Lacey), технический директор компании Ideum и руководитель группы разработки GestureWorks.

Решение GestureWorks Fusion опирается на возможности и наработки двух существующих продуктов компании Ideum: GestureWorks Core и GestureWorks Gameplay 3. GestureWorks Gameplay 3 — это приложение для Microsoft Windows *, обеспечивающее сенсорное управление в популярных играх на ПК. Пользователи могут создавать собственные сенсорные элементы управления, обмениваться ими с другими пользователями или загружать элементы управления, созданные сообществом.

GestureWorks Core — это система многорежимного взаимодействия, проводящая полный трехмерный анализ жестов головы и рук и поддерживающая взаимодействие с помощью мультисенсорного ввода и голоса. В GestureWorks Core SDK представлено свыше 300 готовых жестов и поддерживаются наиболее распространенные языки программирования, в том числе C++, C#, Java * и Python *.

Изначально программа GestureWorks Fusion была разработана для работы с Google Chrome * и Microsoft Internet Explorer * под управлением Microsoft Windows 10. При этом предполагается, что GestureWorks Fusion будет работать с любыми системами, оборудованными камерой Intel RealSense. Компания также планирует развить свою систему, чтобы она смогла работать с широким набором приложений, в том числе с играми, офисными приложениями и программами для презентаций.

Проблемы и решения

Специалисты Ideum столкнулись с несколькими проблемами, стремясь сделать решение GestureWorks интуитивным и удобным в использовании, особенно для новых пользователей. Разработчики уже обладали опытом создания мультисенсорных столов и стеновых панелей для общественных учреждений и знали, что пользователей раздражает, если техника работает не так, как они ожидают. Опираясь на этот опыт, проектировщики решили сделать жесты как можно более простыми и сосредоточиться на наиболее привычном поведении.

В GestureWorks * Fusion используется простой набор жестов, напрямую связанных с пользовательским интерфейсом приложения; реализуется доступ к популярным существующим приложением без использования традиционного или сенсорного интерфейса.

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

Более того, для интерфейсов такого типа важна возможность интуитивно включать и отключать управление при помощи жестов. Человек интуитивно понимает, какие жесты являются значимыми и в каких обстоятельствах. Приложению, в отличие от человека, для анализа жестов требуется контекст. В GestureWorks Fusion достаточно поднять руку в поле зрения камеры, чтобы включить интерфейс управления с помощью жестов. Если рука выходит из поля зрения камеры, интерфейс жестов исчезает; такой подход аналогичен отображению дополнительной информации при наведении указателя мыши.

Сам по себе многорежимный ввод связан с определенным проблемами программирования, повлиявшими на архитектуру и реализацию программ Ideum. Например, в приложении Ideum для каждого жеста предусмотрена голосовая команда, из-за чего могут возникать конфликты. «Многорежимный ввод нуждается в тщательной проработке для достижения успеха», — поясняет Лейси.

Не менее важным фактором оказалось и время отклика, оно должно соответствовать уже существующим стандартам, заданным для мышей и клавиатур (в противном случае резко возрастает трудоемкость всех операций для пользователя, которому приходится постоянно корректировать ввод). Это означает, что время отклика должно быть не более 30 мс, а в идеале — 6 мс. Этот показатель Лейси называет «Святым Граалем взаимодействия человека и компьютера».

И наконец, разработчики Ideum столкнулись с проблемой индивидуальной настройки. В приложении GestureWorks Fusion настройка по большей части осуществляется неявно, «за кадром». «Система автоматически адаптируется и изменяется, постепенно повышая удобство работы по мере использования продукта», — поясняет Лейси.

Использование Intel® RealSense™ SDK

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

Система разделена на набор модулей, при помощи которых разработчики могут сосредоточиться на различных аспектах взаимодействия. Некоторые компоненты, такие как интерфейс SenseManager, обеспечивают координацию общих функций, в том числе отслеживание лица и рук, и управляют конвейером многорежимного управления, включая управление вводом-выводом и обработкой. Прочие элементы, такие как интерфейсы Capture и Image, позволяют разработчикам отслеживать работу камеры и работать с отснятыми изображениями. Интерфейсы HandModule, FaceModule и AudioSource предоставляют доступ к отслеживанию лица и рук, к звуковому вводу.

Intel RealSense SDK упрощает интеграцию благодаря поддержке множества стилей и методик написания программного кода. Предусмотрены оболочки для нескольких распространенных языков программирования, платформ и игровых движков, C++, C#, Unity *, Processing и Java. В Intel RealSense SDK также обеспечивается ограниченная поддержка браузерных приложений с JavaScript *. Пакет Intel RealSense SDK упрощает реализацию сложных алгоритмов взаимодействия человека с компьютером; благодаря этому пакету разработчики могут сосредоточиться на повышении удобства пользователей, а не на написании кода алгоритмов распознавания жестов и речи.

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

Работа над решением

При создании GestureWorks Fusion разработчики Ideum применили ряд новых методик. Рассмотрим, к примеру, проблему определения фокуса пользователя. Для устранения этой проблемы было решено использовать новый режим Cursor, впервые появившийся в Intel RealSense SDK 2016 R1 для Windows. В режиме Cursor доступен быстрый и точный способ отслеживать одну точку, которая соответствует общему положению руки. Благодаря этому система получает возможность поддерживать небольшой набор жестов, таких как щелчки, открытие и закрытие ладони, вращение в любую сторону. В режиме Cursor проблема фокуса пользователя решена: система интерпретирует ввод жестами таким же образом, как ввод мышью.

Используя встроенный режим Cursor в Intel® RealSense™ SDK, разработчики могут без труда имитировать распространенные действия по управлению рабочим столом, например щелчок мыши.

Используя эти жесты, пользователи могут с высокой точностью и уверенностью перемещаться в приложении и управлять его работой «на весу», не прикасаясь к клавиатуре, мыши и экрану. Режим Cursor помогает и в других областях. «Мы обнаружили, помимо прочего, что не все жестикулируют одинаково», — заявил Лейси. Режим Cursor помогает сопоставлять схожие жесты с одним и тем же контекстом, что способствует повышению общей надежности работы.

Разработчики также подчеркнули простоту внедрения режима Cursor в существующие прототипы, что позволило выпустить новые версии GestureWorks Fusion всего за несколько часов: потребовалось добавить лишь несколько строк кода. Например, в GestureWorks режим Cursor используется для получения координат изображения указателя и для синтезирования событий мыши, как показано в следующем фрагменте кода.

// Get the cursor image coordinates
PXCMPoint3DF32 position = HandModule.cursor.QueryCursorPointImage();

// Synthesize a mouse movement
mouse_event (
   0x0001,
                                   // MOUSEEVENTF_MOVE
   (uint)(position.x previousPosition.x),     // dx
   (uint)(position.y previousPosition.y),     // dy
   0,
                               // dwData flags empty
   0                                          // dwExtraInfo flags empty
};

...


// Import for calls to unmanaged WIN32 API
[DllImport("user32.dll", CharSet = CharSet.Auto,
   CallingConvention = CallingConvention.StdCall)]

public static extern void mouse_event(uint dwFlags, uint dx, uint dy,
   uint cButtons, int dwExtraInfo);

После этого можно быстро определить, в каком окне находится фокус, с помощью стандартного API Windows.

// Get the handle of the window with focus

IntPtr activeWindow = GetForegroundWindow();

// Create a WINDOWINFO structure object

WINDOWINFO info = new WINDOWINFO(); GetWindowInfo(activeWindow, ref info);

// Get the actiive window text to compare with pre-configured controllers
StringBuilder builder = new StringBuilder(256);
GetWindowText(activeWindow, builder, 256);

...

// Import for calls to unmanaged WIN32 API
[DllImport("user32.dll")]

static extern IntPtr GetForegroundWindow();

[DllImport("user32.dll")]

static extern int GetWindowText(IntPtr hWnd, StringBuilder builder,
   int count);

В режиме Cursor отслеживание работает вдвое быстрее, чем отслеживании всей руки, при этом вдвое ниже потребление электроэнергии. «Удобство использования — это формирование ожидаемых результатов как можно более предсказуемым образом, — поясняет Лейси. — Когда достигнут очень высокий уровень уверенности в жестах, это позволяет сосредоточиться на доработке других областей взаимодействия с пользователями; это также способствует снижению стоимости разработки и позволяет добиться более значительных результатов, затратив меньше ресурсов».

Для поддержки многорежимного ввода в GestureWorks используется API распознавания речи корпорации Майкрософт (Microsoft SAPI), содержащий компоненты, отсутствующие в Intel RealSense SDK, например частичные гипотезы. Это позволяет сопровождать каждый жест соответствующей голосовой командой, как показано в следующем фрагменте кода.

IspRecognizer* recognizer;
ISpRecoContext* context;

// Initialize SAPI and set the grammar

...


// Create the recognition context
recognizer>CreateRecoContext(&context);

// Create flags for the hypothesis and recognition events
ULONGLONG recognition_event = SPFEI(SPEI_RECOGNITION) |
   SPFEI(SPEI_HYPOTHESIS);

// Inform SAPI about the events to which we want to subscribe context>SetInterest(recognition_event, recognition_event);

// Begin voice recognition
<recognition code …>

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

Разработчики Ideum также постарались полнее описать и формализовать взаимодействие на основе жестов, разработав расширенный XML-сценарий конфигураци, который назвали языком разметки жестов — Gesture Markup Language (GML). Используя GML, удалось создать полную библиотеку жестов, которую можно использовать для решения проблем взаимодействия между человеком и компьютером. Благодаря этому разработчикам удалось избежать чрезмерной сложности алгоритмов распознавания жестов, поскольку диапазон ввода при отслеживании движений и мультисенсорном управлении может охватывать тысячи разновидностей.

«Влияние многорежимного взаимодействия вместе с камерой Intel RealSense можно описать одним словом: контекст, — отметил Лейси. — Мы получаем возможность распознавать новый уровень контекста, открывающий принципиально новые возможности взаимодействия человека с компьютером».

Дальнейшие действия

Разработчики Ideum планируют развивать GestureWorks Fusion, добавить поддержку дополнительных приложений, в том числе офисных пакетов, графических приложений и систем автоматизированного проектирования, в которых для управления виртуальными объектами будут использоваться трехмерные жесты. Приложение GestureWorks может также работать на планшетах, поддерживающих технологию Intel RealSense, в домашних развлекательных системах и даже в автомобилях, а также вместе с другими технологиями — в решениях, резко отличающихся от традиционных настольных ПК и ноутбуков.

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

«В ходе работы над GestureWorks Fusion нам удалось обнаружить новые способы взаимодействия в современной среде, — поясняет Лейси. — Впрочем, вне зависимости от среды должна быть возможность просто управлять устройством с помощью жестов и речи и выбирать нужные последовательности действий, не сталкиваясь с необходимостью управлять устройством традиционным образом, как компьютером».

Ресурсы

Посетите сайт Intel Developer Zone, чтобы приступить к работе с технологией Intel RealSense.

Узнайте больше о компании Ideum, разработавшей GestureWorks.

Загрузите пакет Intel® RealSense™ SDK по адресу https://software.intel.com/en-us/intel-realsense-sdk .

Первая часть в серии учебных материалов по Intel® Software Guard Extensions (Intel® SGX)представляет собой краткое описание этой технологии. Дополнительные сведения см. в документации в составе Intel Software Guard Extensions SDK.Список всех учебных материалов в этой серии см. в статье Представляем серию учебных материалов, посвященных Intel® Software Guard Extensions.

Технология Intel® Software Guard Extensions

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

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

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

Корпорация Intel разработала расширения Intel SGX для высокоуровневой защиты секретов и для защиты от таких программных атак. Intel SGX — это набор инструкций ЦП, дающих возможность приложениям создавать анклавы: защищенные области в адресном пространстве приложения, обеспечивающие конфиденциальность и целостность даже при наличии вредоносных программ с расширенными правами. Код анклавов поддерживается особыми инструкциями, он компилируется и загружается в виде файла библиотеки динамической компоновки Windows * (DLL).

Расширения Intel SGX позволяют снизить уязвимость приложений. На рис. 1 показана значительная разница между потенциальными областями атаки при наличии и при отсутствии анклавов Intel SGX.

Рисунок 1. Области атаки с анклавами и без анклавов Intel® Software Guard Extensions

Как технология расширений Intel Software Guard Extensions помогает защищать данные

Intel SGX обеспечивает следующую защиту от атак, нацеленных на оборудование и программ.

• Доступ к памяти анклава на чтение и запись извне анклава отсутствует вне зависимости от текущего уровня прав и режима работы ЦП.
• Анклавы рабочего уровня недоступны для отладки как программными, так и аппаратными отладчиками. (Можно создать анклав с атрибутом отладки, при наличии которого отладчик Intel SGX может просматривать содержимое анклава аналогично стандартному отладчику. Это сделано, чтобы повысить удобство процесса разработки программного обеспечения.)
• В среду анклава невозможно войти с помощью классических вызовов функций, переходов, манипуляций с регистрами или со стеком. Единственный способ вызвать функцию анклава — с помощью новой инструкции, выполняющей несколько защитных проверок.
• Память анклава защищена с помощью стандартных алгоритмов шифрования с защитой от воспроизведения. Если прочесть память или подключить модули оперативной памяти к другой системе, удастся получить только зашифрованные данные (см. рис. 2).
• Ключ шифрования памяти изменяется случайным образом при каждом изменении цикла электропитания (например, при загрузке, при возобновлении работы после сна и гибернации). Ключ хранится внутри ЦП и недоступен извне.
• Данные изолированы в анклавах и доступны только для кода данного анклава.

Размер защищенной области памяти строго ограничен и задан BIOS системы. Обычно это 64 МБ или 128 МБ. Некоторые производители систем предоставляют возможность настраивать это значение в BIOS. В зависимости от размера каждого анклава в памяти одновременно может быть создано от 5 до 20 анклавов.

Рисунок 2. Защита данных в анклавах Intel® Software Guard Extensions в защищенных приложениях

Как это устроено

Для использования Intel SGX приложение должно быть разделено на два компонента (см. рис. 3).

• Доверенный компонент. Это анклав. Код в доверенном компоненте получает доступ к секретам приложения. У одного приложения может быть несколько доверенных компонентов/анклавов.
• Недоверенный компонент.Это остальная часть приложения, любые его модули. Следует отметить, что с точки зрения анклава и ОС, и VMM считаются недоверенными компонентами.

Доверенный компонент должен быть как можно меньше, в нем должны быть лишь те данные, которые нуждаются в наиболее надежной защите, и операции, работающие непосредственно с этими данными. Крупный анклав со сложным интефейсом не только потребляет больше защищенной памяти, но и повышает уязвимость.

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

Рисунок 3. Выполнение приложения Intel® Software Guard Extensions

Аттестация

В архитектуре SGX аттестация — это подтверждение создания определенного анклава на платформе. Существует два механизма аттестации.

• Локальная аттестация происходит, когда два анклава, находящиеся на одной и той же платформе, выполняют взаимную проверку подлинности.
• Удаленная аттестация происходит, когда доверенность анклава проверяется удаленным поставщиком.

Локальная аттестация

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

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

Удаленная аттестация

При удаленной аттестации программные расширения Intel SGX и оборудование платформы формируют предложение, которое передаются на сторонний сервер для установления доверия. Программное обеспечение включает анклав приложения, а также компонент Quoting Enclave (QE) и Provisioning Enclave (PvE), предоставляемые корпорацией Intel. Оборудование для аттестации — ЦП, поддерживающий Intel SGX. Сводка программной информации в сочетании с уникальным для платформы асимметричным ключом оборудования используются для формирования предложения, которое передается на удаленный сервер по проверенному каналу. Если удаленный сервер определяет, что экземпляр анклава был создан правильно и запущен на процессоре, поддерживающем Intel SGX, то сервер устанавливает доверительные отношения и передает секреты по проверенному каналу.

Запечатывание данных

Запечатывание данных — это шифрование данных, чтобы можно было записывать их в недоверенную память или хранилище, не раскрывая содержимое. Эта данные могут быть позже прочитаны анклавом и распечатаны (расшифрованы). Ключи шифрования создаются внутри по запросу и не раскрываются для анклава.

Существует два способа запечатывания данных.

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

Запечатывание с удостоверением анклава

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

Запечатывание с удостоверением запечатывания

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

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

Как мы будем использовать технологию Intel Software Guard Extensions в учебном руководстве

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

В дальнейших выпусках

Во второй части серии учебных материалов Расширения Intel® Software Guard Extensions: часть 2, создание приложений, мы рассмотрим диспетчер паролей, который будет создан с поддержкой Intel SGX. Мы опишем требования к созданию этого приложения, ограничения и пользовательский интерфейс. Следите за новостями.

Список всех учебных материалов в этой серии см. в статье Представляем серию учебных материалов, посвященных Intel® Software Guard Extensions.

Download Now  Noise.zip

Об образце кода

Образец кода Noise, прилагаемый к этой статье, включает реализацию алгоритма создания шума Перлина, полезного для формирования текстур естественного вида, таких как мрамор или облака, для трехмерной графики. В состав статьи входит тест, в котором используется алгоритм шума Перлина для создания изображения «облака». (Дополнительные сведения об алгоритме шума Перлина см. в разделе «Справочные материалы».) Включены двухмерная и трехмерная версии алгоритма. Это означает, что функции принимают на вход два или три набора данных, чтобы создать одно выходное значение шума Перлина.

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

Введение и мотивация

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

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

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

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

В функциях уровня ядра OpenCL в образце кода Noise применяется подход, более подходящий к задействованному в OpenCL алгоритму разделения работы на параллельные операции.

Создание шума и случайных чисел для OpenCL

В OpenCL глобальное рабочее пространство (массив рабочих элементов) определяется с помощью одного, двух или трех измерений. Каждый рабочий элемент в этом глобальном пространстве обладает уникальным набором идентифицирующих целочисленных значений, соответствующих координатам по осям X, Y и Z в глобальном пространстве.

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

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

kernel void genRand()

{

               uint          x = get_global_id(0);

               uint          y = get_global_id(1);

               uint          rand_num = ParallelRNG2( x, y );

               ...

Рисунок 1. Пример использования случайных чисел (два измерения)

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

kernel void multi2dNoise( float fScale, float offset )

{

float         fX = fScale * get_global_id(0);

float         fY = fScale * get_global_id(1);

float         fZ = offset;

float         randResult = Noise_3d(  fX,  fY,  fZ );

...

Рисунок 2. Пример использования алгоритма шума Перлина (три измерения)

Ограничения

В функциях Noise_2d и Noise_3d используется один и тот же базовый алгоритм шума Перлина, но различается реализация на основе рекомендаций Перлина. (См. первую ссылку в списке справочных материалов.) В образце Noise только Noise_3d используется в примере noise, а тестовое ядро Noise_2d включено в файл Noise.cl для читателей, желающих изменить этот пример и поэкспериментировать с ним.

Функции Noise_2d и Noise_3d следует вызывать со входными значениями с плавающей запятой. Значения должны охватывать какой-либо диапазон, например (0.0, 128.0), чтобы задать размер «таблицы» (см. рисунок 3) случайных значений. Читателям следует рассмотреть пример с облаками, чтобы понять, как можно преобразовать шум Перлина в разнообразные изображения «естественного вида».

Функция ParallelRNG по умолчанию, используемая в тесте random, предоставляет случайные (и выглядящие таковыми) результаты, но не является самым быстрым алгоритмом генератора случайных чисел. Эта функция построена на основе «хеша Вонга», который изначально не предназначался для использования в качестве генератора случайных чисел. Тем не менее некоторые распространенные функции генераторов случайных чисел (закомментированный пример в файле Noise.cl) показывали видимую повторяемость при заполнении двухмерных изображений, особенно в битах младшего разряда результатов. Читатели могут поэкспериментировать и с другими (более быстрыми) функциями генераторов случайных чисел.

Используемая по умолчанию функция ParallelRNG создает в качестве результатов только 32-битные целые числа без знака. Если требуются значения с плавающей запятой для диапазона, такого как (0.0, 1.0), то приложение должно применить сопоставление для этого диапазона. Образец randomсопоставляет случайный целочисленный результат без знака с диапазоном (0, 255) для создания значений пикселей в оттенках серого. Для этого просто применяется двоичная операция AND, чтобы выбрать 8 бит.

Используемая по умолчанию функция ParallelRNG не будет создавать все 4 294 967 296 (2^32) целочисленных значений без знака для последовательных вызовов на основе созданного ранее значения. Для каждого отдельного начального значения величина псевдослучайных последовательностей (циклов) может составлять от всего 7000 уникальных значений до приблизительно 2 миллиардов значений. Функция ParallelRNG создает около 20 различных циклов. Автор считает маловероятным, что какому-либо рабочему элементу ядра OpenCL может потребоваться больше последовательно созданных случайных чисел, чем образуется в самом маленьком цикле.

Двухмерные и трехмерные версии этой функции —ParallelRNG2 и ParallelRNG3 — используют «смешение» циклов путем применения двоичной операции XOR между результатом предыдущего вызова ParallelRNG и следующим входным значением, из-за чего изменяются длины циклов. Тем не менее такое измененное поведение не подвергалось подробному анализу, поэтому читателю рекомендуется внимательно убедиться в том, что функции ParallelRNG отвечают потребностям приложения.

Структура проекта

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

NoiseMain.cpp:

main()
основная входная функция. После разбора параметров командной строки она инициализирует OpenCL, собирает программу OpenCL из файла Noise.cl, подготавливает одно из ядер к запуску и вызывает ExecuteNoiseKernel(), а затем ExecuteNoiseReference(). Проверив, что эти две реализации выдают одинаковые результаты, main()выдает информацию о времени работы каждой из этих функций и сохраняет изображения, получившиеся в результате их работы.

ExecuteNoiseKernel()
Настройка и запуск выбранного ядра Noise в OpenCL.

ExecuteNoiseReference()
Настройка и запуск выбранного эталонного кода Noise на языке C.

Noise.cl:

defaut_perm[256]
Таблица случайных значений 0–255 для ядра трехмерного шума Перлина. Для дополнительного повышения случайности эту таблицу можно сформировать и передать в ядро шума Перлина.

grads2d[16]
16 однородно распределенных единичных векторов, градиенты для ядра двухмерного шума Перлина.

grads3d[16]
16 векторных градиентов для ядра трехмерного шума Перлина.

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

ParallelRNG2()
Генератор случайных чисел, делающий 2 прохода для 2 входных значений.

ParallelRNG3()
Генератор случайных чисел, делающий 3 прохода для 3 входных значений.

weight_poly3(), weight_poly5() и WEIGHT()
Это альтернативные функции веса, используемые алгоритмом шума Перлина для обеспечения непрерывности градиентов. Вторая (предпочитаемая) функция также обеспечивает непрерывность второй производной. Макрос WEIGHTвыбирает, какая функция используется.

NORM256()
Макрос, преобразующий диапазон (0, 255) в (-1.0, 1.0).

interp()
Билинейная интерполяция, использующая OpenCL.

hash_grad_dot2()
Выбирает градиент и вычисляет скалярное произведение со входными значениями XY в составе функции шума Перлина Noise_2d.

Noise_2d()
Генератор шума Перлина с двумя входными значениями.

hash_grad_dot3()
Выбирает градиент и вычисляет скалярное произведение со входными значениями XYZ в составе функции шума Перлина Noise_3d.

Noise_3d()
Генератор шума Перлина с тремя входными значениями.

cloud()
Создает один пиксель «облачного» выходного изображения для CloudTestс помощью Noise_3d.

map256()
Преобразует выходной диапазон шума Перлина (-1.0, 1.0) в диапазон (0, 255), необходимый для получения пикселей в оттенках серого.

CloudTest()
Тест с созданием изображения облака. Параметр sliceпередается в функцию cloud, чтобы код системы мог создавать другие изображения облаков.

Noise2dTest()
Тест Noise_2dне используется по умолчанию.

Noise3dTest()
Тест Noise_3d — функции шума Перлина по умолчанию. Использует map256для получения значений пикселей изображения в оттенках серого.

RandomTest()
Тест ParallelRNG3использует байт младшего разряда целочисленного результата без знака для получения изображения в оттенках серого.

Предоставляются два файла решений Microsoft Visual Studio для Visual Studio версий 2012 и 2013.  Это файлы Noise_2012.sln и Noise_2013.sln.   Если читатель использует более новую версию Visual Studio, должно быть возможно использовать функцию обновления решений и проектов Visual Studio для создания нового решения на основе этих файлов.

В обоих решениях предполагается, что в системе установлен компонент Intel^® OpenCL™ Code Builder.

Управление образцом

Образец можно запустить из командной строки Microsoft Windows* из папки, в которой находится EXE-файл.

Noise.exe<параметры>

Параметры

-hили --help
Отображение справки в командной строке. Демонстрации при этом не запускаются.

-tили --type [ all | cpu | gpu | acc | default |
<константа типа устройства OpenCL>
Выбор типа устройства, для которого запускается ядро OpenCL. Значение по умолчанию: all.

<константа типа устройства OpenCL>

CL_DEVICE_TYPE_ALL | CL_DEVICE_TYPE_CPU | CL_DEVICE_TYPE_GPU |
CL_DEVICE_TYPE_ACCELERATOR | CL_DEVICE_TYPE_DEFAULT

-pили --platform<число или строка> 
Выбор используемой платформы. При запуске демонстрации выводится список всех номеров и названий платформ. Справа от используемой платформы будет указано [Selected]. При использовании строки укажите достаточно букв для уникального распознавания названия платформы. Значение по умолчанию: Intel.

-dили --device<число или строка>
Выбор устройства, на котором выполняются ядра OpenCL, по номеру или имени. При запуске демонстрации выводится список всех номеров и названий устройств на используемой платформе. Справа от текущего устройства будет указано [Selected]. Значение по умолчанию: 0.

-rили --run [ random | perlin | clouds ]
Выбор демонстрации функции для запуска. У генератора случайных чисел, алгоритма шума Перлина и генератора изображения облака есть демонстрационные ядра. Значение по умолчанию: random.

-sили --seed<целое число>
Целочисленное входное значение, в зависимости от которого изменяется результат работы алгоритма. Значение по умолчанию: 1.

Noise.exeвыводит время работы ядра OpenCL и эталонного эквивалентного кода C, а также имена выходных файлов обоих алгоритмов. По завершении вывода информации программа ожидает нажатия пользователем клавиши ВВОД перед выходом. Обратите внимание, что функции эталонного кода на C не были оптимизированы, их цель состоит лишь в проверке правильности кода ядра OpenCL.

Анализ результатов

После завершения работы Noise.exeпросмотрите файлы изображений в формате BMP OutputOpenCL.bmpи OutputReference.bmpв рабочей папке, чтобы сравнить результаты кода OpenCL и C++. Эти два изображения должны быть одинаковыми, хотя возможны весьма незначительные различия между двумя изображениями шума Перлина или между двумя изображениями облаков.

Результат работы алгоритма noise (шум Перлина) должен выглядеть, как показано на рисунке 3.

Рисунок 3. Результат работы алгоритма шума Перлина

Результат работы алгоритма random (генератор случайных чисел) должен выглядеть, как показано на рисунке 4.

Рисунок 4. Результат работы генератора случайных чисел

Результат работы алгоритма cloud (облака) должен выглядеть, как показано на рисунке 5.

Рисунок 5. Результат работы алгоритма создания облаков

Справочные материалы

1. К. Перлин (Perlin, K.) «Улучшение шума». http://mrl.nyu.edu/~perlin/paper445.pdf
2. «Хеширование 4-байтовых целых чисел». http://burtleburtle.net/bob/hash/integer.html
3. М. Овертон (Overton, M. A.), «Быстрые высококачественные параллельные генераторы случайных чисел», веб-сайт Dr. Dobb’s (2011 г.). http://www.drdobbs.com/tools/fast-high-quality-parallel-random-number/229625477
4. Реализация и использование библиотеки цифрового генератора случайных чисел (DRNG) Intel^®. https://software.intel.com/ru-ru/articles/intel-digital-random-number-generator-drng-library-implementation-and-uses?utm_source=Email&utm_medium=IDZ
5. Лицензионное соглашение корпорации Intel на использование образцов исходного кода. https://software.intel.com/ru-ru/articles/intel-sample-source-code-license-agreement/
6. Intel^® OpenCL™ Code Builder.https://software.intel.com/ru-ru/opencl-code-builder

Моя жена недавно купила довольно толстую и дорогую книгу. Моя жена — врач, специалист по ультразвуковой диагностике детей, она покупает немало книг, но эта книга меня, прямо скажем, озадачила.  Книга называлась «Ультразвуковая анатомия здорового ребенка».  Какой смысл врачу покупать книгу, которая посвящена только здоровым детям?  Я задал этот вопрос жене, и ее ответ был прост: для диагностики у детей любого заболевания, даже если оно еще не выявлено, необходимо знать, как должен работать организм здорового ребенка. 

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

Тук-тук-тук.

Врач говорит: «Войдите!»

В кабинет заходит наш пациент — игра WarriorWave*, где ваша рука прокладывает путь, по которому должны пройти воины. Играть в нее очень интересно и необычно. В игре используется технология Intel^® RealSense. 

Но в процессе игры что-то было не так.  Что-то, чего не ощущалось в других играх на основе технологии Intel^® RealSense™.  Проблема может быть вызвана разными причинами, но что не так в этомслучае?  

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

Используя средство Platform Analyzer в составе Intel^® Graphics Performance Analyzer (Intel^® GPA)мы получаем временное представление нагрузки на ЦП, времени создания каждого кадра, кадровой скорости и вызовов отрисовки:

Давайте посмотрим.

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

Для сравнения посмотрим на график кадровой скорости в другой, правильно работающей игре. В этой игре все очень гладко, в нее было приятно играть.  

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

Но в нашем случае явно наблюдаются регулярные скачки. Они происходят примерно 4 раза в секунду.  Давайте изучим проблему подробнее, увеличив один из таких скачков, и посмотрим, что при этом происходит в потоках:

Мы видим, что рабочий поток 2780 тратит большую часть времени на синхронизацию. Этот поток практически ничего не делает, только дожидается следующего кадра из Intel^® RealSense™ SDK:

При этом мы видим, что отрисовка происходит в другом рабочем потоке. Если прокрутить вниз, мы найдем поток 2372.

Вместо того, чтобы «активно» ждать следующего кадра от Intel RealSense SDK, игра могла бы делать что-нибудь полезное. Отрисовку и ожидание Intel^® RealSense™ SDK можно было бы поместить в один рабочий поток вместо двух, что упростило бы обмен данными между потоками.

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

Вот пример правильно устроенной игры, в которой работа Intel^® RealSense™ SDK и вызовы DirectX* находятся в одном и том же потоке. 

Специалисты по RealSense™ заявляют, что нет смысла ждать кадры из Intel^® RealSense™ SDK. От этого они не будут появляться быстрее. 

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

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

Теперь перейдем к конвейеру и попробуем разобраться, как идет выполнение кода.  Посмотрите на количество пакетов в Engine 0: конвейер заполнен до краев, но очередь выполнения почти пуста.

Человеческий мозг может обрабатывать до 10–12 изображений в секунду по отдельности. Это поясняет, почему при съемке самых первых кинофильмов пленка протягивалась со скоростью 16 кадров в секунду: это средний порог, после которого большинство людей перестают воспринимать картинку на экране как отдельные изображения и начинают видеть фильм.

Снова посмотрим на профиль правильно работающей игры: 

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

Давайте попробуем понять, почему в нашей игре это не так.

Сначала рассмотрим вызовы DirectX*. Выделенный вызов со всплывающей подсказкой — это наш вызов Present, отправляющий готовый кадр в ГП. На приведенном выше снимке экрана видно, что он создает пакет Present в конвейере ГП (помеченный крестиками).  На отметке 2215 мс он переместился ближе к выполнению, перескочив через три позиции, но на отметке 2231 мс он просто исчез, не завершив выполнение.

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

Вопрос: каким же образом изображение игры вообще появляется на экране, если все вызовы DirectX* Present пропадают?! Хорошо, что у нас есть удобные инструменты, позволяющие получить ответ на этот вопрос. Давайте посмотрим.

Видите нечто любопытное внутри серого овала? Мы видим, что этот пакет, возникший вне всякой связи с какими-либо вызовами DirectX* в нашем коде, все же добирается до выполнения, быстро и без видимого порядка. Минутку, постойте!

Давайте поподробнее изучим наш пакет. 

А теперь — пакет, который все-таки был выполнен. 

Ага! Он появился из ВНЕШНЕГО потока. Что это может означать? Внешние потоки — это потоки, не принадлежащие к игре.

Итак, наши собственные пакеты пропадают, но зато какой-то внешний поток выводит на экран нашу игру? Как это вообще возможно? Может быть, наша программа Platform Analyzer выдает какую-то чепуху?

Нет, на изображении все верно. А объясняется весь этот цирк следующим образом: в системах Windows* (начиная с Windows Vista*) существует программа под названием «диспетчер окон рабочего стола» (DWM), которая и отвечает за фактический вывод изображения на экран. Это пакеты DWM выполнялись быстро и вне очереди, с высоким приоритетом.  А наши пакеты вовсе не пропадали: диспетчер окон рабочего стола перехватывал их для создания итогового изображения.

Но почему диспетчер окон рабочего стола вмешался в работу полноэкранной игры? Подумав, я понял, что ответ прост: к моему компьютеру подключено два монитора. Достаточно было отключить второй монитор из схемы, и все встало на свои места: игра WarriorWaveзаработала точно так же, как все приличные игры: нормальная кадровая скорость ГП, никаких скачков, никаких пакетов DWM.

Пациент будет жить! Хорошая новость!

Но ведь другие игры вполне хорошо работали и в конфигурации с двумя мониторами, не так ли?

Чтобы изучить проблему подробнее, нужен другой инструмент. Intel^® GPA Platform Analyzer позволяет отслеживать работу ЦП и ГП по времени, но не дает возможности подробно изучать каждый кадр.

Следует более внимательно рассмотреть код создания Direct3D* Device. Для этого можно использовать Intel^® GPA Frame Analyzer для DirectX*, но это уже материал для другой статьи.

Итак, подведем итоги.

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

Заключение: Intel^® GPA Platform Analyzer — очень полезный инструмент для анализа проблем на начальном этапе. Изучите его и используйте его.

Об авторе

Александр Рауд (Alexander Raud) работает в команде Intel^® Graphics Performance Analyzers в России, ранее он работал над программой VTune Amplifier. У Александра двойное гражданство России и Евросоюза, он говорит по-русски, по-английски и немного по-французски, а также изучает испанский язык.  Александр женат, у него двое детей, но, несмотря на это, он находит время, чтобы профессионально играть прогрессивный металл в составе рок-группы и руководить международной миссионерской организацией церкви «Дом Божий».

Дополнительные сведения об оптимизации компиляторов см. в нашем уведомлении об оптимизации.

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

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

OpenCL и эмблема OpenCL являются товарными знаками Apple Inc. и используются с разрешения Kronos.

Дополнительные сведения об оптимизации компиляторов см. в уведомлении об оптимизации.

В этой серии из двух статей о производительности и памяти описываются базовые принципы и приводятся советы для разработчиков по повышению производительности программного обеспечения.  Эти статьи затрагивают, в частности, работу памяти и компоновку. В первой частибыло рассказано об использовании регистров и о применении алгоритмов блокирования для повышения многократного использования данных. В этой части статьи сначала описывается компоновка данных для обычного распараллеливания — программирования для общей памяти с потоками, а затем распределенные вычисления по сетям MPI. В статье описываются понятия, связанные с распараллеливанием: векторизация (инструкции SIMD) и работа с общей памятью (многопоточная архитектура), а также вычисления с распределенной памятью. И наконец, в этой статье сравниваются компоновки данных «массив структур» (AOS) и «структура массивов» (SOA).

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

Программирование общей памяти с потоками

Давайте начнем с программирования общей памяти с потоками. Все потоки вместе обращаются к одной и той же памяти в пределах процесса. Существует множество моделей управления потоками. Наиболее известные среди них потоки Posix* и потоки Windows*. В работе, связанной с правильным созданием потоков и управлением ими, могут возникать ошибки. В современных программах, состоящих из множества модулей и создаваемых крупными командами разработчиков, часто возникают ошибки в параллельном программировании с использованием многопоточных вычислений. Разработано несколько пакетов для упрощения создания потоков, управления ими и наиболее эффективного использования параллельных потоков. Два самых популярных пакета — это OpenMP* и Intel^® Threading Building Blocks. Третья модель управления потоками — Intel^® Cilk™ Plus — не получила настолько широкого распространения, как OpenMP и Threading Building blocks. Все эти модели управления потоками создают пул потоков, который многократно используется каждой из параллельных операций и параллельных областей. В OpenMP есть преимущество — ступенчатое распараллеливание с помощью использования директив. При этом директивы OpenMP можно зачастую добавлять к существующим программам в пошаговом процессе и с минимальными изменениями кода. Если позволить библиотеке времени выполнения управлять обслуживанием потоков, это существенно упростит разработку многопоточных программ. Также предоставляется единая модель управления потоками, которой должны придерживаться все разработчики кода, что снижает вероятность возникновения некоторых распространенных ошибок. Оптимизированная библиотека управления потоками используется всеми разработчиками.

Принципы параллельного программирования, упомянутые во вводной части, состоят в том, чтобы размещать данные как можно ближе к месту, где они будут использоваться, и избегать перемещения данных. В многопоточном программировании в модели по умолчанию данные являются общими для всего процесса, к ним могут обращаться все потоки. Во вводных статьях по управлению потоками подчеркивается, насколько просто можно применить OpenMP к циклам do (Fortran*) или циклам for (C). Такие методы обычно значительно ускоряются при выполнении кода на двух или четырех ядрах. Зачастую эти методы наращиваются до 64 потоков или более. Впрочем, не менее часто дополнительные потоки не используются, причем в некоторых таких случаях это обусловлено неподходящей компоновкой данных. Дело в создании архитектуры, пригодной для параллельного кода.

Важно изучать возможности распараллеливания на более высоком уровне в стеке вызовов кода, чем первоначально предполагается разработчиком или средствами разработки. Если разработчик считает, что какие-либо задачи или данные можно обрабатывать параллельно, то попробуйте ответить на следующие вопросы (в свете закона Амдала): «Можно ли начать применять параллельные операции выше в стеке вызовов перед переходом к этому месту?», «Если я это сделаю, то увеличится ли параллельная область кода, что приведет к ускорению работы при задействовании большего числа потоков?».

Следует внимательно обдумать и размещение данных, и то, к каким данным может быть предоставлен общий доступ посредством сообщений. Компоновка данных должна предусматривать размещение данных там, где они используются больше всего, а оттуда их можно отправлять другим системам. Для приложений, представленных в таблице или в физическом домене с заданными разделами, программы MPI часто добавляют строку «фантомных» ячеек вокруг подчиненной таблицы или подчиненного домена. В «фантомных» ячейках сохраняются значения данных, отправленные процессом MPI, обновляющим эти ячейки. В многопоточных программах «фантомные» ячейки обычно не используются, но при снижении длины границы раздела для передачи сообщений желательно уменьшить границы разделов, использующих общую память. При этом снижается необходимость в блокировке потоков (или важных разделов) и вероятность образования конфликтов кэша, связанных с владением кэшем.

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

Рисунок 1. Скорость доступа к памяти, относительные задержки при доступе к данным

Если один поток выделяет и инициализирует данные, то эти данные обычно помещаются в память, ближайшую к процессору, в котором выполняется поток, выделяющий и инициализирующий память (рис. 1). Можно повысить производительность, если заставить каждый поток выделять и давать первую ссылку на память, которая в наибольшей степени будет использоваться этим потоком. Обычно этого достаточно для того, чтобы поток был запущен в области памяти, ближайшей к процессору. Если поток создан и активен, то ОС обычно оставляет его в этом же процессоре. Иногда бывает выгодно явным образом привязать поток к определенному ядру, чтобы избежать переноса потока между ядрами. Если данные имеют определенную компоновку, то может быть выгодно назначить или привязать потоки к определенным ядрам в соответствии с этой компоновкой. Библиотека выполнения Intel OpenMP (в составе Intel^® Parallel Studio XE 2016) содержит явные атрибуты сопоставления, эффективно работающие на сопроцессорах Intel^® Xeon Phi™.

Это атрибуты Compact, Scatter и Balanced. 

• Атрибут Compact сопоставляет последовательные или соседние потоки с симметричными многопоточными множествами (SMT) на одном ядре перед назначением потоков другим ядрам. Это идеальное решение для ситуаций, когда потоки обращаются к данным, общим для потоков с последовательной нумерацией (т. е. соседних потоков).
• Атрибут Scatter назначает по одному потоку каждому ядру, затем возвращается к первоначальному ядру для планирования других потоков в SMT.
• Атрибут Balanced равномерно назначает потоки с последовательными или соседними идентификаторами одному и тому же ядру. Это рекомендуемый начальный атрибут для оптимизации сопоставления потоков в документации компилятора Intel 16.0 C++. Параметр Balanced доступен только для семейства продуктов Intel^® Xeon Phi™. Для обычных ЦП он недействителен. Когда все SMT на платформе Xeon Phi задействованы, атрибуты Balanced и Compact работают одинаково.  Если же на платформе Xeon Phi задействованы лишь некоторые SMT, то метод Compact будет заполнять все SMT на первых ядрах, а некоторые ядра останутся свободными (в идеале).

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

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

Представьте ситуацию, когда каждый поток увеличивает значение собственного счетчика, но сам счетчик при этом является одномерным массивом. Каждый поток увеличивает значение своего счетчика. Для увеличения значения счетчика ядро должно владеть строкой кэша. Например, поток A процессора 0 становится владельцем строки кэша и увеличивает значение счетчика iCount[A]. Одновременно поток A+1 процессора 1 увеличивает значение счетчика iCount[A+1]. Для этого ядро процессора 1 становится владельцем строки кэша и поток A+1 обновляет значение счетчика.  Поскольку значение в строке кэша изменяется, эта строка аннулируется для процессора 0. В следующей итерации процессор 0 становится владельцем строки кэша и изменяет значение iCount[A], что, в свою очередь, аннулирует эту строку кэша для процессора 1. Когда поток в процессоре 1 будет готов к записи, цикл повторяется. Значительное количество циклов процессора тратится на поддержку согласованности кэша, поскольку аннулирование строк кэша, восстановление контроля и синхронизация с памятью влияют на производительность.

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

int iCount[nThreads] ;
      .
      .
      .
      for (some interval){
       //some work . . .
       iCount[myThreadId]++ // may result in false sharing
     }

int iCount[nThreads*16] ;// memory padding to avoid false sharing
      .
      .
      .
      for (some interval){
       //some work . . .
       iCount[myThreadId*16]++ //no false sharing, unused memory
     }

int iCount[nThreads] ; // make temporary local copy

      .
      .
      .
      // every thread creates its own local variable local_count
      int local_Count = iCount[myThreadID] ;
      for (some interval){
       //some work . . .
       local_Count++ ; //no false sharing
     }
     iCount[myThreadId] = local_Count ; //preserve values
     // potential false sharing at the end,
     // but outside of inner work loop much improved
     // better just preserve local_Count for each thread

Рисунок 2.

Ложный общий доступ может возникнуть и при назначении скалярных значений в соседние области памяти. Этот случай показан в приведенном ниже фрагменте кода:

int data1, data2 ; // data1 and data2 may be placed in memory
                   //such that false sharing could occur
declspec(align(64)) int data3;  // data3 and data4 will be
declspec(align(64)) int data4;  // on separate cache lines,
                                // no false sharing

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

Выравнивание данных

Производительность программ является оптимальной, когда данные, обрабатываемые инструкциями SIMD (AVX512, AVX, SSE4), выравниваются по границам строки кэша. Потеря производительности при доступе к невыровненным данным различается в зависимости от семейства процессоров. Работа сопроцессоров Intel^® Xeon Phi™ особенно сильно затрагивается выравниванием данных.    На платформе Intel Xeon Phi выравнивание данных имеет огромное значение. Эта разница не столь велика на других платформах Intel^® Xeon^®, но производительность все же заметно возрастает, когда данные выровнены по границам строки кэша. Поэтому разработчикам программ рекомендуется всегда выравнивать данные по 64-байтовым границам.  В системах Linux* и Mac OS X* для этого даже не нужно менять код, достаточно лишь использовать соответствующий параметр в командной строке компилятора Intel: /align:rec64byte.    

Для динамически выделяемой памяти в C можно заменить malloc()на _mm_alloc(datasize,64). Если используется _mm_alloc(), то следует использовать _mm_free()вместо free(). Подробная статья, посвященная выравниванию данных, находится здесь:  https://software.intel.com/en-us/articles/data-alignment-to-assist-vectorization. 

Также ознакомьтесь с документацией к компилятору. Чтобы показать влияние выравнивания данных на две матрицы одинакового размера, мы создали и запустили блочный код умножения матриц, использованный в первой части этой статьи.   В первом случае матрица А была выровнена. Во втором случае матрица А была намеренно смещена на 24 байта (три значения типа Double). При этом производительность (использовался компилятор Intel 16.0) упала на 56–63 % для матриц размером от 1200 х 1200 до 4000 х 4000.  В первой части я привел таблицу с производительностью упорядочения циклов в разных компиляторах. Когда одна матрица была смещена, компилятор Intel перестал давать прирост производительности.  Разработчикам рекомендуется прочесть документацию к компиляторам, чтобы узнать о выравнивании данных и о доступных параметрах, чтобы компилятор мог с наибольшей эффективностью воспользоваться выровненными данными. Код для измерения производительности матрицы, смещенной по отношению к строке кэша, входит в состав кода для первой части статьи:  https://github.com/drmackay/samplematrixcode

Дополнительные сведения вы найдете в документации к компилятору.

Чтобы показать влияние выравнивания данных на две матрицы одинакового размера, мы создали и запустили блочный код умножения матриц, использованный в первой части этой статьи. Первая матрица была выровнена. Вторая матрица была намеренно смещена на 24 байта (три значения типа Double). При этом производительность (использовался компилятор Intel 16.0) упала на 56–63 % для матриц размером от 1200 х 1200 до 4000 х 4000.

Массив структур или структура массивов

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

struct {
   uint r, g, b, w ; // a possible 2D color rgb pixel layout
} MyAoS[N] ;

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

struct {
   uint r[N] ;
   uint g[N] ;
   uint b[N] ;
   uint w[N] ;
} MySoA ;

Если данные хранятся в структуре массивов и программа работает со всеми значениями g (или r, или b), то весь кэш с высокой вероятностью будет использован в работе при помещении в кэш одной строки кэша.    Данные эффективнее загружаются в регистры SIMD, благодаря чему повышается эффективность и производительность. Во многих случаях разработчики программ временно перемещают данные в структуру массивов для обработки, а затем копируют обратно, когда это становится нужно. Во всех возможных случаях лучше избегать этого дополнительного копирования, поскольку из-за него выполнение занимает больше времени.

Анализ Memory Access Pattern (MAP) в Intel (Vectorization) Advisor 2016 выявляет циклы с последовательным, непоследовательным и нерегулярным доступом:

В столбце Strides Distribution предоставляется совокупная статистика о том, насколько часто используется каждая модель в заданном цикле. На приведенном выше рисунке две трети горизонтальной полосы закрашены синим (это последовательный доступ к памяти), а правая треть закрашена красным (это непоследовательный доступ). Для кода с компоновкой «массив структур» Advisor также может получить «рекомендацию» для преобразования массива структур в структуру массивов.  

Анализы моделей доступа и локальности памяти упрощены в Advisor MAP, они дополнительно предоставляют метрику использования памяти и сопоставляют диагностику каждого «шага» (то есть модель доступа) с определенными именами объектов и массивов C++ или Fortran*. Дополнительные сведения о Intel Advisor см. на сайтах

https://software.intel.com/en-us/get-started-with-advisor и https://software.intel.com/en-us/intel-advisor-xe

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

В компиляторе Intel, начиная с версии 2016 Update 1, преобразование «массив структур» -> «структура массивов» упрощено за счет применения шаблонов компоновки данных Intel^® SIMD (Intel^® SDLT). С помощью шаблонов SDLT можно просто переопределить контейнер массива структур следующим образом:

SDLT_PRIMITIVE(Point3s, x, y, z)
sdlt::soa1d_container<Point3s> inputDataSet(count);  

Это позволит обращаться к экземплярам Point3s по модели структуры массивов. Подробнее о SDLT см. здесь.

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

https://software.intel.com/en-us/articles/a-case-study-comparing-aos-arrays-of-structures-and-soa-structures-of-arrays-data-layouts

и

https://software.intel.com/en-us/articles/how-to-manipulate-data-structure-to-optimize-memory-use-on-32-bit-intel-architecture
http://stackoverflow.com/questions/17924705/structure-of-arrays-vs-array-of-structures-in-cuda

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

Заключение

Подведем итоги. Вот основные принципы, которые следует соблюдать в отношении производительности и компоновки данных. Структурируйте код таким образом, чтобы свести к минимуму перемещение данных. Многократно используйте данные, пока они находятся в регистрах и в кэше (это также дает возможность меньше перемещать их). Можно ограничить перемещение данных с помощью блокирования циклов. Это особенно важно для программ с двухмерной или трехмерной компоновкой. Проанализируйте компоновку на предмет распараллеливания: как задачи и данные распределяются для параллельных вычислений. Правильные методики разграничения доменов повышают эффективность и обмена сообщениями (MPI), и программирования с общей памятью. В структуре массивов обычно перемещается меньше данных, чем в массиве структур, и выше скорость. Избегайте ложного общего доступа, создавайте действительно локальные переменные или применяйте заполнение, чтобы несколько потоков не ссылались на значения в одной и той же строке кэша. И наконец, настройте выравнивание данных так, чтобы они начинались в строке кэша. 

Полный код можно загрузить здесь: https://github.com/drmackay/samplematrixcode

Если вы еще не читали первую часть этой статьи, то она находится здесь.

Примените описанные методики и оцените, насколько повысится производительность кода.

Дополнительные сведения об оптимизации компиляторов см. в нашем уведомлении об оптимизации

Кодирование 4K HEVC в реальном времени, стабильность декодирования AVC и MPEG2

Выпущена версия Intel^® Media Server Studio 2016! В новой версии можно быстрее перекодировать высококачественное видео. 

В кодировщике HEVC в 1,1 раза повышена производительностьи на 10 % повышено качество. Intel^® Media Server Studio помогает поставщикам решений перекодировки добиваться кодирования видео HEVC с разрешением 4K в реальном времени с пригодным для вещания качеством с помощью Intel^® Visual Compute Accelerator на базе процессоров Intel^® Xeon^® E3 и некоторых процессоров Intel^® Xeon^® E5¹. Повышение стабильности декодирования AVC и MPEG2 позволяет обрабатывать ошибки в видеоматериалах. Подробные сведения о новых возможностях для перекодирования мультимедиа см. ниже.

Корпорация Intel является лидером в области ускорения обработки мультимедиа и облачных технологий. Благодаря мощи процессоров Intel^®и Intel^® Media Server Studio мы помогаем поставщикам решений мультимедиа, вещательным компаниям и разработчикам инфраструктуры создавать новые решения и добиваться высокой производительности, эффективности и высокого качества в приложениях для обработки мультимедиа и вещания видеоматериалов через Интернет.

Download [PDF 1.2MB]

Введение

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

Ошибочный подход № 1. Недостаточное понимание технологий разработки

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

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

Это один из примеров ситуации, когда мы, разработчики, идем по неверному пути. Впрочем, таких путей немало. К примеру, когда я был моложе и только начинал знакомство с разработкой программного обеспечения, я старался во всем подражать моему начальнику: все, что он делал, казалось мне безупречным и безусловно правильным. Когда мне нужно было что-нибудь сделать, я смотрел, как то же самое делает начальник, и стремился как можно точнее повторить все его действия. Неоднократно бывало, что я просто не понимал, почему его подход работает, но разве это важно? Главное, что все работает!

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

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

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

JavaScript* и DOM

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

Устранить такую проблему довольно просто. Посмотрите на следующий пример кода. Перед работой с объектом в переменной myFieldпроисходит удержание прямой ссылки. Новый код компактнее, его удобнее читать и понимать, и он быстрее работает, поскольку доступ к дереву DOM осуществляется только один раз.

Рассмотрим еще один пример. Этот пример взят из материала: http://code.tutsplus.com/tutorials/10-ways-to-instantly-increase-your-jquery-performance--net-5551

На следующем рисунке показаны два равноценных фрагмента кода. Каждый из них создает список с 1000 элементов li. Код справа добавляет атрибут idк каждому элементу li, а код слева добавляет атрибут classк каждому элементу li.

Как видите, вторая часть фрагмента кода просто обращается к каждому из тысячи созданных элементов li. Я измерил скорость в браузерах Internet Explorer* 10 и Chrome* 48: среднее время выполнения кода, приведенного слева, составило 57 мс, а время выполнения кода, показанного справа, — всего 9 мс, существенно меньше. Разница огромна, притом что в данном случае она обусловлена лишь разными способами доступа к элементам.

К этому примеру стоит отнестись крайне внимательно. В этом примере есть еще немало интересных для анализа моментов, например порядок проверки селекторов (здесь это порядок справа налево). Если вы используете jQuery*, то почитайте и про контекст DOM. Сведения об общих принципах производительности селекторов CSS см. в следующей статье: https://smacss.com/book/selectors

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

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

После создания такого объекта создаются тысячи объектов с помощью этих двух способов. Если сравнить объем памяти, используемой этими объектами, вы заметите разницу в использовании областей памяти Shallow Size и Retained Size в Chrome. Подход, где используется прототип, задействует примерно на 20 % меньше памяти (20 КБ по сравнению с 24 КБ) в области Shallow Size и на 66 % меньше в области Retained Memory (20 КБ по сравнению с 60 КБ).

Для получения дополнительных сведений о характеристиках памяти Shallow Size и Retained Size см.

https://developers.google.com/web/tools/chrome-devtools/profile/memory-problems/memory-101?hl=en

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

LINQ

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

Рассмотрим следующий распространенный сценарий. На следующем рисунке показано два функционально равноценных фрагмента кода. Цель кода — создать список всех отделений и всех курсов для каждого отделения в школе. В коде под названием Select N+1 мы выводим список всех отделений, а для каждого отделения — список курсов. Это означает, что при наличии 100 отделений нам потребуется 1 + 100 вызовов к базе данных.

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

Таким образом, можно повысить производительность в сотни раз, просто избегая подхода Select N+1.

Рассмотрим менее очевидный пример.

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

В примере Code #1, где ожидается тип данных IEnumerable, запрос выполняется непосредственно перед выполнением Take<Employee>(10). Это означает, что при наличии 1000 сотрудников они все будут получены из базы данных, после чего из них будет выбрано 10.

В примере Code #2 запрос выполняется после выполнения Take<Employee>(10).
Из базы данных при этом извлекается всего 10 записей.

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

http://www.codeproject.com/Articles/832189/List-vs-IEnumerable-vs-IQueryable-vs-ICollection-v

SQL Server*

В SQL необходимо изучить множество особенностей, чтобы добиться наивысшей производительности базы данных. Работать с SQL Server непросто: нужно понимать, как используются данные, какие таблицы запрашиваются чаще всего и какими именно полями.

Тем не менее для повышения производительности можно применять и ряд общих принципов, например:

• кластерные либо некластерные индексы;
• правильный порядок инструкций JOIN;
• понимание, когда следует использовать таблицы #tempи таблицы переменных;
• использование представлений либо индексированных представлений;
• использование заранее скомпилированных инструкций.

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

Изменение образа мышления

Итак, как мы, разработчики, должны изменить образ мышления, чтобы избегать ошибочного подхода № 1?

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

Ошибочный подход № 2. Предпочтение определенных технологий

Я занимаюсь разработкой на .NET с версии 1.0. Я в мельчайших подробностях знаю все особенности работы веб-форм, а также множества клиентских библиотек .NET (некоторые из них я самостоятельно изменил). Когда я узнал о выпуске Model View Controller (MVC), то не хотел его использовать: «Это нам не нужно».

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

Мне часто приходится слышать обсуждения, касающиеся либо связи LINQ с объектами в Entity Framework, либо хранимых процедур SQL при запросе данных. Люди настолько привыкли использовать одно или другое решение, что пытаются использовать их везде.

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

Иногда внешние факторы (например, жесткие сроки) вынуждают нас принимать неоптимальные решения. Для выбора наилучшей технологии требуется время: нужно читать, пробовать, сравнивать и делать выводы. При разработке нового продукта или новой версии существующего продукта часто бывает, что мы уже опаздываем: «Крайний срок — вчера». Два очевидных выхода из такой ситуации: затребовать дополнительное время или работать сверхурочно для самообразования.

Изменение образа мышления

Как мы, разработчики, должны изменить образ мышления, чтобы избегать ошибочного подхода № 2:

• Перестаньте говорить: «Этот способ всегда работал», «Мы всегда делали именно так» и т. д. Нужно знать и использовать и другие варианты, особенно если эти варианты в чем-то лучше.
• Не пытайтесь использовать неподходящие решения! Бывает, что разработчики упорно пытаются применять какую-то определенную технологию, которая не дает и не может дать нужных результатов. Разработчики тратят много времени и сил, стараясь все же как-то доработать эту технологию, подогнать ее под результат, не рассматривая иных вариантов. Такой неблагодарный процесс можно назвать «попыткой натянуть сову на глобус»: это стремление ценой любых усилий приспособить существующее неподходящее решение вместо того, чтобы сосредоточиться на проблеме и отыскать другое, более изящное и быстрое решение.
• «Мне некогда». Разумеется, у нас всегда не хватает времени на изучение нового. Это возражение я могу понять.

Ошибочный подход № 3.Недостаточное понимание инфраструктуры приложения

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

Отнюдь, все может быть вовсе не в порядке!

Задали ли вы себе следующие вопросы?

• Пригодно ли приложение для работы в среде с балансировкой нагрузки?
• Приложение будет размещено в облаке, где будет много экземпляров этого приложения?
• Сколько других приложений работают на машине, для которой предназначено мое приложение?
• Какие еще программы выполняются на этом сервере? SQL Server? Службы Reporting Services? Какие-либо расширения SharePoint*?
• Где находятся конечные пользователи? Они распределены по всему миру?
• Сколько пользователей будет у моего приложения в течение следующих пяти лет?

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

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

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

Возможна еще одна ситуация: предположим, что приложения работают на серверах, на которых одновременно запущена СУБД SQL Server и веб-сервер. В этом случае на одном физическом сервере выполняются одновременно две серверных системы с интенсивной нагрузкой на ЦП. Как решить эту проблему? Если мы говорим о приложении .NET на сервере Internet Information Services (IIS), то можно воспользоваться соответствием процессоров. Соответствие процессоров — это привязка одного процесса к одному или нескольким определенным ядрам ЦП компьютера.

К примеру, предположим, что на компьютере с четырьмя процессорами выполняется SQL Server и веб-сервер IIS.

Если позволить операционной системе решить, какой ЦП будет использоваться для SQL Server, а какой — для IIS, ресурсы могут распределяться по-разному. Возможно, что каждой серверной нагрузке будет назначено по два процессора.

А возможно, что все четыре процессора будут выделены только одной нагрузке.

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

Еще одна возможная ситуация: один процесс не будет все время работать на одном и том же ЦП. Будет часто возникать переключение контекста. Частое переключение контекста приведет к снижению производительности сначала самого сервера, а затем и приложений, работающих на этом сервере.

Один из способов решить эту проблему — использовать «соответствие процессоров» для IIS и SQL. В этом случае мы сами решаем, сколько процессоров нужно для SQL Server, а сколько — для IIS. Для этого нужно настроить параметры в разделе «Соответствие процессоров» в категории ЦП в IIS и «маску соответствия» в базе данных SQL Server. Оба этих случая показаны на следующих рисунках.

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

Изменение образа мышления

Как мы, разработчики, должны изменить образ мышления, чтобы избегать ошибочного подхода № 3?

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

Не оправдывайтесь!

Вам не в чем себя упрекнуть. Не все зависит только от вас. Действительно бывает некогда. У всех семьи, у всех хобби, всем нужно отдыхать.

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

Вот как их можно избежать.

1. Выделяйте время, если нужно — с запасом. Когда у вас просят оценить сроки, необходимые для работы над проектом, не забудьте выделить время для исследования и тестирования, для подготовки выводов и принятия решений.
2. Постарайтесь одновременно создать и личное приложение для тестирования. В этом приложении вы сможете пробовать разные решения перед их воплощением (или отказом от их воплощения) в разрабатываемом приложении. Мы все порой ошибаемся.
3. Найдите людей, уже владеющих нужной технологией, и попробуйте программировать вместе. Поработайте со специалистом, который разбирается в инфраструктуре, когда он будет развертывать приложение. Это время будет потрачено с пользой.
4. Избегайте переполнения стека! Большая часть моих проблем уже решена. Если просто копировать ответы, не анализируя их, вы в итоге получите неполное решение.
5. Не считайте себя узким специалистом, не ограничивайте свои возможности. Разумеется, если вам удастся стать экспертом в какой-либо области, это замечательно, но вы должны уметь поддержать разговор на должном уровне и в том случае, если разговор касается областей, в которых вы пока не являетесь экспертом.
6. Помогайте другим! Это, пожалуй, один из лучших способов обучения. Если вы помогаете другим решать их проблемы, то в конечном итоге вы сэкономите собственное время, поскольку уже будете знать, что делать, если столкнетесь с подобными проблемами.

См. также

Веселый и интересный блог Скотта Хансельмана (Scott Hanselman) о том, как лучше создавать код: разрабатывать самому или находить в Google.

http://www.hanselman.com/blog/AmIReallyADeveloperOrJustAGoodGoogler.aspx

Информация об объектах и прототипах:

http://thecodeship.com/web-development/methods-within-constructor-vs-prototype-in-javascript/

Об авторе

Александр Гарсия (Alexander García) — компьютерный инженер из филиала корпорации Intel в Коста-Рике. Он обладает 14-летним профессиональным опытом создания программного обеспечения. Сфера интересов Александра весьма разнообразна — от практики разработки программного обеспечения и безопасности программ до производительности, интеллектуального анализа данных и смежных областей.  В настоящее время Александр обладает ученой степенью магистра в области компьютерных наук.