---
metadata:
  - name: generator
    content: Diplodoc Platform v5.50.6
alternate:
  - https://ydb.tech/docs/en/contributor/load-actors-storage.md?version=main
  - https://ydb.tech/docs/ru/contributor/load-actors-storage.md?version=main
sourcePath: ru/core/contributor/load-actors-storage.md
---
> **Documentation Index:** Fetch the complete configuration index at https://ydb.tech/docs/ru/llms.txt

# StorageLoad

Тестирует производительность записи и чтения с Distributed Storage. Нагрузка подается непосредственно на Distributed Storage без задействования слоев таблеток и Query Processor. При тестировании производительности записи актор записывает данные в указанную группу хранения. Для тестирования чтения актор предварительно записывает данные в указанную группу хранения, а потом читает их. После снятия нагрузки все данные, записанные актором, удаляются.

Вы можете подать нагрузку трех видов:

* _Постоянная_  — актор следит, чтобы одновременно было запущено указанное число запросов. Чтобы подать постоянную нагрузку, задайте нулевую паузу между запросами (например, `WriteIntervals: { Weight: 1.0 Uniform: { MinUs: 0 MaxUs: 0 } }`) и отличный от нуля `MaxInFlightWriteRequests`, при этом не задавайте `WriteHardRateDispatcher`.
* _Интервальная_  — актор запускает запросы через заданные промежутки времени. Чтобы подать интервальную нагрузку, задайте ненулевую паузу между запросами (например, `WriteIntervals: { Weight: 1.0 Uniform: { MinUs: 50000 MaxUs: 50000 } }`) и не задавайте `WriteHardRateDispatcher`. Максимальное число одновременно выполняемых запросов задается параметром `InFlightWrites`. Если его значение равно `0`, то ограничения нет.
* _С фиксированной частотой_  — актор запускает запросы через определенные промежутки времени, величина которых меняется таким образом, чтобы поддерживать определенную частоту запросов в секунду. Если продолжительность нагрузки ограничена параметром `DurationSeconds`, то эта частота может отличаться в момент старта и в момент завершения нагрузки и будет изменяться равномерно на протяжении всего основного цикла нагрузки. Чтобы подать нагрузку этого вида, задайте описание [параметров нагрузки с фиксированной частотой](#hard-rate-dispatcher) (параметр `WriteHardRateDispatcher`). Обратите внимание, что если в параметрах актора задан `WriteHardRateDispatcher`, то запустится нагрузка с фиксированной частотой, вне зависимости значений `WriteIntervals`. Максимальное количество одновременно выполняемых запросов задается параметром `InFlightWrites`, если его значение равно `0`, то ограничения нет.

## Параметры актора {#options}

<!-- source: ru/_includes/load-actors-params.md -->
Ниже описаны основные параметры актора. Полный список параметров смотрите в файле [load_test.proto](https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/load_test.proto) Git-репозитория YDB.
<!-- endsource: ru/_includes/load-actors-params.md -->

| Параметр                   | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `DurationSeconds`          | Продолжительность нагрузки. Таймер запускается после завершения начальной записи данных.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `Tablets`                  | Нагрузка подается от имени таблетки со следующими реквизитами:<ul><li>`TabletId` — идентификатор таблетки. Должен быть уникальным для каждого нагружающего актора в кластере. Этот параметр и `TabletName` – взаимоисключающие.</li><li>`TabletName` — имя таблетки. Если задан этот параметр, идентификаторы таблеток назначаются автоматически, таблеткам, запущенным на одной и той же ноде с одним и тем же именем, присваиваются одинаковые идентификаторы, таблеткам на разных нодах присваиваются различные идентификаторы.</li><li>`Channel` — канал таблетки.</li><li>`GroupId` — идентификатор группы хранения, на которую будет подана нагрузка.</li><li>`Generation` — поколение таблетки.</li></ul>  |
| `WriteSizes`               | Размер записываемых данных. Для каждого запроса выбирается случайным образом из интервала `Min`-`Max`. Вы можете задать несколько диапазонов `WriteSizes`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `WriteHardRateDispatcher`  | Описание [параметров нагрузки с фиксированной частотой](#hard-rate-dispatcher) для запросов записи. Если задан этот параметр, то значение `WriteIntervals` игнорируется.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `WriteIntervals`           | Описание [параметров вероятностного распределения](#params) временных интервалов между записями для интервальной нагрузки в микросекундах. Вы можете задать несколько диапазонов `WriteIntervals`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `MaxInFlightWriteRequests` | Максимальное количество одновременно обрабатываемых запросов на запись.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ReadSizes`                | Размер читаемых данных. Для каждого запроса выбирается случайным образом из интервала `Min`-`Max`. Вы можете задать несколько диапазонов `ReadSizes`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `ReadIntervals`            | Описание [параметров вероятностного распределения](#params) временных интервалов между запросами для интервальной нагрузки в микросекундах. Вы можете задать несколько диапазонов `ReadIntervals`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `ReadHardRateDispatcher`   | Описание [параметров нагрузки с фиксированной частотой](#hard-rate-dispatcher) для запросов чтения. Если задан этот параметр, то значение `ReadIntervals` игнорируется.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `MaxInFlightReadRequests`  | Максимальное количество одновременно обрабатываемых запросов на чтение.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `FlushIntervals`           | Описание [параметров вероятностного распределения](#params) временных интервалов между запросами на удаление записанных основным циклом StorageLoad данных в микросекундах. Вы можете задать несколько диапазонов `FlushIntervals`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`. Одновременно будет обрабатываться только один запрос на удаление записанных данных.                                                                                                                                                                                                                                                                                                          |
| `PutHandleClass`           | [Класс записи данных](#write-class) в дисковую подсистему. В случае `TabletLog` запись выполняется с максимальным приоритетом.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `GetHandleClass`           | [Класс чтения данных](#read-class) с дисковой подсистемы. В случае `FastRead` чтение выполняется с максимальной скоростью.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|  `InitialAllocation`       | Описание [параметров начальной записи данных](#initial-allocation). Определяет объем данных, который будет записан до старта основной нагрузки, и которые затем могут быть прочитаны запросами чтения, наряду с данными, записанными в основном цикле нагрузки.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

### Write requests class {#write-class}

| Class       | Description                                                         |
|-------------|---------------------------------------------------------------------|
| `TabletLog` | Самый высокий приоритет запросов записи.                            |
| `AsyncBlob` | Используется для записи таблиц SSTable и их частей.                 |
| `UserData`  | Используется для записи пользовательских данных отдельными блобами. |

### Read requests class {#read-class}

| Class       | Description                                                            |
|-------------|------------------------------------------------------------------------|
| `AsyncRead` | Используется для чтения данных таблеток, прошедших процесс компакшена. |
| `FastRead`  | Используется для быстрого чтения пользовательских данных.              |
| `Discover`  | Чтения запросов Discover.                                              |
| `LowRead`   | Низкоприоритетные чтения, выполняемые на фоне.                         |

### Параметры вероятностного распределения {#params}

<!-- source: ru/_includes/load-actors-interval.md -->
Интервал, записанный в виде repeated-поля `TIntervalInfo`, вычисляется по следующему алгоритму:

* случайным образом выбирается элемент из массива `TIntervalInfo` с вероятностью, пропорциональной весу;
* для элемента типа `TIntervalUniform` равновероятно выбирается значение в интервале `Min-Max` (если указано `MinMs/MaxMs`, то значение в миллисекундах; если `MinUs/MaxUs` — в микросекундах);
* для элемента типа `TIntervalPoisson` выбирается интервал по формуле `Min(log(-x / Frequency), MaxIntervalMs)`, где `x` — случайное значение в интервале `[0, 1]`, что обеспечивает соответствие интервалов распределению Пуассона с частотой `Frequency`, но с интервалом не больше `MaxIntervalMs`.

Аналогичный механизм применяется и для вероятностного распределения размеров записываемых данных, за исключением того, что в том механизме есть только равновероятное распределение размера `[Min, Max]`.
<!-- endsource: ru/_includes/load-actors-interval.md -->

### Параметры нагрузки с фиксированной частотой {#hard-rate-dispatcher}

| Параметр                     | Описание                                                                                                                                                                   |
|------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `RequestsPerSecondAtStart`   | Частота запросов в секунду в момент старта нагрузки. Если продолжительность нагрузки не задана, то частота запросов остается постоянной и равной величине этого параметра. |
|  `RequestsPerSecondOnFinish` | Частота запросов в секунду в момент завершения нагрузки.                                                                                                                   |

### Параметры начальной записи данных {#initial-allocation}

| Параметр                   | Описание                                                                                                                                                                                                                                   |
|----------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `TotalSize`                | Суммарный размер записанных данных. Этот параметр и `BlobsNumber` – взаимосключающие.                                                                                                                                                      |
| `BlobsNumber`              | Количество записанных блобов.                                                                                                                                                                                                              |
| `BlobSizes`                | Размер записываемых блобов. Для каждого запроса выбирается случайным образом из интервала `Min`-`Max`. Вы можете задать несколько диапазонов `BlobSizes`, и тогда выбор значения из конкретного диапазона будет определяться его `Weight`. |
| `MaxWritesInFlight`        | Максимальное количество одновременно обрабатываемых запросов на запись. Если парамаетр не задан, то ограничения на количество одновременно обрабатываемых запросов нет.                                                                    |
| `MaxWriteBytesInFlight`    | Максимальный суммарный объем данных одновременно обрабатываемых запросов на запись. Если парамаетр не задан, то ограничения на суммарный объем данных одновременно обрабатываемых запросов нет.                                            |
| `PutHandleClass`           | [Класс записи данных](#write-class) в дисковую подсистему.                                                                                                                                                                                          |
| `DelayAfterCompletionSec`  | Время в секундах, которое актор ждет от момента завершения начальной записи данных до момента старта основной нагрузки. Если параметр не задан, нагрузка начнется сразу же после завершения начальной записи данных.                       |

## Примеры {#examples}

### Нагрузка на запись {#write}

Следующий актор будет писать в группу с идентификатором `2181038080` в течение `60` секунд. Размер одной записи `4096` байт, число одновременно выполняемых запросов не более `256` (постоянная нагрузка):

```proto
StorageLoad: {
    DurationSeconds: 60
    Tablets: {
        Tablets: { TabletId: 1000 Channel: 0 GroupId: 2181038080 Generation: 1 }
        WriteSizes: { Weight: 1.0 Min: 4096 Max: 4096 }
        WriteIntervals: { Weight: 1.0 Uniform: { MinUs: 0 MaxUs: 0 } }
        MaxInFlightWriteRequests: 256
        FlushIntervals: { Weight: 1.0 Uniform: { MinUs: 10000000 MaxUs: 10000000 } }
        PutHandleClass: TabletLog
    }
}
```

При просмотре результата тестирования наибольший интерес представляют следующие значения:

* `Writes per seconds` — количество записей в секунду, например `28690.29`.
* `Speed@ 100%` — 100 перцентиль скорости записи в МБ/с, например `108.84`.

### Нагрузка на чтение {#read}

Чтобы подать нагрузку на чтение, необходимо сначала записать данные. Данные записываются запросами по `4096` байт каждые `50` мс, при этом число одновременно выполняемых запросов не более `1` (интервальная нагрузка). Если запрос не успеет завершиться за `50` мс, актор дождется его завершения и через `50` мс запустит следующий запрос. Данные старше `10` с удаляются. Чтение данных выполнятся запросами по `4096` байт, число одновременно выполняемых запросов `16` (постоянная нагрузка):

```proto
StorageLoad: {
    DurationSeconds: 60
    Tablets: {
        Tablets: { TabletId: 5000 Channel: 0 GroupId: 2181038080 Generation: 1 }
        WriteSizes: { Weight: 1.0 Min: 4096 Max: 4096}
        WriteIntervals: { Weight: 1.0 Uniform: { MinUs: 50000 MaxUs: 50000 } }
        MaxInFlightWriteRequests: 1

        ReadSizes: { Weight: 1.0 Min: 4096 Max: 4096 }
        ReadIntervals: { Weight: 1.0 Uniform: { MinUs: 0 MaxUs: 0 } }
        MaxInFlightReadRequests: 16
        FlushIntervals: { Weight: 1.0 Uniform: { MinUs: 10000000 MaxUs: 10000000 } }
        PutHandleClass: TabletLog
        GetHandleClass: FastRead
    }
}
```

При просмотре результата тестирования наибольший интерес представляют следующие значение:

* `ReadSpeed@ 100%` — 100 перцентиль скорости чтения МБ/с, например `60.86`.

### Нагрузка только на чтение {#readonly}

До старта основной нагрузки записывается блок данных, объемом `1 GB`, состоящий из блобов размером от `1 MB` до `5 MB`. Чтобы не перегрузить систему запросами записи, количество одновременно выполняемых запросов ограничивается `5`. После завершения записи этого блока запускается readonly нагрузка с возрастающей частотой: с `10` до `50` запросов в секунду, частота возрастает равномерно на протяжении `300` секунд.

```proto
StorageLoad: {
    DurationSeconds: 300
    Tablets: {
        Tablets: { TabletId: 5000 Channel: 0 GroupId: 2181038080 Generation: 1 }

        MaxInFlightReadRequests: 10
        GetHandleClass: FastRead
        ReadHardRateDispatcher {
                RequestsPerSecondAtStart: 10
                RequestsPerSecondOnFinish: 50
        }

        InitialAllocation {
                TotalSize: 1000000000
                BlobSizes: { Weight: 1.0 Min: 1000000 Max: 5000000 }
                MaxWritesInFlight: 5
        }
    }
}
```

Рассчитанные перцентили скорости чтения/записи относятся только к запросам основного цикла нагрузки, запросы начальной записи в них не учитываются. Представляют интерес [графики в Monitoring](https://ydb.tech/docs/ru/reference/observability/metrics/grafana-dashboards.md?version=main), например, по ним можно проследить, как ухудшается время отклика системы по мере роста нагрузки.

<!-- source: ru/contributor/_includes/career.md -->
{% note tip "Хотите присоединиться к команде разработки YDB?" %}

Ознакомьтесь с разделами о [команде YDB и открытых вакансиях](https://ydb.tech/ru/careers/), а также о [возможностях для студентов](https://ydb.tech/ru/students/).

{% endnote %}
<!-- endsource: ru/contributor/_includes/career.md -->