diff options
Diffstat (limited to 'libs')
24 files changed, 1208 insertions, 1566 deletions
diff --git a/libs/libmdbx/src/packages/rpm/CMakeLists.txt b/libs/libmdbx/src/CMakeLists.txt index b664075556..b664075556 100644 --- a/libs/libmdbx/src/packages/rpm/CMakeLists.txt +++ b/libs/libmdbx/src/CMakeLists.txt diff --git a/libs/libmdbx/src/README-RU.md b/libs/libmdbx/src/README-RU.md index 5dd062c1a6..f4ae5e8f14 100644 --- a/libs/libmdbx/src/README-RU.md +++ b/libs/libmdbx/src/README-RU.md @@ -12,31 +12,31 @@ and [by Yandex](https://translate.yandex.ru/translate?url=https%3A%2F%2Fgithub.c ### Project Status -**Сейчас MDBX _активно перерабатывается_** и к середине 2018 ожидается -большое изменение как API, так и формата базы данных. К сожалению, -обновление приведет к потере совместимости с предыдущими версиями. - -Цель этой революции - обеспечение более четкого надежного API и -добавление новых функции, а также наделение базы данных новыми -свойствами. - -В настоящее время MDBX предназначена для Linux, а также поддерживает -Windows (начиная с Windows Server 2008) в качестве дополнительной -платформы. Поддержка других ОС может быть обеспечена на коммерческой -основе. Однако такие усовершенствования (т. е. pull-requests) могут быть -приняты в мейнстрим только в том случае, если будет доступен -соответствующий публичный и бесплатный сервис непрерывной интеграции -(aka Continuous Integration). + +**Сейчас MDBX _активно перерабатывается_** и к середине 2018 +ожидается большое изменение как API, так и формата базы данных. +К сожалению, обновление приведет к потере совместимости с +предыдущими версиями. + +Цель этой революции - обеспечение более четкого надежного +API и добавление новых функции, а также наделение базы данных +новыми свойствами. + +В настоящее время MDBX предназначена для Linux, а также +поддерживает Windows (начиная с Windows Server 2008) в качестве +дополнительной платформы. Поддержка других ОС может быть +обеспечена на коммерческой основе. Однако такие +усовершенствования (т. е. pull-requests) могут быть приняты в +мейнстрим только в том случае, если будет доступен +соответствующий публичный и бесплатный сервис непрерывной +интеграции (aka Continuous Integration). ## Содержание + - [Обзор](#Обзор) - [Сравнение с другими СУБД](#Сравнение-с-другими-СУБД) - [История & Acknowledgments](#История) - [Основные свойства](#Основные-свойства) -- [Доработки и усовершенствования относительно LMDB](#Доработки-и-усовершенствования-относительно-lmdb) -- [Недостатки и Компромиссы](#Недостатки-и-Компромиссы) - - [Проблема долгих чтений](#Проблема-долгих-чтений) - - [Сохранность данных в режиме асинхронной фиксации](#Сохранность-данных-в-режиме-асинхронной-фиксации) - [Сравнение производительности](#Сравнение-производительности) - [Интегральная производительность](#Интегральная-производительность) - [Масштабируемость чтения](#Масштабируемость-чтения) @@ -44,18 +44,21 @@ Windows (начиная с Windows Server 2008) в качестве дополн - [Отложенная фиксация](#Отложенная-фиксация) - [Асинхронная фиксация](#Асинхронная-фиксация) - [Потребление ресурсов](#Потребление-ресурсов) +- [Недостатки и Компромиссы](#Недостатки-и-Компромиссы) + - [Проблема долгих чтений](#Проблема-долгих-чтений) + - [Сохранность данных в режиме асинхронной фиксации](#Сохранность-данных-в-режиме-асинхронной-фиксации) +- [Доработки и усовершенствования относительно LMDB](#Доработки-и-усовершенствования-относительно-lmdb) ## Обзор + _libmdbx_ - это встраиваемый key-value движок хранения со специфическим набором свойств и возможностей, ориентированный на создание уникальных -легковесных решений с предельной производительностью под Linux и -Windows. +легковесных решений с предельной производительностью под Linux и Windows. _libmdbx_ позволяет множеству процессов совместно читать и обновлять -несколько key-value таблиц с соблюдением -[ACID](https://ru.wikipedia.org/wiki/ACID), при минимальных накладных -расходах и амортизационной стоимости любых операций Olog(N). +несколько key-value таблиц с соблюдением [ACID](https://ru.wikipedia.org/wiki/ACID), +при минимальных накладных расходах и амортизационной стоимости любых операций Olog(N). _libmdbx_ обеспечивает [serializability](https://en.wikipedia.org/wiki/Serializability) @@ -69,26 +72,20 @@ _libmdbx_ позволяет выполнять операции чтения с параллельно на каждом ядре CPU, без использования атомарных операций и/или примитивов синхронизации. -_libmdbx_ не использует -[LSM](https://en.wikipedia.org/wiki/Log-structured_merge-tree), а -основан на [B+Tree](https://en.wikipedia.org/wiki/B%2B_tree) с -[отображением](https://en.wikipedia.org/wiki/Memory-mapped_file) всех -данных в память, при этом текущая версия не использует -[WAL](https://en.wikipedia.org/wiki/Write-ahead_logging). Это -предопределяет многие свойства, в том числе удачные и противопоказанные -сценарии использования. - +_libmdbx_ не использует [LSM](https://en.wikipedia.org/wiki/Log-structured_merge-tree), а основан на [B+Tree](https://en.wikipedia.org/wiki/B%2B_tree) с [отображением](https://en.wikipedia.org/wiki/Memory-mapped_file) всех данных в память, +при этом текущая версия не использует [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging). +Это предопределяет многие свойства, в том числе удачные и противопоказанные сценарии использования. ### Сравнение с другими СУБД -Ввиду того, что в _libmdbx_ сейчас происходит революция, я посчитал -лучшим решением ограничится здесь ссылкой на [главу Comparison with -other databases](https://github.com/coreos/bbolt#comparison-with-other-databases) -в описании _BoltDB_. + +Ввиду того, что в _libmdbx_ сейчас происходит революция, я посчитал лучшим решением +ограничится здесь ссылкой на [главу Comparison with other databases](https://github.com/coreos/bbolt#comparison-with-other-databases) в описании _BoltDB_. ### История -_libmdbx_ является результатом переработки и развития "Lightning -Memory-Mapped Database", известной под аббревиатурой + +_libmdbx_ является результатом переработки и развития "Lightning Memory-Mapped Database", +известной под аббревиатурой [LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database). Изначально доработка производилась в составе проекта [ReOpenLDAP](https://github.com/leo-yuriev/ReOpenLDAP). Примерно за год @@ -105,223 +102,226 @@ Technologies](https://www.ptsecurity.ru). #### Acknowledgments -Howard Chu (Symas Corporation) - the author of LMDB, from which -originated the MDBX in 2015. -Martin Hedenfalk <martin@bzero.se> - the author of `btree.c` code, which -was used for begin development of LMDB. +Howard Chu (Symas Corporation) - the author of LMDB, +from which originated the MDBX in 2015. + +Martin Hedenfalk <martin@bzero.se> - the author of `btree.c` code, +which was used for begin development of LMDB. Основные свойства ================= -_libmdbx_ наследует все ключевые возможности и особенности своего -прародителя -[LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database), -но с устранением ряда описываемых далее проблем и архитектурных -недочетов. - -1. Данные хранятся в упорядоченном отображении (ordered map), ключи -всегда отсортированы, поддерживается выборка диапазонов (range lookups). - -2. Данные отображается в память каждого работающего с БД процесса. К -данным и ключам обеспечивается прямой доступ в памяти без необходимости -их копирования. - -3. Транзакции согласно [ACID](https://ru.wikipedia.org/wiki/ACID), -посредством [MVCC](https://ru.wikipedia.org/wiki/MVCC) и -[COW](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8). -Изменения строго последовательны и не блокируются чтением, конфликты -между транзакциями невозможны. При этом гарантируется чтение только -зафиксированных данных, см [relaxing -serializability](https://en.wikipedia.org/wiki/Serializability). - -4. Чтение и поиск [без -блокировок](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), -без [атомарных -операций](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D0%B0%D1%8F_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F). -Читатели не блокируются операциями записи и не конкурируют между собой, -чтение масштабируется линейно по ядрам CPU. +_libmdbx_ наследует все ключевые возможности и особенности +своего прародителя [LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database), +но с устранением ряда описываемых далее проблем и архитектурных недочетов. + +1. Данные хранятся в упорядоченном отображении (ordered map), ключи всегда + отсортированы, поддерживается выборка диапазонов (range lookups). + +2. Данные отображается в память каждого работающего с БД процесса. + К данным и ключам обеспечивается прямой доступ в памяти без необходимости их + копирования. + +3. Транзакции согласно + [ACID](https://ru.wikipedia.org/wiki/ACID), посредством + [MVCC](https://ru.wikipedia.org/wiki/MVCC) и + [COW](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8). + Изменения строго последовательны и не блокируются чтением, + конфликты между транзакциями невозможны. + При этом гарантируется чтение только зафиксированных данных, см [relaxing serializability](https://en.wikipedia.org/wiki/Serializability). + +4. Чтение и поиск [без блокировок](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), + без [атомарных операций](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D0%B0%D1%8F_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F). + Читатели не блокируются операциями записи и не конкурируют + между собой, чтение масштабируется линейно по ядрам CPU. > Для точности следует отметить, что "подключение к БД" (старт первой > читающей транзакции в потоке) и "отключение от БД" (закрытие БД или > завершение потока) требуют краткосрочного захвата блокировки для > регистрации/дерегистрации текущего потока в "таблице читателей". -5. Эффективное хранение дубликатов (ключей с несколькими значениями), -без дублирования ключей, с сортировкой значений, в том числе -целочисленных (для вторичных индексов). +5. Эффективное хранение дубликатов (ключей с несколькими + значениями), без дублирования ключей, с сортировкой значений, в + том числе целочисленных (для вторичных индексов). -6. Эффективная поддержка коротких ключей фиксированной длины, в том -числе целочисленных. +6. Эффективная поддержка коротких ключей фиксированной длины, в том числе целочисленных. 7. Амортизационная стоимость любой операции Olog(N), -[WAF](https://en.wikipedia.org/wiki/Write_amplification) (Write -Amplification Factor) и RAF (Read Amplification Factor) также Olog(N). + [WAF](https://en.wikipedia.org/wiki/Write_amplification) (Write + Amplification Factor) и RAF (Read Amplification Factor) также Olog(N). -8. Нет [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) и -журнала транзакций, после сбоев не требуется восстановление. Не -требуется компактификация или какое-либо периодическое обслуживание. -Поддерживается резервное копирование "по горячему", на работающей БД без -приостановки изменения данных. +8. Нет [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) и журнала + транзакций, после сбоев не требуется восстановление. Не требуется компактификация + или какое-либо периодическое обслуживание. Поддерживается резервное копирование + "по горячему", на работающей БД без приостановки изменения данных. -9. Отсутствует какое-либо внутреннее управление памятью или -кэшированием. Всё необходимое штатно выполняет ядро ОС. +9. Отсутствует какое-либо внутреннее управление памятью или кэшированием. Всё + необходимое штатно выполняет ядро ОС! -Доработки и усовершенствования относительно LMDB -================================================ +Сравнение производительности +============================ -1. Утилита `mdbx_chk` для проверки целостности структуры БД. +Все представленные ниже данные получены многократным прогоном тестов на +ноутбуке Lenovo Carbon-2, i7-4600U 2.1 ГГц, 8 Гб ОЗУ, с SSD-диском +SAMSUNG MZNTD512HAGL-000L1 (DXT23L0Q) 512 Гб. -2. Автоматическое динамическое управление размером БД согласно -параметрам задаваемым функцией `mdbx_env_set_geometry()`, включая шаг -приращения и порог уменьшения размера БД, а также выбор размера -страницы. Соответственно, это позволяет снизить фрагментированность -файла БД на диске и освободить место, в том числе в **Windows**. +Исходный код бенчмарка [_IOArena_](https://github.com/pmwkaa/ioarena) и +сценарии тестирования [доступны на +github](https://github.com/pmwkaa/ioarena/tree/HL%2B%2B2015). -3. Автоматическая без-затратная компактификация БД путем возврата -освобождающихся страниц в область нераспределенного резерва в конце -файла данных. При этом уменьшается количество страниц находящихся в -памяти и участвующих в в обмене с диском. +-------------------------------------------------------------------------------- -4. Поддержка ключей и значений нулевой длины, включая сортированные -дубликаты. +### Интегральная производительность -5. Возможность связать с каждой завершаемой транзакцией до 3 -дополнительных маркеров посредством `mdbx_canary_put()`, и прочитать их -в транзакции чтения посредством `mdbx_canary_get()`. +Показана соотнесенная сумма ключевых показателей производительности в трёх +бенчмарках: -6. Возможность посредством `mdbx_replace()` обновить или удалить запись -с получением предыдущего значения данных, а также адресно изменить -конкретное multi-значение. + - Чтение/Поиск на машине с 4-мя процессорами; -7. Режим `LIFO RECLAIM`. + - Транзакции с [CRUD](https://ru.wikipedia.org/wiki/CRUD)-операциями + (вставка, чтение, обновление, удаление) в режиме **синхронной фиксации** + данных (fdatasync при завершении каждой транзакции или аналог); - Для повторного использования выбираются не самые старые, а - самые новые страницы из доступных. За счет этого цикл - использования страниц всегда имеет минимальную длину и не - зависит от общего числа выделенных страниц. + - Транзакции с [CRUD](https://ru.wikipedia.org/wiki/CRUD)-операциями + (вставка, чтение, обновление, удаление) в режиме **отложенной фиксации** + данных (отложенная запись посредством файловой систем или аналог); - В результате механизмы кэширования и обратной записи работают с - максимально возможной эффективностью. В случае использования - контроллера дисков или системы хранения с - [BBWC](https://en.wikipedia.org/wiki/BBWC) возможно - многократное увеличение производительности по записи - (обновлению данных). +*Бенчмарк в режиме асинхронной записи не включен по двум причинам:* -8. Генерация последовательностей посредством `mdbx_dbi_sequence()`. + 1. Такое сравнение не совсем правомочно, его следует делать с движками + ориентированными на хранение данных в памяти ([Tarantool](https://tarantool.io/), [Redis](https://redis.io/)). -9. Обработчик `OOM-KICK`. + 2. Превосходство libmdbx становится еще более подавляющим, что мешает + восприятию информации. - Посредством `mdbx_env_set_oomfunc()` может быть установлен - внешний обработчик (callback), который будет вызван при - исчерпании свободных страниц по причине долгой операцией чтения - на фоне интенсивного изменения данных. - Обработчику будет передан PID и pthread_id виновника. - В свою очередь обработчик может предпринять одно из действий: + - * нейтрализовать виновника (отправить сигнал kill #9), если - долгое чтение выполняется сторонним процессом; +-------------------------------------------------------------------------------- - * отменить или перезапустить проблемную операцию чтения, если - операция выполняется одним из потоков текущего процесса; +### Масштабируемость чтения - * подождать некоторое время, в расчете на то, что проблемная операция - чтения будет штатно завершена; +Для каждого движка показана суммарная производительность при +одновременном выполнении запросов чтения/поиска в 1-2-4-8 потоков на +машине с 4-мя физическими процессорами. - * прервать текущую операцию изменения данных с возвратом кода - ошибки. + -10. Возможность открыть БД в эксклюзивном режиме посредством флага -`MDBX_EXCLUSIVE`. +-------------------------------------------------------------------------------- -11. Возможность получить отставание текущей транзакции чтения от -последней версии данных в БД посредством `mdbx_txn_straggler()`. +### Синхронная фиксация -12. Возможность явно запросить обновление существующей записи, без -создания новой посредством флажка `MDBX_CURRENT` для `mdbx_put()`. + - Линейная шкала слева и темные прямоугольники соответствуют количеству + транзакций в секунду, усредненному за всё время теста. -13. Исправленный вариант `mdbx_cursor_count()`, возвращающий корректное -количество дубликатов для всех типов таблиц и любого положения курсора. + - Логарифмическая шкала справа и желтые интервальные отрезки + соответствуют времени выполнения транзакций. При этом каждый отрезок + показывает минимальное и максимальное время, затраченное на выполнение + транзакций, а крестиком отмечено среднеквадратичное значение. -14. Возможность получить посредством `mdbx_env_info()` дополнительную -информацию, включая номер самой старой версии БД (снимка данных), -который используется одним из читателей. +Выполняется **10.000 транзакций в режиме синхронной фиксации данных** на +диске. При этом требуется гарантия, что при аварийном выключении питания +(или другом подобном сбое) все данные будут консистентны и полностью +соответствовать последней завершенной транзакции. В _libmdbx_ в этом +режиме при фиксации каждой транзакции выполняется системный вызов +[fdatasync](https://linux.die.net/man/2/fdatasync). -15. Функция `mdbx_del()` не игнорирует дополнительный (уточняющий) -аргумент `data` для таблиц без дубликатов (без флажка `MDBX_DUPSORT`), а -при его ненулевом значении всегда использует его для сверки с удаляемой -записью. +В каждой транзакции выполняется комбинированная CRUD-операция (две +вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует +на пустой базе, а при завершении, в результате выполняемых действий, в +базе насчитывается 10.000 небольших key-value записей. -16. Возможность открыть dbi-таблицу, одновременно с установкой -компараторов для ключей и данных, посредством `mdbx_dbi_open_ex()`. + -17. Возможность посредством `mdbx_is_dirty()` определить находятся ли -некоторый ключ или данные в "грязной" странице БД. Таким образом, -избегая лишнего копирования данных перед выполнением модифицирующих -операций (значения, размещенные в "грязных" страницах, могут быть -перезаписаны при изменениях, иначе они будут неизменны). +-------------------------------------------------------------------------------- -18. Корректное обновление текущей записи, в том числе сортированного -дубликата, при использовании режима `MDBX_CURRENT` в -`mdbx_cursor_put()`. +### Отложенная фиксация -19. Возможность узнать есть ли за текущей позицией курсора строка данных -посредством `mdbx_cursor_eof()`. + - Линейная шкала слева и темные прямоугольники соответствуют количеству + транзакций в секунду, усредненному за всё время теста. -20. Дополнительный код ошибки `MDBX_EMULTIVAL`, который возвращается из -`mdbx_put()` и `mdbx_replace()` при попытке выполнить неоднозначное -обновление или удаления одного из нескольких значений с одним ключом. + - Логарифмическая шкала справа и желтые интервальные отрезки + соответствуют времени выполнения транзакций. При этом каждый отрезок + показывает минимальное и максимальное время, затраченное на выполнение + транзакций, а крестиком отмечено среднеквадратичное значение. -21. Возможность посредством `mdbx_get_ex()` получить значение по -заданному ключу, одновременно с количеством дубликатов. +Выполняется **100.000 транзакций в режиме отложенной фиксации данных** +на диске. При этом требуется гарантия, что при аварийном выключении +питания (или другом подобном сбое) все данные будут консистентны на +момент завершения одной из транзакций, но допускается потеря изменений +из некоторого количества последних транзакций, что для многих движков +предполагает включение +[WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) (write-ahead +logging) либо журнала транзакций, который в свою очередь опирается на +гарантию упорядоченности данных в журналируемой файловой системе. +_libmdbx_ при этом не ведет WAL, а передает весь контроль файловой +системе и ядру ОС. -22. Наличие функций `mdbx_cursor_on_first()` и `mdbx_cursor_on_last()`, -которые позволяют быстро выяснить стоит ли курсор на первой/последней -позиции. +В каждой транзакции выполняется комбинированная CRUD-операция (две +вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует +на пустой базе, а при завершении, в результате выполняемых действий, в +базе насчитывается 100.000 небольших key-value записей. -23. Возможность автоматического формирования контрольных точек (сброса -данных на диск) при накоплении заданного объёма изменений, -устанавливаемого функцией `mdbx_env_set_syncbytes()`. + -24. Управление отладкой и получение отладочных сообщений посредством -`mdbx_setup_debug()`. +-------------------------------------------------------------------------------- -25. Функция `mdbx_env_pgwalk()` для обхода всех страниц БД. +### Асинхронная фиксация -26. Три мета-страницы вместо двух, что позволяет гарантированно -консистентно обновлять слабые контрольные точки фиксации без риска -повредить крайнюю сильную точку фиксации. + - Линейная шкала слева и темные прямоугольники соответствуют количеству + транзакций в секунду, усредненному за всё время теста. -27. Гарантия сохранности БД в режиме `WRITEMAP+MAPSYNC`. - > В текущей версии _libmdbx_ вам предоставляется выбор между безопасным - > режимом (по умолчанию) асинхронной фиксации, и режимом `UTTERLY_NOSYNC` - > когда при системной аварии есть шанс полного разрушения БД как в LMDB. - > Для подробностей смотрите раздел - > [Сохранность данных в режиме асинхронной фиксации](#Сохранность-данных-в-режиме-асинхронной-фиксации). + - Логарифмическая шкала справа и желтые интервальные отрезки + соответствуют времени выполнения транзакций. При этом каждый отрезок + показывает минимальное и максимальное время, затраченное на выполнение + транзакций, а крестиком отмечено среднеквадратичное значение. -28. Возможность закрыть БД в "грязном" состоянии (без сброса данных и -формирования сильной точки фиксации) посредством `mdbx_env_close_ex()`. +Выполняется **1.000.000 транзакций в режиме асинхронной фиксации +данных** на диске. При этом требуется гарантия, что при аварийном +выключении питания (или другом подобном сбое) все данные будут +консистентны на момент завершения одной из транзакций, но допускается +потеря изменений из значительного количества последних транзакций. Во +всех движках при этом включался режим предполагающий минимальную +нагрузку на диск по записи, и соответственно минимальную гарантию +сохранности данных. В _libmdbx_ при этом используется режим асинхронной +записи измененных страниц на диск посредством ядра ОС и системного +вызова [msync(MS_ASYNC)](https://linux.die.net/man/2/msync). -29. При завершении читающих транзакций, открытые в них DBI-хендлы не -закрываются и не теряются при завершении таких транзакций посредством -`mdbx_txn_abort()` или `mdbx_txn_reset()`. Что позволяет избавится от ряда -сложно обнаруживаемых ошибок. +В каждой транзакции выполняется комбинированная CRUD-операция (две +вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует +на пустой базе, а при завершении, в результате выполняемых действий, в +базе насчитывается 10.000 небольших key-value записей. -30. Все курсоры, как в транзакциях только для чтения, так и в пишущих, -могут быть переиспользованы посредством `mdbx_cursor_renew()` и ДОЛЖНЫ -ОСВОБОЖДАТЬСЯ ЯВНО. - > - > ## _ВАЖНО_, Обратите внимание! - > - > Это единственное изменение в API, которое значимо меняет - > семантику управления курсорами и может приводить к утечкам - > памяти. Следует отметить, что это изменение вынужденно. - > Так устраняется неоднозначность с массой тяжких последствий: - > - > - обращение к уже освобожденной памяти; - > - попытки повторного освобождения памяти; - > - повреждение памяти и ошибки сегментации. + + +-------------------------------------------------------------------------------- + +### Потребление ресурсов + +Показана соотнесенная сумма использованных ресурсов в ходе бенчмарка в +режиме отложенной фиксации: + + - суммарное количество операций ввода-вывода (IOPS), как записи, так и + чтения. + + - суммарное затраченное время процессора, как в режиме пользовательских процессов, + так и в режиме ядра ОС. + + - использованное место на диске при завершении теста, после закрытия БД из тестирующего процесса, + но без ожидания всех внутренних операций обслуживания (компактификации LSM и т.п.). + +Движок _ForestDB_ был исключен при оформлении результатов, так как +относительно конкурентов многократно превысил потребление каждого из +ресурсов (потратил процессорное время на генерацию IOPS для заполнения +диска), что не позволяло наглядно сравнить показатели остальных движков +на одной диаграмме. + +Все данные собирались посредством системного вызова +[getrusage()](http://man7.org/linux/man-pages/man2/getrusage.2.html) и +сканированием директорий с данными. + + -------------------------------------------------------------------------------- @@ -382,6 +382,7 @@ Amplification Factor) и RAF (Read Amplification Factor) также Olog(N). #### Проблема долгих чтений + *Следует отметить*, что проблема "сборки мусора" так или иначе существует во всех СУБД (Vacuum в PostgreSQL). Однако в случае _libmdbx_ и LMDB она проявляется более остро, прежде всего из-за высокой @@ -447,17 +448,19 @@ Amplification Factor) и RAF (Read Amplification Factor) также Olog(N). за счет эффективной работы [BBWC](https://en.wikipedia.org/wiki/BBWC) при включении `LIFO RECLAIM` в _libmdbx_. + #### Сохранность данных в режиме асинхронной фиксации + При работе в режиме `WRITEMAP+MAPSYNC` запись измененных страниц выполняется ядром ОС, что имеет ряд преимуществ. Так например, при крахе приложения, ядро ОС сохранит все изменения. Однако, при аварийном отключении питания или сбое в ядре ОС, на диске -может быть сохранена только часть измененных страниц БД. При этом с -большой вероятностью может оказаться, что будут сохранены мета-страницы -со ссылками на страницы с новыми версиями данных, но не сами новые -данные. В этом случае БД будет безвозвратна разрушена, даже если до -аварии производилась полная синхронизация данных (посредством +может быть сохранена только часть измененных страниц БД. При этом с большой +вероятностью может оказаться, что будут сохранены мета-страницы со +ссылками на страницы с новыми версиями данных, но не сами новые данные. +В этом случае БД будет безвозвратна разрушена, даже если до аварии +производилась полная синхронизация данных (посредством `mdbx_env_sync()`). В _libmdbx_ эта проблема устранена путем полной переработки @@ -485,194 +488,186 @@ Amplification Factor) и RAF (Read Amplification Factor) также Olog(N). * При открытии БД выполняется автоматический откат к последней сильной фиксации. Этим обеспечивается гарантия сохранности БД. -Такая гарантия надежности не дается бесплатно. Для сохранности данных, -страницы, формирующие крайний снимок с сильной фиксацией, не должны -повторно использоваться (перезаписываться) до формирования следующей -сильной точки фиксации. Таким образом, крайняя точка фиксации создает -описанный выше эффект "долгого чтения". Разница же здесь в том, что при -исчерпании свободных страниц ситуация будет автоматически исправлена, -посредством записи изменений на диск и формирования новой сильной точки -фиксации. +Такая гарантия надежности не дается бесплатно. Для +сохранности данных, страницы, формирующие крайний снимок с +сильной фиксацией, не должны повторно использоваться +(перезаписываться) до формирования следующей сильной точки +фиксации. Таким образом, крайняя точка фиксации создает +описанный выше эффект "долгого чтения". Разница же здесь в том, +что при исчерпании свободных страниц ситуация будет +автоматически исправлена, посредством записи изменений на диск +и формирования новой сильной точки фиксации. Таким образом, в режиме безопасной асинхронной фиксации _libmdbx_ будет -всегда использовать новые страницы до исчерпания места в БД или до -явного формирования сильной точки фиксации посредством -`mdbx_env_sync()`. При этом суммарный трафик записи на диск будет -примерно такой же, как если бы отдельно фиксировалась каждая транзакция. +всегда использовать новые страницы до исчерпания места в БД или до явного +формирования сильной точки фиксации посредством `mdbx_env_sync()`. +При этом суммарный трафик записи на диск будет примерно такой же, +как если бы отдельно фиксировалась каждая транзакция. В текущей версии _libmdbx_ вам предоставляется выбор между безопасным -режимом (по умолчанию) асинхронной фиксации, и режимом `UTTERLY_NOSYNC` -когда при системной аварии есть шанс полного разрушения БД как в LMDB. - -В последующих версиях _libmdbx_ будут предусмотрены средства для -асинхронной записи данных на диск с автоматическим формированием сильных -точек фиксации. - --------------------------------------------------------------------------------- - -Сравнение производительности -============================ - -Все представленные ниже данные получены многократным прогоном тестов на -ноутбуке Lenovo Carbon-2, i7-4600U 2.1 ГГц, 8 Гб ОЗУ, с SSD-диском -SAMSUNG MZNTD512HAGL-000L1 (DXT23L0Q) 512 Гб. +режимом (по умолчанию) асинхронной фиксации, и режимом `UTTERLY_NOSYNC` когда +при системной аварии есть шанс полного разрушения БД как в LMDB. -Исходный код бенчмарка [_IOArena_](https://github.com/pmwkaa/ioarena) и -сценарии тестирования [доступны на -github](https://github.com/pmwkaa/ioarena/tree/HL%2B%2B2015). +В последующих версиях _libmdbx_ будут предусмотрены средства +для асинхронной записи данных на диск с автоматическим +формированием сильных точек фиксации. -------------------------------------------------------------------------------- -### Интегральная производительность - -Показана соотнесенная сумма ключевых показателей производительности в трёх -бенчмарках: +Доработки и усовершенствования относительно LMDB +================================================ - - Чтение/Поиск на машине с 4-мя процессорами; +1. Режим `LIFO RECLAIM`. - - Транзакции с [CRUD](https://ru.wikipedia.org/wiki/CRUD)-операциями - (вставка, чтение, обновление, удаление) в режиме **синхронной фиксации** - данных (fdatasync при завершении каждой транзакции или аналог); + Для повторного использования выбираются не самые старые, а + самые новые страницы из доступных. За счет этого цикл + использования страниц всегда имеет минимальную длину и не + зависит от общего числа выделенных страниц. - - Транзакции с [CRUD](https://ru.wikipedia.org/wiki/CRUD)-операциями - (вставка, чтение, обновление, удаление) в режиме **отложенной фиксации** - данных (отложенная запись посредством файловой систем или аналог); + В результате механизмы кэширования и обратной записи работают с + максимально возможной эффективностью. В случае использования + контроллера дисков или системы хранения с + [BBWC](https://en.wikipedia.org/wiki/BBWC) возможно + многократное увеличение производительности по записи + (обновлению данных). -*Бенчмарк в режиме асинхронной записи не включен по двум причинам:* +2. Обработчик `OOM-KICK`. - 1. Такое сравнение не совсем правомочно, его следует делать с движками - ориентированными на хранение данных в памяти ([Tarantool](https://tarantool.io/), [Redis](https://redis.io/)). + Посредством `mdbx_env_set_oomfunc()` может быть установлен + внешний обработчик (callback), который будет вызван при + исчерпании свободных страниц из-за долгой операцией чтения. + Обработчику будет передан PID и pthread_id виновника. + В свою очередь обработчик может предпринять одно из действий: - 2. Превосходство libmdbx становится еще более подавляющим, что мешает - восприятию информации. + * нейтрализовать виновника (отправить сигнал kill #9), если + долгое чтение выполняется сторонним процессом; - + * отменить или перезапустить проблемную операцию чтения, если + операция выполняется одним из потоков текущего процесса; --------------------------------------------------------------------------------- + * подождать некоторое время, в расчете на то, что проблемная операция + чтения будет штатно завершена; -### Масштабируемость чтения + * прервать текущую операцию изменения данных с возвратом кода + ошибки. -Для каждого движка показана суммарная производительность при -одновременном выполнении запросов чтения/поиска в 1-2-4-8 потоков на -машине с 4-мя физическими процессорами. - - - --------------------------------------------------------------------------------- - -### Синхронная фиксация - - - Линейная шкала слева и темные прямоугольники соответствуют количеству - транзакций в секунду, усредненному за всё время теста. - - - Логарифмическая шкала справа и желтые интервальные отрезки - соответствуют времени выполнения транзакций. При этом каждый отрезок - показывает минимальное и максимальное время, затраченное на выполнение - транзакций, а крестиком отмечено среднеквадратичное значение. +3. Гарантия сохранности БД в режиме `WRITEMAP+MAPSYNC`. + > В текущей версии _libmdbx_ вам предоставляется выбор между безопасным + > режимом (по умолчанию) асинхронной фиксации, и режимом `UTTERLY_NOSYNC` + > когда при системной аварии есть шанс полного разрушения БД как в LMDB. + > Для подробностей смотрите раздел + > [Сохранность данных в режиме асинхронной фиксации](#Сохранность-данных-в-режиме-асинхронной-фиксации). -Выполняется **10.000 транзакций в режиме синхронной фиксации данных** на -диске. При этом требуется гарантия, что при аварийном выключении питания -(или другом подобном сбое) все данные будут консистентны и полностью -соответствовать последней завершенной транзакции. В _libmdbx_ в этом -режиме при фиксации каждой транзакции выполняется системный вызов -[fdatasync](https://linux.die.net/man/2/fdatasync). +4. Возможность автоматического формирования контрольных точек +(сброса данных на диск) при накоплении заданного объёма изменений, +устанавливаемого функцией `mdbx_env_set_syncbytes()`. -В каждой транзакции выполняется комбинированная CRUD-операция (две -вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует -на пустой базе, а при завершении, в результате выполняемых действий, в -базе насчитывается 10.000 небольших key-value записей. +5. Возможность получить отставание текущей транзакции чтения от +последней версии данных в БД посредством `mdbx_txn_straggler()`. - +6. Утилита mdbx_chk для проверки БД и функция `mdbx_env_pgwalk()` для +обхода всех страниц БД. --------------------------------------------------------------------------------- +7. Управление отладкой и получение отладочных сообщений посредством +`mdbx_setup_debug()`. -### Отложенная фиксация +8. Возможность связать с каждой завершаемой транзакцией до 3 +дополнительных маркеров посредством `mdbx_canary_put()`, и прочитать их +в транзакции чтения посредством `mdbx_canary_get()`. - - Линейная шкала слева и темные прямоугольники соответствуют количеству - транзакций в секунду, усредненному за всё время теста. +9. Возможность узнать есть ли за текущей позицией курсора строка данных +посредством `mdbx_cursor_eof()`. - - Логарифмическая шкала справа и желтые интервальные отрезки - соответствуют времени выполнения транзакций. При этом каждый отрезок - показывает минимальное и максимальное время, затраченное на выполнение - транзакций, а крестиком отмечено среднеквадратичное значение. +10. Возможность явно запросить обновление существующей записи, без +создания новой посредством флажка `MDBX_CURRENT` для `mdbx_put()`. -Выполняется **100.000 транзакций в режиме отложенной фиксации данных** -на диске. При этом требуется гарантия, что при аварийном выключении -питания (или другом подобном сбое) все данные будут консистентны на -момент завершения одной из транзакций, но допускается потеря изменений -из некоторого количества последних транзакций, что для многих движков -предполагает включение -[WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) (write-ahead -logging) либо журнала транзакций, который в свою очередь опирается на -гарантию упорядоченности данных в журналируемой файловой системе. -_libmdbx_ при этом не ведет WAL, а передает весь контроль файловой -системе и ядру ОС. +11. Возможность посредством `mdbx_replace()` обновить или удалить запись +с получением предыдущего значения данных, а также адресно изменить +конкретное multi-значение. -В каждой транзакции выполняется комбинированная CRUD-операция (две -вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует -на пустой базе, а при завершении, в результате выполняемых действий, в -базе насчитывается 100.000 небольших key-value записей. +12. Поддержка ключей и значений нулевой длины, включая сортированные +дубликаты. - +13. Исправленный вариант `mdbx_cursor_count()`, возвращающий корректное +количество дубликатов для всех типов таблиц и любого положения курсора. --------------------------------------------------------------------------------- +14. Возможность открыть БД в эксклюзивном режиме посредством флага +`MDBX_EXCLUSIVE`, например в целях её проверки. -### Асинхронная фиксация +15. Возможность закрыть БД в "грязном" состоянии (без сброса данных и +формирования сильной точки фиксации) посредством `mdbx_env_close_ex()`. - - Линейная шкала слева и темные прямоугольники соответствуют количеству - транзакций в секунду, усредненному за всё время теста. +16. Возможность получить посредством `mdbx_env_info()` дополнительную +информацию, включая номер самой старой версии БД (снимка данных), +который используется одним из читателей. - - Логарифмическая шкала справа и желтые интервальные отрезки - соответствуют времени выполнения транзакций. При этом каждый отрезок - показывает минимальное и максимальное время, затраченное на выполнение - транзакций, а крестиком отмечено среднеквадратичное значение. +17. Функция `mdbx_del()` не игнорирует дополнительный (уточняющий) +аргумент `data` для таблиц без дубликатов (без флажка `MDBX_DUPSORT`), а +при его ненулевом значении всегда использует его для сверки с удаляемой +записью. -Выполняется **1.000.000 транзакций в режиме асинхронной фиксации -данных** на диске. При этом требуется гарантия, что при аварийном -выключении питания (или другом подобном сбое) все данные будут -консистентны на момент завершения одной из транзакций, но допускается -потеря изменений из значительного количества последних транзакций. Во -всех движках при этом включался режим предполагающий минимальную -нагрузку на диск по записи, и соответственно минимальную гарантию -сохранности данных. В _libmdbx_ при этом используется режим асинхронной -записи измененных страниц на диск посредством ядра ОС и системного -вызова [msync(MS_ASYNC)](https://linux.die.net/man/2/msync). +18. Возможность открыть dbi-таблицу, одновременно с установкой +компараторов для ключей и данных, посредством `mdbx_dbi_open_ex()`. -В каждой транзакции выполняется комбинированная CRUD-операция (две -вставки, одно чтение, одно обновление, одно удаление). Бенчмарк стартует -на пустой базе, а при завершении, в результате выполняемых действий, в -базе насчитывается 10.000 небольших key-value записей. +19. Возможность посредством `mdbx_is_dirty()` определить находятся ли +некоторый ключ или данные в "грязной" странице БД. Таким образом, +избегая лишнего копирования данных перед выполнением модифицирующих +операций (значения, размещенные в "грязных" страницах, могут быть +перезаписаны при изменениях, иначе они будут неизменны). - +20. Корректное обновление текущей записи, в том числе сортированного +дубликата, при использовании режима `MDBX_CURRENT` в +`mdbx_cursor_put()`. --------------------------------------------------------------------------------- +21. Все курсоры, как в транзакциях только для чтения, так и в пишущих, +могут быть переиспользованы посредством `mdbx_cursor_renew()` и ДОЛЖНЫ +ОСВОБОЖДАТЬСЯ ЯВНО. + > + > ## _ВАЖНО_, Обратите внимание! + > + > Это единственное изменение в API, которое значимо меняет + > семантику управления курсорами и может приводить к утечкам + > памяти. Следует отметить, что это изменение вынужденно. + > Так устраняется неоднозначность с массой тяжких последствий: + > + > - обращение к уже освобожденной памяти; + > - попытки повторного освобождения памяти; + > - повреждение памяти и ошибки сегментации. -### Потребление ресурсов +22. Дополнительный код ошибки `MDBX_EMULTIVAL`, который возвращается из +`mdbx_put()` и `mdbx_replace()` при попытке выполнить неоднозначное +обновление или удаления одного из нескольких значений с одним ключом. -Показана соотнесенная сумма использованных ресурсов в ходе бенчмарка в -режиме отложенной фиксации: +23. Возможность посредством `mdbx_get_ex()` получить значение по +заданному ключу, одновременно с количеством дубликатов. - - суммарное количество операций ввода-вывода (IOPS), как записи, так и - чтения. +24. Наличие функций `mdbx_cursor_on_first()` и `mdbx_cursor_on_last()`, +которые позволяют быстро выяснить стоит ли курсор на первой/последней +позиции. - - суммарное затраченное время процессора, как в режиме пользовательских - процессов, так и в режиме ядра ОС. +25. При завершении читающих транзакций, открытые в них DBI-хендлы не +закрываются и не теряются при завершении таких транзакций посредством +`mdbx_txn_abort()` или `mdbx_txn_reset()`. Что позволяет избавится от ряда +сложно обнаруживаемых ошибок. - - использованное место на диске при завершении теста, после закрытия БД - из тестирующего процесса, но без ожидания всех внутренних операций - обслуживания (компактификации LSM и т.п.). +26. Генерация последовательностей посредством `mdbx_dbi_sequence()`. -Движок _ForestDB_ был исключен при оформлении результатов, так как -относительно конкурентов многократно превысил потребление каждого из -ресурсов (потратил процессорное время на генерацию IOPS для заполнения -диска), что не позволяло наглядно сравнить показатели остальных движков -на одной диаграмме. +27. Расширенное динамическое управление размером БД, включая выбор +размера страницы посредством `mdbx_env_set_geometry()`, +в том числе в **Windows** -Все данные собирались посредством системного вызова -[getrusage()](http://man7.org/linux/man-pages/man2/getrusage.2.html) и -сканированием директорий с данными. +28. Три мета-страницы вместо двух, что позволяет гарантированно +консистентно обновлять слабые контрольные точки фиксации без риска +повредить крайнюю сильную точку фиксации. - +29. В _libmdbx_ реализован автоматический возврат освобождающихся +страниц в область нераспределенного резерва в конце файла данных. При +этом уменьшается количество страниц загруженных в память и участвующих в +цикле обновления данных и записи на диск. Фактически _libmdbx_ выполняет +постоянную компактификацию данных, но не затрачивая на это +дополнительных ресурсов, а только освобождая их. При освобождении места +в БД и установке соответствующих параметров геометрии базы данных, также будет +уменьшаться размер файла на диске, в том числе в **Windows**. -------------------------------------------------------------------------------- @@ -690,3 +685,16 @@ Idx Name Size VMA LMA File off Algn CONTENTS, ALLOC, LOAD, READONLY, CODE ``` + +``` +$ gcc -v +Using built-in specs. +COLLECT_GCC=gcc +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/7/lto-wrapper +OFFLOAD_TARGET_NAMES=nvptx-none +OFFLOAD_TARGET_DEFAULT=1 +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 7.2.0-8ubuntu3' --with-bugurl=file:///usr/share/doc/gcc-7/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-7 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 7.2.0 (Ubuntu 7.2.0-8ubuntu3) +``` diff --git a/libs/libmdbx/src/README.md b/libs/libmdbx/src/README.md index 7c07de316e..92b6542fa7 100644 --- a/libs/libmdbx/src/README.md +++ b/libs/libmdbx/src/README.md @@ -9,21 +9,9 @@ libmdbx ## Project Status for now - - The stable versions - ([_stable/0.0_](https://github.com/leo-yuriev/libmdbx/tree/stable/0.0) - and - [_stable/0.1_](https://github.com/leo-yuriev/libmdbx/tree/stable/0.1) - branches) of _MDBX_ are frozen, i.e. no new features or API changes, but - only bug fixes. - - - The next version - ([_devel_](https://github.com/leo-yuriev/libmdbx/tree/devel) branch) - **is under active non-public development**, i.e. current API and set of - features are extreme volatile. - - - The immediate goal of development is formation of the stable API and - the stable internal database format, which allows realise all PLANNED - FEATURES: + - The stable versions ([_stable/0.0_](https://github.com/leo-yuriev/libmdbx/tree/stable/0.0) and [_stable/0.1_](https://github.com/leo-yuriev/libmdbx/tree/stable/0.1) branches) of _MDBX_ are frozen, i.e. no new features or API changes, but only bug fixes. + - The next version ([_devel_](https://github.com/leo-yuriev/libmdbx/tree/devel) branch) **is under active non-public development**, i.e. current API and set of features are extreme volatile. + - The immediate goal of development is formation of the stable API and the stable internal database format, which allows realise all PLANNED FEATURES: 1. Integrity check by [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree); 2. Support for [raw block devices](https://en.wikipedia.org/wiki/Raw_device); 3. Separate place (HDD) for large data items; @@ -36,21 +24,19 @@ Don't miss [Java Native Interface](https://github.com/castortech/mdbxjni) by [Ca ----- -Nowadays MDBX intended for Linux, and support Windows (since Windows -Server 2008) as a complementary platform. Support for other OS could be -implemented on commercial basis. However such enhancements (i.e. pull -requests) could be accepted in mainstream only when corresponding public -and free Continuous Integration service will be available. +Nowadays MDBX intended for Linux, and support Windows (since +Windows Server 2008) as a complementary platform. Support for +other OS could be implemented on commercial basis. However such +enhancements (i.e. pull requests) could be accepted in +mainstream only when corresponding public and free Continuous +Integration service will be available. ## Contents + - [Overview](#overview) - [Comparison with other DBs](#comparison-with-other-dbs) - [History & Acknowledgments](#history) - [Main features](#main-features) -- [Improvements over LMDB](#improvements-over-lmdb) -- [Gotchas](#gotchas) - - [Long-time read transactions problem](#long-time-read-transactions-problem) - - [Data safety in async-write-mode](#data-safety-in-async-write-mode) - [Performance comparison](#performance-comparison) - [Integral performance](#integral-performance) - [Read scalability](#read-scalability) @@ -58,58 +44,52 @@ and free Continuous Integration service will be available. - [Lazy-write mode](#lazy-write-mode) - [Async-write mode](#async-write-mode) - [Cost comparison](#cost-comparison) +- [Gotchas](#gotchas) + - [Long-time read transactions problem](#long-time-read-transactions-problem) + - [Data safety in async-write-mode](#data-safety-in-async-write-mode) +- [Improvements over LMDB](#improvements-over-lmdb) ## Overview -_libmdbx_ is an embedded lightweight key-value database engine oriented -for performance under Linux and Windows. -_libmdbx_ allows multiple processes to read and update several key-value -tables concurrently, while being -[ACID](https://en.wikipedia.org/wiki/ACID)-compliant, with minimal -overhead and operation cost of Olog(N). +_libmdbx_ is an embedded lightweight key-value database engine oriented for performance under Linux and Windows. + +_libmdbx_ allows multiple processes to read and update several key-value tables concurrently, +while being [ACID](https://en.wikipedia.org/wiki/ACID)-compliant, with minimal overhead and operation cost of Olog(N). _libmdbx_ provides -[serializability](https://en.wikipedia.org/wiki/Serializability) and -consistency of data after crash. Read-write transactions don't block -read-only transactions and are -[serialized](https://en.wikipedia.org/wiki/Serializability) by -[mutex](https://en.wikipedia.org/wiki/Mutual_exclusion). - -_libmdbx_ -[wait-free](https://en.wikipedia.org/wiki/Non-blocking_algorithm#Wait-freedom) -provides parallel read transactions without atomic operations or -synchronization primitives. - -_libmdbx_ uses [B+Trees](https://en.wikipedia.org/wiki/B%2B_tree) and -[mmap](https://en.wikipedia.org/wiki/Memory-mapped_file), doesn't use -[WAL](https://en.wikipedia.org/wiki/Write-ahead_logging). This might -have caveats for some workloads. +[serializability](https://en.wikipedia.org/wiki/Serializability) and consistency of data after crash. +Read-write transactions don't block read-only transactions and are +[serialized](https://en.wikipedia.org/wiki/Serializability) by [mutex](https://en.wikipedia.org/wiki/Mutual_exclusion). + +_libmdbx_ [wait-free](https://en.wikipedia.org/wiki/Non-blocking_algorithm#Wait-freedom) provides parallel read transactions +without atomic operations or synchronization primitives. + +_libmdbx_ uses [B+Trees](https://en.wikipedia.org/wiki/B%2B_tree) and [mmap](https://en.wikipedia.org/wiki/Memory-mapped_file), +doesn't use [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging). This might have caveats for some workloads. ### Comparison with other DBs -Because _libmdbx_ is currently overhauled, I think it's better to just -link [chapter of Comparison with other -databases](https://github.com/coreos/bbolt#comparison-with-other-databases) -here. + +Because _libmdbx_ is currently overhauled, I think it's better to just link +[chapter of Comparison with other databases](https://github.com/coreos/bbolt#comparison-with-other-databases) here. ### History -The _libmdbx_ design is based on [Lightning Memory-Mapped -Database](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database). -Initial development was going in -[ReOpenLDAP](https://github.com/leo-yuriev/ReOpenLDAP) project, about a -year later it received separate development effort and in autumn 2015 -was isolated to separate project, which was [presented at Highload++ -2015 conference](http://www.highload.ru/2015/abstracts/1831.html). - -Since early 2017 _libmdbx_ is used in [Fast PositiveTables](https://github.com/leo-yuriev/libfpta), + +The _libmdbx_ design is based on [Lightning Memory-Mapped Database](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database). +Initial development was going in [ReOpenLDAP](https://github.com/leo-yuriev/ReOpenLDAP) project, about a year later it +received separate development effort and in autumn 2015 was isolated to separate project, which was +[presented at Highload++ 2015 conference](http://www.highload.ru/2015/abstracts/1831.html). + +Since early 2017 _libmdbx_ is used in [Fast Positive Tables](https://github.com/leo-yuriev/libfpta), by [Positive Technologies](https://www.ptsecurity.com). #### Acknowledgments -Howard Chu (Symas Corporation) - the author of LMDB, from which -originated the MDBX in 2015. -Martin Hedenfalk <martin@bzero.se> - the author of `btree.c` code, which -was used for begin development of LMDB. +Howard Chu (Symas Corporation) - the author of LMDB, +from which originated the MDBX in 2015. + +Martin Hedenfalk <martin@bzero.se> - the author of `btree.c` code, +which was used for begin development of LMDB. Main features @@ -118,468 +98,365 @@ Main features _libmdbx_ inherits all keys features and characteristics from [LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database): -1. Data is stored in ordered map, keys are always sorted, range lookups -are supported. - -2. Data is [mmaped](https://en.wikipedia.org/wiki/Memory-mapped_file) to -memory of each worker DB process, read transactions are zero-copy. - -3. Transactions are -[ACID](https://en.wikipedia.org/wiki/ACID)-compliant, thanks to -[MVCC](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) -and [CoW](https://en.wikipedia.org/wiki/Copy-on-write). Writes are -strongly serialized and aren't blocked by reads, transactions can't -conflict with each other. Reads are guaranteed to get only commited data -([relaxing serializability](https://en.wikipedia.org/wiki/Serializability#Relaxing_serializability)). - -4. Reads and queries are -[non-blocking](https://en.wikipedia.org/wiki/Non-blocking_algorithm), -don't use [atomic -operations](https://en.wikipedia.org/wiki/Linearizability#High-level_atomic_operations). -Readers don't block each other and aren't blocked by writers. Read -performance scales linearly with CPU core count. - > Though "connect to DB" (start of first read transaction in thread) and - > "disconnect from DB" (shutdown or thread termination) requires to - > acquire a lock to register/unregister current thread from "readers - > table" - -5. Keys with multiple values are stored efficiently without key -duplication, sorted by value, including integers (reasonable for -secondary indexes). - -6. Efficient operation on short fixed length keys, including integer -ones. - -7. [WAF](https://en.wikipedia.org/wiki/Write_amplification) (Write -Amplification Factor) и RAF (Read Amplification Factor) are Olog(N). - -8. No [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) and -transaction journal. In case of a crash no recovery needed. No need for -regular maintenance. Backups can be made on the fly on working DB - without freezing writers. +1. Data is stored in ordered map, keys are always sorted, range lookups are supported. + +2. Data is [mmaped](https://en.wikipedia.org/wiki/Memory-mapped_file) to memory of each worker DB process, read transactions are zero-copy. + +3. Transactions are [ACID](https://en.wikipedia.org/wiki/ACID)-compliant, thanks to + [MVCC](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) and [CoW](https://en.wikipedia.org/wiki/Copy-on-write). + Writes are strongly serialized and aren't blocked by reads, transactions can't conflict with each other. + Reads are guaranteed to get only commited data + ([relaxing serializability](https://en.wikipedia.org/wiki/Serializability#Relaxing_serializability)). + +4. Reads and queries are [non-blocking](https://en.wikipedia.org/wiki/Non-blocking_algorithm), + don't use [atomic operations](https://en.wikipedia.org/wiki/Linearizability#High-level_atomic_operations). + Readers don't block each other and aren't blocked by writers. Read performance scales linearly with CPU core count. + > Though "connect to DB" (start of first read transaction in thread) and "disconnect from DB" (shutdown or thread + > termination) requires to acquire a lock to register/unregister current thread from "readers table" + +5. Keys with multiple values are stored efficiently without key duplication, sorted by value, including integers + (reasonable for secondary indexes). + +6. Efficient operation on short fixed length keys, including integer ones. + +7. [WAF](https://en.wikipedia.org/wiki/Write_amplification) (Write Amplification Factor) и RAF (Read Amplification Factor) + are Olog(N). + +8. No [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) and transaction journal. + In case of a crash no recovery needed. No need for regular maintenance. Backups can be made on the fly on working DB + without freezing writers. 9. No custom memory management, all done with standard OS syscalls. --------------------------------------------------------------------------------- -Improvements over LMDB -====================== +Performance comparison +===================== -1. `mdbx_chk` tool for DB integrity check. +All benchmarks were done by [IOArena](https://github.com/pmwkaa/ioarena) +and multiple [scripts](https://github.com/pmwkaa/ioarena/tree/HL%2B%2B2015) +runs on Lenovo Carbon-2 laptop, i7-4600U 2.1 GHz, 8 Gb RAM, +SSD SAMSUNG MZNTD512HAGL-000L1 (DXT23L0Q) 512 Gb. -2. Automatic dynamic DB size management according to the parameters -specified by `mdbx_env_set_geometry()` function. Including including -growth step and truncation threshold, as well as the choice of page -size. +-------------------------------------------------------------------------------- -3. Automatic returning of freed pages into unallocated space at the end -of database file with optionally automatic shrinking it. This reduces -amount of pages resides in RAM and circulated in disk I/O. In fact -_libmdbx_ constantly performs DB compactification, without spending -additional resources for that. +### Integral performance -4. Support for keys and values of zero length, including sorted -duplicates. +Here showed sum of performance metrics in 3 benchmarks: -5. Ability to assign up to 3 markers to commiting transaction with -`mdbx_canary_put()` and then get them in read transaction by -`mdbx_canary_get()`. + - Read/Search on 4 CPU cores machine; -6. Ability to update or delete record and get previous value via -`mdbx_replace()` Also can update specific multi-value. + - Transactions with [CRUD](https://en.wikipedia.org/wiki/CRUD) operations + in sync-write mode (fdatasync is called after each transaction); -7. `LIFO RECLAIM` mode: + - Transactions with [CRUD](https://en.wikipedia.org/wiki/CRUD) operations + in lazy-write mode (moment to sync data to persistent storage is decided by OS). - The newest pages are picked for reuse instead of the oldest. This allows - to minimize reclaim loop and make it execution time independent of total - page count. +*Reasons why asynchronous mode isn't benchmarked here:* - This results in OS kernel cache mechanisms working with maximum - efficiency. In case of using disk controllers or storages with - [BBWC](https://en.wikipedia.org/wiki/Disk_buffer#Write_acceleration) - this may greatly improve write performance. + 1. It doesn't make sense as it has to be done with DB engines, oriented for keeping data in memory e.g. + [Tarantool](https://tarantool.io/), [Redis](https://redis.io/)), etc. -8. Sequence generation via `mdbx_dbi_sequence()`. + 2. Performance gap is too high to compare in any meaningful way. -9. `OOM-KICK` callback. + - `mdbx_env_set_oomfunc()` allows to set a callback, which will be called - in the event of DB space exhausting during long-time read transaction in - parallel with extensive updating. Callback will be invoked with PID and - pthread_id of offending thread as parameters. Callback can do any of - these things to remedy the problem: +-------------------------------------------------------------------------------- - * wait for read transaction to finish normally; +### Read Scalability - * kill the offending process (signal 9), if separate process is doing - long-time read; +Summary performance with concurrent read/search queries in 1-2-4-8 threads on 4 CPU cores machine. - * abort or restart offending read transaction if it's running in sibling - thread; + - * abort current write transaction with returning error code. +-------------------------------------------------------------------------------- -10. Ability to open DB in exclusive mode with `MDBX_EXCLUSIVE` flag. +### Sync-write mode -11. Ability to get how far current read-only snapshot is from latest -version of the DB by `mdbx_txn_straggler()`. + - Linear scale on left and dark rectangles mean arithmetic mean transactions per second; -12. Ability to explicitly request update of present record without -creating new record. Implemented as `MDBX_CURRENT` flag for -`mdbx_put()`. + - Logarithmic scale on right is in seconds and yellow intervals mean execution time of transactions. + Each interval shows minimal and maximum execution time, cross marks standard deviation. -13. Fixed `mdbx_cursor_count()`, which returns correct count of -duplicated for all table types and any cursor position. +**10,000 transactions in sync-write mode**. In case of a crash all data is consistent and state is right after last successful transaction. [fdatasync](https://linux.die.net/man/2/fdatasync) syscall is used after each write transaction in this mode. -14. `mdbx_env_info()` to getting additional info, including number of -the oldest snapshot of DB, which is used by one of the readers. +In the benchmark each transaction contains combined CRUD operations (2 inserts, 1 read, 1 update, 1 delete). +Benchmark starts on empty database and after full run the database contains 10,000 small key-value records. -15. `mdbx_del()` doesn't ignore additional argument (specifier) `data` -for tables without duplicates (without flag `MDBX_DUPSORT`), if `data` -is not null then always uses it to verify record, which is being -deleted. + -16. Ability to open dbi-table with simultaneous setup of comparators for -keys and values, via `mdbx_dbi_open_ex()`. +-------------------------------------------------------------------------------- -17. `mdbx_is_dirty()`to find out if key or value is on dirty page, that -useful to avoid copy-out before updates. +### Lazy-write mode -18. Correct update of current record in `MDBX_CURRENT` mode of -`mdbx_cursor_put()`, including sorted duplicated. + - Linear scale on left and dark rectangles mean arithmetic mean of thousands transactions per second; -19. Check if there is a row with data after current cursor position via -`mdbx_cursor_eof()`. + - Logarithmic scale on right in seconds and yellow intervals mean execution time of transactions. Each interval shows minimal and maximum execution time, cross marks standard deviation. -20. Additional error code `MDBX_EMULTIVAL`, which is returned by -`mdbx_put()` and `mdbx_replace()` in case is ambiguous update or delete. +**100,000 transactions in lazy-write mode**. +In case of a crash all data is consistent and state is right after one of last transactions, but transactions after it +will be lost. Other DB engines use [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) or transaction journal for that, +which in turn depends on order of operations in journaled filesystem. _libmdbx_ doesn't use WAL and hands I/O operations +to filesystem and OS kernel (mmap). -21. Ability to get value by key and duplicates count by `mdbx_get_ex()`. +In the benchmark each transaction contains combined CRUD operations (2 inserts, 1 read, 1 update, 1 delete). +Benchmark starts on empty database and after full run the database contains 100,000 small key-value records. -22. Functions `mdbx_cursor_on_first()` and `mdbx_cursor_on_last()`, -which allows to know if cursor is currently on first or last position -respectively. -23. Automatic creation of synchronization points (flush changes to -persistent storage) when changes reach set threshold (threshold can be -set by `mdbx_env_set_syncbytes()`). + -24. Control over debugging and receiving of debugging messages via -`mdbx_setup_debug()`. +-------------------------------------------------------------------------------- -25. Function `mdbx_env_pgwalk()` for page-walking all pages in DB. +### Async-write mode -26. Three meta-pages instead of two, this allows to guarantee -consistently update weak sync-points without risking to corrupt last -steady sync-point. + - Linear scale on left and dark rectangles mean arithmetic mean of thousands transactions per second; -27. Guarantee of DB integrity in `WRITEMAP+MAPSYNC` mode: - > Current _libmdbx_ gives a choice of safe async-write mode (default) - > and `UTTERLY_NOSYNC` mode which may result in full - > DB corruption during system crash as with LMDB. For details see - > [Data safety in async-write mode](#data-safety-in-async-write-mode). + - Logarithmic scale on right in seconds and yellow intervals mean execution time of transactions. Each interval shows minimal and maximum execution time, cross marks standard deviation. -28. Ability to close DB in "dirty" state (without data flush and -creation of steady synchronization point) via `mdbx_env_close_ex()`. +**1,000,000 transactions in async-write mode**. In case of a crash all data will be consistent and state will be right after one of last transactions, but lost transaction count is much higher than in lazy-write mode. All DB engines in this mode do as little writes as possible on persistent storage. _libmdbx_ uses [msync(MS_ASYNC)](https://linux.die.net/man/2/msync) in this mode. -29. If read transaction is aborted via `mdbx_txn_abort()` or -`mdbx_txn_reset()` then DBI-handles, which were opened in it, aren't -closed or deleted. This allows to avoid several types of hard-to-debug -errors. +In the benchmark each transaction contains combined CRUD operations (2 inserts, 1 read, 1 update, 1 delete). +Benchmark starts on empty database and after full run the database contains 10,000 small key-value records. -30. All cursors in all read and write transactions can be reused by -`mdbx_cursor_renew()` and MUST be freed explicitly. - > ## Caution, please pay attention! - > - > This is the only change of API, which changes semantics of cursor management - > and can lead to memory leaks on misuse. This is a needed change as it eliminates ambiguity - > which helps to avoid such errors as: - > - use-after-free; - > - double-free; - > - memory corruption and segfaults. + -------------------------------------------------------------------------------- -## Gotchas +### Cost comparison -1. At one moment there can be only one writer. But this allows to -serialize writes and eliminate any possibility of conflict or logical -errors during transaction rollback. - -2. No [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) means -relatively big [WAF](https://en.wikipedia.org/wiki/Write_amplification) -(Write Amplification Factor). Because of this syncing data to disk might -be quite resource intensive and be main performance bottleneck during -intensive write workload. - > As compromise _libmdbx_ allows several modes of lazy and/or periodic - > syncing, including `MAPASYNC` mode, which modificate data in memory and - > asynchronously syncs data to disk, moment to sync is picked by OS. - > - > Although this should be used with care, synchronous transactions in a DB - > with transaction journal will require 2 IOPS minimum (probably 3-4 in - > practice) because of filesystem overhead, overhead depends on - > filesystem, not on record count or record size. In _libmdbx_ IOPS count - > will grow logarithmically depending on record count in DB (height of B+ - > tree) and will require at least 2 IOPS per transaction too. - -3. [CoW](https://en.wikipedia.org/wiki/Copy-on-write) for -[MVCC](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) -is done on memory page level with -[B+trees](https://ru.wikipedia.org/wiki/B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE). -Therefore altering data requires to copy about Olog(N) memory pages, -which uses [memory bandwidth](https://en.wikipedia.org/wiki/Memory_bandwidth) and is main -performance bottleneck in `MAPASYNC` mode. - > This is unavoidable, but isn't that bad. Syncing data to disk requires - > much more similar operations which will be done by OS, therefore this is - > noticeable only if data sync to persistent storage is fully disabled. - > _libmdbx_ allows to safely save data to persistent storage with minimal - > performance overhead. If there is no need to save data to persistent - > storage then it's much more preferable to use `std::map`. - - -4. LMDB has a problem of long-time readers which degrades performance -and bloats DB. - > _libmdbx_ addresses that, details below. +Summary of used resources during lazy-write mode benchmarks: -5. _LMDB_ is susceptible to DB corruption in `WRITEMAP+MAPASYNC` mode. -_libmdbx_ in `WRITEMAP+MAPASYNC` guarantees DB integrity and consistency -of data. - > Additionally there is an alternative: `UTTERLY_NOSYNC` mode. - > Details below. + - Read and write IOPS; + - Sum of user CPU time and sys CPU time; -#### Long-time read transactions problem -Garbage collection problem exists in all databases one way or another -(e.g. VACUUM in PostgreSQL). But in _libmdbx_ and LMDB it's even more -important because of high performance and deliberate simplification of -internals with emphasis on performance. + - Used space on persistent storage after the test and closed DB, but not waiting for the end of all internal + housekeeping operations (LSM compactification, etc). -* Altering data during long read operation may exhaust available space -on persistent storage. +_ForestDB_ is excluded because benchmark showed it's resource consumption for each resource (CPU, IOPS) much higher than other engines which prevents to meaningfully compare it with them. -* If available space is exhausted then any attempt to update data -results in `MAP_FULL` error until long read operation ends. +All benchmark data is gathered by [getrusage()](http://man7.org/linux/man-pages/man2/getrusage.2.html) syscall and by +scanning data directory. -* Main examples of long readers is hot backup and debugging of client -application which actively uses read transactions. + -* In _LMDB_ this results in degraded performance of all operations of -syncing data to persistent storage. +-------------------------------------------------------------------------------- -* _libmdbx_ has a mechanism which aborts such operations and `LIFO RECLAIM` -mode which addresses performance degradation. - -Read operations operate only over snapshot of DB which is consistent on -the moment when read transaction started. This snapshot doesn't change -throughout the transaction but this leads to inability to reclaim the -pages until read transaction ends. - -In _LMDB_ this leads to a problem that memory pages, allocated for -operations during long read, will be used for operations and won't be -reclaimed until DB process terminates. In _LMDB_ they are used in -[FIFO](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics)) -manner, which causes increased page count and less chance of cache hit -during I/O. In other words: one long-time reader can impact performance -of all database until it'll be reopened. - -_libmdbx_ addresses the problem, details below. Illustrations to this -problem can be found in the -[presentation](http://www.slideshare.net/leoyuriev/lmdb). There is also -example of performance increase thanks to -[BBWC](https://en.wikipedia.org/wiki/Disk_buffer#Write_acceleration) -when `LIFO RECLAIM` enabled in _libmdbx_. +## Gotchas -#### Data safety in async-write mode -In `WRITEMAP+MAPSYNC` mode dirty pages are written to persistent storage -by kernel. This means that in case of application crash OS kernel will -write all dirty data to disk and nothing will be lost. But in case of -hardware malfunction or OS kernel fatal error only some dirty data might -be synced to disk, and there is high probability that pages with -metadata saved, will point to non-saved, hence non-existent, data pages. -In such situation, DB is completely corrupted and can't be repaired even -if there was full sync before the crash via `mdbx_env_sync(). +1. At one moment there can be only one writer. But this allows to serialize writes and eliminate any possibility + of conflict or logical errors during transaction rollback. + +2. No [WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) means relatively + big [WAF](https://en.wikipedia.org/wiki/Write_amplification) (Write Amplification Factor). + Because of this syncing data to disk might be quite resource intensive and be main performance bottleneck + during intensive write workload. + > As compromise _libmdbx_ allows several modes of lazy and/or periodic syncing, including `MAPASYNC` mode, which modificate + > data in memory and asynchronously syncs data to disk, moment to sync is picked by OS. + > + > Although this should be used with care, synchronous transactions in a DB with transaction journal will require 2 IOPS + > minimum (probably 3-4 in practice) because of filesystem overhead, overhead depends on filesystem, not on record + > count or record size. In _libmdbx_ IOPS count will grow logarithmically depending on record count in DB (height of B+ tree) + > and will require at least 2 IOPS per transaction too. + +3. [CoW](https://en.wikipedia.org/wiki/Copy-on-write) + for [MVCC](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) is done on memory page level with [B+ + trees](https://ru.wikipedia.org/wiki/B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE). + Therefore altering data requires to copy about Olog(N) memory pages, which uses [memory bandwidth](https://en.wikipedia.org/wiki/Memory_bandwidth) and is main performance bottleneck in `MAPASYNC` mode. + > This is unavoidable, but isn't that bad. Syncing data to disk requires much more similar operations which will + > be done by OS, therefore this is noticeable only if data sync to persistent storage is fully disabled. + > _libmdbx_ allows to safely save data to persistent storage with minimal performance overhead. If there is no need + > to save data to persistent storage then it's much more preferable to use `std::map`. + + +4. LMDB has a problem of long-time readers which degrades performance and bloats DB + > _libmdbx_ addresses that, details below. -_libmdbx_ addresses this by fully reimplementing write path of data: +5. _LMDB_ is susceptible to DB corruption in `WRITEMAP+MAPASYNC` mode. + _libmdbx_ in `WRITEMAP+MAPASYNC` guarantees DB integrity and consistency of data. + > Additionally there is an alternative: `UTTERLY_NOSYNC` mode. Details below. -* In `WRITEMAP+MAPSYNC` mode meta-data pages aren't updated in place, -instead their shadow copies are used and their updates are synced after -data is flushed to disk. -* During transaction commit _libmdbx_ marks synchronization points as -steady or weak depending on how much synchronization needed between RAM -and persistent storage, e.g. in `WRITEMAP+MAPSYNC` commited transactions -are marked as weak, but during explicit data synchronization - as -steady. +#### Long-time read transactions problem -* _libmdbx_ maintains three separate meta-pages instead of two. This -allows to commit transaction with steady or weak synchronization point -without losing two previous synchronization points (one of them can be -steady, and second - weak). This allows to order weak and steady -synchronization points in any order without losing consistency in case -of system crash. +Garbage collection problem exists in all databases one way or another (e.g. VACUUM in PostgreSQL). +But in _libmdbx_ and LMDB it's even more important because of high performance and deliberate +simplification of internals with emphasis on performance. -* During DB open _libmdbx_ rollbacks to the last steady synchronization -point, this guarantees database integrity. +* Altering data during long read operation may exhaust available space on persistent storage. -For data safety pages which form database snapshot with steady -synchronization point must not be updated until next steady -synchronization point. So last steady synchronization point creates -"long-time read" effect. The only difference that in case of memory -exhaustion the problem will be immediately addressed by flushing changes -to persistent storage and forming new steady synchronization point. +* If available space is exhausted then any attempt to update data + results in `MAP_FULL` error until long read operation ends. -So in async-write mode _libmdbx_ will always use new pages until memory -is exhausted or `mdbx_env_sync()` is invoked. Total disk usage will be -almost the same as in sync-write mode. +* Main examples of long readers is hot backup + and debugging of client application which actively uses read transactions. -Current _libmdbx_ gives a choice of safe async-write mode (default) and -`UTTERLY_NOSYNC` mode which may result in full DB corruption during -system crash as with LMDB. +* In _LMDB_ this results in degraded performance of all operations + of syncing data to persistent storage. -Next version of _libmdbx_ will create steady synchronization points -automatically in async-write mode. +* _libmdbx_ has a mechanism which aborts such operations and `LIFO RECLAIM` + mode which addresses performance degradation. --------------------------------------------------------------------------------- +Read operations operate only over snapshot of DB which is consistent on the moment when read transaction started. +This snapshot doesn't change throughout the transaction but this leads to inability to reclaim the pages until +read transaction ends. -Performance comparison -====================== +In _LMDB_ this leads to a problem that memory pages, allocated for operations during long read, will be used for operations +and won't be reclaimed until DB process terminates. In _LMDB_ they are used in +[FIFO](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics)) manner, which causes increased page count +and less chance of cache hit during I/O. In other words: one long-time reader can impact performance of all database +until it'll be reopened. -All benchmarks were done by [IOArena](https://github.com/pmwkaa/ioarena) -and multiple [scripts](https://github.com/pmwkaa/ioarena/tree/HL%2B%2B2015) -runs on Lenovo Carbon-2 laptop, i7-4600U 2.1 GHz, 8 Gb RAM, -SSD SAMSUNG MZNTD512HAGL-000L1 (DXT23L0Q) 512 Gb. +_libmdbx_ addresses the problem, details below. Illustrations to this problem can be found in the +[presentation](http://www.slideshare.net/leoyuriev/lmdb). There is also example of performance increase thanks to +[BBWC](https://en.wikipedia.org/wiki/Disk_buffer#Write_acceleration) when `LIFO RECLAIM` enabled in _libmdbx_. --------------------------------------------------------------------------------- +#### Data safety in async-write mode -### Integral performance +In `WRITEMAP+MAPSYNC` mode dirty pages are written to persistent storage by kernel. This means that in case of application +crash OS kernel will write all dirty data to disk and nothing will be lost. But in case of hardware malfunction or OS kernel +fatal error only some dirty data might be synced to disk, and there is high probability that pages with metadata saved, +will point to non-saved, hence non-existent, data pages. In such situation, DB is completely corrupted and can't be +repaired even if there was full sync before the crash via `mdbx_env_sync(). -Here showed sum of performance metrics in 3 benchmarks: +_libmdbx_ addresses this by fully reimplementing write path of data: - - Read/Search on 4 CPU cores machine; +* In `WRITEMAP+MAPSYNC` mode meta-data pages aren't updated in place, instead their shadow copies are used and their updates + are synced after data is flushed to disk. - - Transactions with [CRUD](https://en.wikipedia.org/wiki/CRUD) - operations in sync-write mode (fdatasync is called after each - transaction); +* During transaction commit _libmdbx_ marks synchronization points as steady or weak depending on how much synchronization + needed between RAM and persistent storage, e.g. in `WRITEMAP+MAPSYNC` commited transactions are marked as weak, + but during explicit data synchronization - as steady. - - Transactions with [CRUD](https://en.wikipedia.org/wiki/CRUD) - operations in lazy-write mode (moment to sync data to persistent storage - is decided by OS). +* _libmdbx_ maintains three separate meta-pages instead of two. This allows to commit transaction with steady or +weak synchronization point without losing two previous synchronization points (one of them can be steady, and second - weak). +This allows to order weak and steady synchronization points in any order without losing consistency in case of system crash. -*Reasons why asynchronous mode isn't benchmarked here:* +* During DB open _libmdbx_ rollbacks to the last steady synchronization point, this guarantees database integrity. - 1. It doesn't make sense as it has to be done with DB engines, oriented - for keeping data in memory e.g. [Tarantool](https://tarantool.io/), - [Redis](https://redis.io/)), etc. +For data safety pages which form database snapshot with steady synchronization point must not be updated until next steady +synchronization point. So last steady synchronization point creates "long-time read" effect. The only difference that in case +of memory exhaustion the problem will be immediately addressed by flushing changes to persistent storage and forming new steady +synchronization point. - 2. Performance gap is too high to compare in any meaningful way. +So in async-write mode _libmdbx_ will always use new pages until memory is exhausted or `mdbx_env_sync()` is invoked. Total +disk usage will be almost the same as in sync-write mode. - +Current _libmdbx_ gives a choice of safe async-write mode (default) and `UTTERLY_NOSYNC` mode which may result in full DB +corruption during system crash as with LMDB. + +Next version of _libmdbx_ will create steady synchronization points automatically in async-write mode. -------------------------------------------------------------------------------- -### Read Scalability +Improvements over LMDB +================================================ -Summary performance with concurrent read/search queries in 1-2-4-8 -threads on 4 CPU cores machine. +1. `LIFO RECLAIM` mode: - + The newest pages are picked for reuse instead of the oldest. + This allows to minimize reclaim loop and make it execution time independent of total page count. --------------------------------------------------------------------------------- + This results in OS kernel cache mechanisms working with maximum efficiency. + In case of using disk controllers or storages with + [BBWC](https://en.wikipedia.org/wiki/Disk_buffer#Write_acceleration) this may greatly improve + write performance. -### Sync-write mode +2. `OOM-KICK` callback. - - Linear scale on left and dark rectangles mean arithmetic mean - transactions per second; + `mdbx_env_set_oomfunc()` allows to set a callback, which will be called + in the event of memory exhausting during long-time read transaction. + Callback will be invoked with PID and pthread_id of offending thread as parameters. + Callback can do any of these things to remedy the problem: - - Logarithmic scale on right is in seconds and yellow intervals mean - execution time of transactions. Each interval shows minimal and maximum - execution time, cross marks standard deviation. + * wait for read transaction to finish normally; -**10,000 transactions in sync-write mode**. In case of a crash all data -is consistent and state is right after last successful transaction. -[fdatasync](https://linux.die.net/man/2/fdatasync) syscall is used after -each write transaction in this mode. + * kill the offending process (signal 9), if separate process is doing long-time read; -In the benchmark each transaction contains combined CRUD operations (2 -inserts, 1 read, 1 update, 1 delete). Benchmark starts on empty database -and after full run the database contains 10,000 small key-value records. + * abort or restart offending read transaction if it's running in sibling thread; - + * abort current write transaction with returning error code. --------------------------------------------------------------------------------- +3. Guarantee of DB integrity in `WRITEMAP+MAPSYNC` mode: + > Current _libmdbx_ gives a choice of safe async-write mode (default) + > and `UTTERLY_NOSYNC` mode which may result in full + > DB corruption during system crash as with LMDB. For details see + > [Data safety in async-write mode](#data-safety-in-async-write-mode). -### Lazy-write mode +4. Automatic creation of synchronization points (flush changes to persistent storage) + when changes reach set threshold (threshold can be set by `mdbx_env_set_syncbytes()`). - - Linear scale on left and dark rectangles mean arithmetic mean of - thousands transactions per second; +5. Ability to get how far current read-only snapshot is from latest version of the DB by `mdbx_txn_straggler()`. - - Logarithmic scale on right in seconds and yellow intervals mean - execution time of transactions. Each interval shows minimal and maximum - execution time, cross marks standard deviation. +6. `mdbx_chk` tool for DB checking and `mdbx_env_pgwalk()` for page-walking all pages in DB. -**100,000 transactions in lazy-write mode**. In case of a crash all data -is consistent and state is right after one of last transactions, but -transactions after it will be lost. Other DB engines use -[WAL](https://en.wikipedia.org/wiki/Write-ahead_logging) or transaction -journal for that, which in turn depends on order of operations in -journaled filesystem. _libmdbx_ doesn't use WAL and hands I/O operations -to filesystem and OS kernel (mmap). +7. Control over debugging and receiving of debugging messages via `mdbx_setup_debug()`. -In the benchmark each transaction contains combined CRUD operations (2 -inserts, 1 read, 1 update, 1 delete). Benchmark starts on empty database -and after full run the database contains 100,000 small key-value -records. +8. Ability to assign up to 3 markers to commiting transaction with `mdbx_canary_put()` and then get them in read transaction + by `mdbx_canary_get()`. +9. Check if there is a row with data after current cursor position via `mdbx_cursor_eof()`. - +10. Ability to explicitly request update of present record without creating new record. Implemented as `MDBX_CURRENT` flag + for `mdbx_put()`. --------------------------------------------------------------------------------- +11. Ability to update or delete record and get previous value via `mdbx_replace()` Also can update specific multi-value. -### Async-write mode +12. Support for keys and values of zero length, including sorted duplicates. - - Linear scale on left and dark rectangles mean arithmetic mean of - thousands transactions per second; +13. Fixed `mdbx_cursor_count()`, which returns correct count of duplicated for all table types and any cursor position. - - Logarithmic scale on right in seconds and yellow intervals mean - execution time of transactions. Each interval shows minimal and maximum - execution time, cross marks standard deviation. +14. Ability to open DB in exclusive mode with `MDBX_EXCLUSIVE` flag, e.g. for integrity check. -**1,000,000 transactions in async-write mode**. In case of a crash all -data will be consistent and state will be right after one of last -transactions, but lost transaction count is much higher than in -lazy-write mode. All DB engines in this mode do as little writes as -possible on persistent storage. _libmdbx_ uses -[msync(MS_ASYNC)](https://linux.die.net/man/2/msync) in this mode. +15. Ability to close DB in "dirty" state (without data flush and creation of steady synchronization point) + via `mdbx_env_close_ex()`. -In the benchmark each transaction contains combined CRUD operations (2 -inserts, 1 read, 1 update, 1 delete). Benchmark starts on empty database -and after full run the database contains 10,000 small key-value records. +16. Ability to get additional info, including number of the oldest snapshot of DB, which is used by one of the readers. + Implemented via `mdbx_env_info()`. - +17. `mdbx_del()` doesn't ignore additional argument (specifier) `data` + for tables without duplicates (without flag `MDBX_DUPSORT`), if `data` is not zero then always uses it to verify + record, which is being deleted. --------------------------------------------------------------------------------- +18. Ability to open dbi-table with simultaneous setup of comparators for keys and values, via `mdbx_dbi_open_ex()`. -### Cost comparison +19. Ability to find out if key or value is in dirty page. This may be useful to make a decision to avoid + excessive CoW before updates. Implemented via `mdbx_is_dirty()`. -Summary of used resources during lazy-write mode benchmarks: +20. Correct update of current record in `MDBX_CURRENT` mode of `mdbx_cursor_put()`, including sorted duplicated. - - Read and write IOPS; +21. All cursors in all read and write transactions can be reused by `mdbx_cursor_renew()` and MUST be freed explicitly. + > ## Caution, please pay attention! + > + > This is the only change of API, which changes semantics of cursor management + > and can lead to memory leaks on misuse. This is a needed change as it eliminates ambiguity + > which helps to avoid such errors as: + > - use-after-free; + > - double-free; + > - memory corruption and segfaults. - - Sum of user CPU time and sys CPU time; +22. Additional error code `MDBX_EMULTIVAL`, which is returned by `mdbx_put()` and + `mdbx_replace()` in case is ambiguous update or delete. - - Used space on persistent storage after the test and closed DB, but not - waiting for the end of all internal housekeeping operations (LSM - compactification, etc). +23. Ability to get value by key and duplicates count by `mdbx_get_ex()`. -_ForestDB_ is excluded because benchmark showed it's resource -consumption for each resource (CPU, IOPS) much higher than other engines -which prevents to meaningfully compare it with them. +24. Functions `mdbx_cursor_on_first() and mdbx_cursor_on_last(), which allows to know if cursor is currently on first or + last position respectively. -All benchmark data is gathered by -[getrusage()](http://man7.org/linux/man-pages/man2/getrusage.2.html) -syscall and by scanning data directory. +25. If read transaction is aborted via `mdbx_txn_abort()` or `mdbx_txn_reset()` then DBI-handles, which were opened in it, + aren't closed or deleted. This allows to avoid several types of hard-to-debug errors. - +26. Sequence generation via `mdbx_dbi_sequence()`. + +27. Advanced dynamic control over DB size, including ability to choose page size via `mdbx_env_set_geometry()`, + including on Windows. + +28. Three meta-pages instead of two, this allows to guarantee consistently update weak sync-points without risking to + corrupt last steady sync-point. + +29. Automatic reclaim of freed pages to specific reserved space at the end of database file. This lowers amount of pages, + loaded to memory, used in update/flush loop. In fact _libmdbx_ constantly performs compactification of data, + but doesn't use additional resources for that. Space reclaim of DB and setup of database geometry parameters also decreases + size of the database on disk, including on Windows. -------------------------------------------------------------------------------- @@ -597,3 +474,16 @@ Idx Name Size VMA LMA File off Algn CONTENTS, ALLOC, LOAD, READONLY, CODE ``` + +``` +$ gcc -v +Using built-in specs. +COLLECT_GCC=gcc +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/7/lto-wrapper +OFFLOAD_TARGET_NAMES=nvptx-none +OFFLOAD_TARGET_DEFAULT=1 +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 7.2.0-8ubuntu3' --with-bugurl=file:///usr/share/doc/gcc-7/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-7 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 7.2.0 (Ubuntu 7.2.0-8ubuntu3) +``` diff --git a/libs/libmdbx/src/TODO.md b/libs/libmdbx/src/TODO.md new file mode 100644 index 0000000000..810b18dc4a --- /dev/null +++ b/libs/libmdbx/src/TODO.md @@ -0,0 +1,89 @@ +Допеределки +=========== +- [ ] Перевод mdbx-tools на С++ и сборка для Windows. +- [ ] Переход на CMake, замена заглушек mdbx_version и mdbx_build. +- [ ] Актуализация README.md +- [ ] Переход на C++11, добавление #pramga detect_mismatch(). +- [ ] Убрать MDB_DEBUG (всегда: логирование важный ситуаций и ошибок, опционально: включение ассертов и трассировка). +- [ ] Заменить mdbx_debug на mdbx_trace, и почистить... +- [ ] Заметить максимум assert() на mdbx_assert(env, ...). + +Качество и CI +============= +- [ ] Добавить в CI linux сборки для 32-битных таргетов. + +Доработки API +============= +- [ ] Поправить/Добавить описание нового API. +- [ ] Добавить возможность "подбора" режима для mdbx_env_open(). +- [ ] Переименовать в API: env->db, db->tbl. + +Тесты +===== +- [ ] Тестирование поддержки lockless-режима. +- [x] Додумать имя и размещение тестовой БД по-умолчанию. +- [ ] Реализовать cleanup в тесте. +- [ ] usage для теста. +- [ ] Логирование в файл, плюс более полный progress bar. +- [ ] Опция игнорирования (пропуска части теста) при переполнении БД. +- [ ] Базовый бенчмарк. + +Развитие +======== +- [ ] Отслеживание времени жизни DBI-хендлов. +- [ ] Отрефакторить mdbx_freelist_save(). +- [ ] Хранить "свободный хвост" не связанный с freeDB в META. +- [x] Возврат выделенных страниц в unallocated tail-pool. +- [ ] Валидатор страниц БД по номеру транзакции: + ~0 при переработке и номер транзакции при выделении, + проверять что этот номер больше головы реклайминга и не-больше текущей транзакции. +- [ ] Размещение overflow-pages в отдельном mmap/файле с собственной геометрией. +- [ ] Зафиксировать формат БД. +- [ ] Валидатор страниц по CRC32, плюс контроль номер транзакии под модулю 2^32. +- [ ] Валидатор страниц по t1ha c контролем снимков/версий БД на основе Merkle Tree. +- [ ] Возможность хранения ключей внутри data (libfptu). +- [ ] Асинхронная фиксация (https://github.com/leo-yuriev/libmdbx/issues/5). +- [ ] (Пере)Выделять память под IDL-списки с учетом реального кол-ва страниц, т.е. max(MDB_IDL_UM_MAX/MDB_IDL_UM_MAX, npages). + +----------------------------------------------------------------------- + +Сделано +======= +- [x] разделение errno и GetLastError(). +- [x] CI посредством AppVeyor. +- [x] тест конкурентного доступа. +- [x] тест основного функционала (заменить текущий треш). +- [x] uint32/uint64 в структурах. +- [x] Завершить переименование. +- [x] Макросы версионности, сделать как в fpta (cmake?). +- [x] Попробовать убрать yield (или что там с местом?). +- [x] trinity для copy/compaction. +- [x] trinity для mdbx_chk и mdbx_stat. +- [x] проверки с mdbx_meta_eq. +- [x] Не проверять режим при открытии в readonly. +- [x] Поправить выбор tail в mdbx_chk. +- [x] Там-же проверять позицию реклайминга. +- [x] поправить проблему открытия после READ-ONLY. +- [x] static-assertы на размер/выравнивание lck, meta и т.п. +- [x] Зачистить size_t. +- [x] Добавить локи вокруг dbi. +- [x] Привести в порядок volatile. +- [x] контроль meta.mapsize. +- [x] переработка формата: заголовки страниц, meta, clk... +- [x] зачистка Doxygen и бесполезных комментариев. +- [x] Добавить поле типа контрольной суммы. +- [x] Добавить поле/флаг размера pgno_t. +- [x] Поменять сигнатуры. +- [x] Добавить мета-страницы в coredump, проверить lck. +- [x] Сделать список для txnid_t, кода sizeof(txnid_t) > sizeof(pgno_t) и вернуть размер pgno_t. +- [x] Избавиться от умножения на размер страницы (заменить на сдвиг). +- [x] Устранение всех предупреждений (в том числе под Windows). +- [x] Добавить 'mti_reader_finished_flag'. +- [x] Погасить все level4-warnings от MSVC, включить /WX. +- [x] Проверка посредством Coverity с гашением всех дефектов. +- [x] Полная матрица Windows-сборок (2013/2015/2017). +- [x] Дать возможность задавать размер страницы при создании БД. +- [x] Изменение mapsize через API с блокировкой и увеличением txn. +- [x] Контроль размера страницы полного размера и кол-ва страниц при создании и обновлении. +- [x] Инкрементальный mmap. +- [x] Инкрементальное приращение размера (колбэк стратегии?). diff --git a/libs/libmdbx/src/packages/rpm/build.sh b/libs/libmdbx/src/build.sh index 5170882265..5170882265 100644 --- a/libs/libmdbx/src/packages/rpm/build.sh +++ b/libs/libmdbx/src/build.sh diff --git a/libs/libmdbx/src/mdbx.h b/libs/libmdbx/src/mdbx.h index 57efd875cf..35faed8488 100644 --- a/libs/libmdbx/src/mdbx.h +++ b/libs/libmdbx/src/mdbx.h @@ -924,6 +924,7 @@ LIBMDBX_API int mdbx_env_set_maxdbs(MDBX_env *env, MDBX_dbi dbs); * * Returns The maximum size of a key we can write. */ LIBMDBX_API int mdbx_env_get_maxkeysize(MDBX_env *env); +LIBMDBX_API int mdbx_get_maxkeysize(size_t pagesize); /* Set application information associated with the MDBX_env. * @@ -1696,13 +1697,6 @@ LIBMDBX_API int mdbx_is_dirty(const MDBX_txn *txn, const void *ptr); LIBMDBX_API int mdbx_dbi_sequence(MDBX_txn *txn, MDBX_dbi dbi, uint64_t *result, uint64_t increment); -LIBMDBX_API int mdbx_limits_pgsize_min(void); -LIBMDBX_API int mdbx_limits_pgsize_max(void); -LIBMDBX_API intptr_t mdbx_limits_dbsize_min(intptr_t pagesize); -LIBMDBX_API intptr_t mdbx_limits_dbsize_max(intptr_t pagesize); -LIBMDBX_API intptr_t mdbx_limits_keysize_max(intptr_t pagesize); -LIBMDBX_API intptr_t mdbx_limits_txnsize_max(intptr_t pagesize); - /*----------------------------------------------------------------------------*/ /* attribute support functions for Nexenta */ typedef uint_fast64_t mdbx_attr_t; diff --git a/libs/libmdbx/src/packages/rpm/package.sh b/libs/libmdbx/src/package.sh index d7f9ab297a..d7f9ab297a 100644 --- a/libs/libmdbx/src/packages/rpm/package.sh +++ b/libs/libmdbx/src/package.sh diff --git a/libs/libmdbx/src/src/bits.h b/libs/libmdbx/src/src/bits.h index 559435b49d..955a583264 100644 --- a/libs/libmdbx/src/src/bits.h +++ b/libs/libmdbx/src/src/bits.h @@ -508,7 +508,12 @@ typedef MDBX_ID2 *MDBX_ID2L; /* PNL sizes - likely should be even bigger * limiting factors: sizeof(pgno_t), thread stack size */ -#define MDBX_LIST_MAX ((1 << 24) - 1) +#define MDBX_PNL_LOGN 16 /* DB_SIZE is 2^16, UM_SIZE is 2^17 */ +#define MDBX_PNL_DB_SIZE (1 << MDBX_PNL_LOGN) +#define MDBX_PNL_UM_SIZE (1 << (MDBX_PNL_LOGN + 1)) + +#define MDBX_PNL_DB_MAX (MDBX_PNL_DB_SIZE - 1) +#define MDBX_PNL_UM_MAX (MDBX_PNL_UM_SIZE - 1) #define MDBX_PNL_SIZEOF(pl) (((pl)[0] + 1) * sizeof(pgno_t)) #define MDBX_PNL_IS_ZERO(pl) ((pl)[0] == 0) @@ -752,10 +757,10 @@ struct MDBX_env { MDBX_page *me_dpages; /* list of malloc'd blocks for re-use */ /* PNL of pages that became unused in a write txn */ MDBX_PNL me_free_pgs; - /* ID2L of pages written during a write txn. Length MDBX_LIST_MAX. */ + /* ID2L of pages written during a write txn. Length MDBX_PNL_UM_SIZE. */ MDBX_ID2L me_dirtylist; - /* Number of freelist items that can fit in a single overflow page */ - unsigned me_maxgc_ov1page; + /* Max number of freelist items that can fit in a single overflow page */ + unsigned me_maxfree_1pg; /* Max size of a node on a page */ unsigned me_nodemax; unsigned me_maxkey_limit; /* max size of a key */ diff --git a/libs/libmdbx/src/src/defs.h b/libs/libmdbx/src/src/defs.h index 4b045efc1d..b6076cc1b3 100644 --- a/libs/libmdbx/src/src/defs.h +++ b/libs/libmdbx/src/src/defs.h @@ -327,13 +327,6 @@ # define mdbx_func_ "<mdbx_unknown>" #endif -#if defined(__GNUC__) || __has_attribute(format) -#define __printf_args(format_index, first_arg) \ - __attribute__((format(printf, format_index, first_arg))) -#else -#define __printf_args(format_index, first_arg) -#endif - /*----------------------------------------------------------------------------*/ #if defined(USE_VALGRIND) diff --git a/libs/libmdbx/src/src/lck-posix.c b/libs/libmdbx/src/src/lck-posix.c index 0aa9d85078..869b98c054 100644 --- a/libs/libmdbx/src/src/lck-posix.c +++ b/libs/libmdbx/src/src/lck-posix.c @@ -48,7 +48,7 @@ static __cold __attribute__((destructor)) void mdbx_global_destructor(void) { #endif #define LCK_WHOLE OFF_T_MAX -static int mdbx_lck_op(mdbx_filehandle_t fd, int op, short lck, off_t offset, +static int mdbx_lck_op(mdbx_filehandle_t fd, int op, int lck, off_t offset, off_t len) { for (;;) { int rc; @@ -68,19 +68,11 @@ static int mdbx_lck_op(mdbx_filehandle_t fd, int op, short lck, off_t offset, } } -static __inline int mdbx_lck_exclusive(int lfd, bool fallback2shared) { +static __inline int mdbx_lck_exclusive(int lfd) { assert(lfd != INVALID_HANDLE_VALUE); if (flock(lfd, LOCK_EX | LOCK_NB)) return errno; - int rc = mdbx_lck_op(lfd, F_SETLK, F_WRLCK, 0, 1); - if (rc != 0 && fallback2shared) { - while (flock(lfd, LOCK_SH)) { - int rc = errno; - if (rc != EINTR) - return rc; - } - } - return rc; + return mdbx_lck_op(lfd, F_SETLK, F_WRLCK, 0, 1); } static __inline int mdbx_lck_shared(int lfd) { @@ -98,6 +90,8 @@ int mdbx_lck_downgrade(MDBX_env *env, bool complete) { return complete ? mdbx_lck_shared(env->me_lfd) : MDBX_SUCCESS; } +int mdbx_lck_upgrade(MDBX_env *env) { return mdbx_lck_exclusive(env->me_lfd); } + int mdbx_rpid_set(MDBX_env *env) { assert(env->me_lfd != INVALID_HANDLE_VALUE); return mdbx_lck_op(env->me_lfd, F_SETLK, F_WRLCK, env->me_pid, 1); @@ -156,10 +150,6 @@ int __cold mdbx_lck_init(MDBX_env *env) { goto bailout; #endif /* PTHREAD_PRIO_INHERIT */ - rc = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK); - if (rc) - goto bailout; - rc = pthread_mutex_init(&env->me_lck->mti_rmutex, &ma); if (rc) goto bailout; @@ -173,7 +163,7 @@ bailout: void __cold mdbx_lck_destroy(MDBX_env *env) { if (env->me_lfd != INVALID_HANDLE_VALUE) { /* try get exclusive access */ - if (env->me_lck && mdbx_lck_exclusive(env->me_lfd, false) == 0) { + if (env->me_lck && mdbx_lck_exclusive(env->me_lfd) == 0) { mdbx_info("%s: got exclusive, drown mutexes", mdbx_func_); int rc = pthread_mutex_destroy(&env->me_lck->mti_rmutex); if (rc == 0) @@ -242,7 +232,7 @@ static int __cold internal_seize_lck(int lfd) { assert(lfd != INVALID_HANDLE_VALUE); /* try exclusive access */ - int rc = mdbx_lck_exclusive(lfd, false); + int rc = mdbx_lck_exclusive(lfd); if (rc == 0) /* got exclusive */ return MDBX_RESULT_TRUE; @@ -251,7 +241,7 @@ static int __cold internal_seize_lck(int lfd) { rc = mdbx_lck_shared(lfd); if (rc == 0) { /* got shared, try exclusive again */ - rc = mdbx_lck_exclusive(lfd, true); + rc = mdbx_lck_exclusive(lfd); if (rc == 0) /* now got exclusive */ return MDBX_RESULT_TRUE; diff --git a/libs/libmdbx/src/src/lck-windows.c b/libs/libmdbx/src/src/lck-windows.c index 7da0755916..02b074e9fc 100644 --- a/libs/libmdbx/src/src/lck-windows.c +++ b/libs/libmdbx/src/src/lck-windows.c @@ -457,6 +457,51 @@ int mdbx_lck_downgrade(MDBX_env *env, bool complete) { return MDBX_SUCCESS /* 7) now at S-? (used), done */; } +int mdbx_lck_upgrade(MDBX_env *env) { + /* Transite from locked state (S-E) to exclusive-write (E-E) */ + assert(env->me_fd != INVALID_HANDLE_VALUE); + assert(env->me_lfd != INVALID_HANDLE_VALUE); + assert((env->me_flags & MDBX_EXCLUSIVE) == 0); + + if (env->me_flags & MDBX_EXCLUSIVE) + return MDBX_RESULT_TRUE /* files were must be opened non-shareable */; + + /* 1) must be at S-E (locked), transite to ?_E (middle) */ + if (!funlock(env->me_lfd, LCK_LOWER)) + mdbx_panic("%s(%s) failed: errcode %u", mdbx_func_, + "S-E(locked) >> ?-E(middle)", GetLastError()); + + /* 3) now on ?-E (middle), try E-E (exclusive-write) */ + mdbx_jitter4testing(false); + if (flock(env->me_lfd, LCK_EXCLUSIVE | LCK_DONTWAIT, LCK_LOWER)) + return MDBX_RESULT_TRUE; /* 4) got E-E (exclusive-write), done */ + + /* 5) still on ?-E (middle) */ + int rc = GetLastError(); + mdbx_jitter4testing(false); + if (rc != ERROR_SHARING_VIOLATION && rc != ERROR_LOCK_VIOLATION) { + /* 6) something went wrong, report but continue */ + mdbx_error("%s(%s) failed: errcode %u", mdbx_func_, + "?-E(middle) >> E-E(exclusive-write)", rc); + } + + /* 7) still on ?-E (middle), try restore S-E (locked) */ + mdbx_jitter4testing(false); + rc = flock(env->me_lfd, LCK_SHARED | LCK_DONTWAIT, LCK_LOWER) + ? MDBX_RESULT_FALSE + : GetLastError(); + + mdbx_jitter4testing(false); + if (rc != MDBX_RESULT_FALSE) { + mdbx_fatal("%s(%s) failed: errcode %u", mdbx_func_, + "?-E(middle) >> S-E(locked)", rc); + return rc; + } + + /* 8) now on S-E (locked) */ + return MDBX_RESULT_FALSE; +} + void mdbx_lck_destroy(MDBX_env *env) { int rc; diff --git a/libs/libmdbx/src/src/mdbx.c b/libs/libmdbx/src/src/mdbx.c index cafaefc19c..57d6ec1928 100644 --- a/libs/libmdbx/src/src/mdbx.c +++ b/libs/libmdbx/src/src/mdbx.c @@ -1,4 +1,4 @@ -/* +/* * Copyright 2015-2018 Leonid Yuriev <leo@yuriev.ru> * and other libmdbx authors: please see AUTHORS file. * All rights reserved. @@ -501,7 +501,6 @@ __cold void mdbx_rthc_remove(const mdbx_thread_key_t key) { * Allocates memory for an PNL of the given size. * Returns PNL on success, NULL on failure. */ static MDBX_PNL mdbx_pnl_alloc(size_t size) { - assert(size <= MDBX_LIST_MAX); MDBX_PNL pl = malloc((size + 2) * sizeof(pgno_t)); if (likely(pl)) { *pl++ = (pgno_t)size; @@ -537,15 +536,12 @@ static void mdbx_txl_free(MDBX_TXL list) { /* Append ID to PNL. The PNL must be big enough. */ static __inline void mdbx_pnl_xappend(MDBX_PNL pl, pgno_t id) { - assert(pl[0] + (size_t)1 <= MDBX_PNL_ALLOCLEN(pl)); + assert(pl[0] + (size_t)1 < MDBX_PNL_ALLOCLEN(pl)); pl[pl[0] += 1] = id; } -static bool mdbx_pnl_check(MDBX_PNL pl, bool allocated) { +static bool mdbx_pnl_check(MDBX_PNL pl) { if (pl) { - if (allocated) { - assert(pl[0] <= MDBX_LIST_MAX && pl[0] <= pl[-1]); - } for (const pgno_t *ptr = pl + pl[0]; --ptr > pl;) { assert(MDBX_PNL_ORDERED(ptr[0], ptr[1])); assert(ptr[0] >= NUM_METAS); @@ -633,7 +629,7 @@ static void __hot mdbx_pnl_sort(MDBX_PNL pnl) { } #undef PNL_SMALL #undef PNL_SWAP - assert(mdbx_pnl_check(pnl, false)); + assert(mdbx_pnl_check(pnl)); } /* Search for an ID in an PNL. @@ -641,7 +637,7 @@ static void __hot mdbx_pnl_sort(MDBX_PNL pnl) { * [in] id The ID to search for. * Returns The index of the first ID greater than or equal to id. */ static unsigned __hot mdbx_pnl_search(MDBX_PNL pnl, pgno_t id) { - assert(mdbx_pnl_check(pnl, true)); + assert(mdbx_pnl_check(pnl)); /* binary search of id in pl * if found, returns position of id @@ -678,12 +674,12 @@ static unsigned __hot mdbx_pnl_search(MDBX_PNL pnl, pgno_t id) { * [in,out] ppl Address of the PNL to shrink. */ static void mdbx_pnl_shrink(MDBX_PNL *ppl) { MDBX_PNL pl = *ppl - 1; - if (unlikely(*pl > MDBX_LIST_MAX)) { - /* shrink to MDBX_LIST_MAX */ - pl = realloc(pl, (MDBX_LIST_MAX + 2) * sizeof(pgno_t)); + if (unlikely(*pl > MDBX_PNL_UM_MAX)) { + /* shrink to MDBX_PNL_UM_MAX */ + pl = realloc(pl, (MDBX_PNL_UM_MAX + 2) * sizeof(pgno_t)); if (likely(pl)) { - *pl = MDBX_LIST_MAX; - *ppl = pl + 1; + *pl++ = MDBX_PNL_UM_MAX; + *ppl = pl; } } } @@ -691,80 +687,104 @@ static void mdbx_pnl_shrink(MDBX_PNL *ppl) { /* Grow an PNL. * Return the PNL to the size growed by given number. * [in,out] ppl Address of the PNL to grow. */ -static int __must_check_result mdbx_pnl_grow(MDBX_PNL *ppl, size_t num) { - MDBX_PNL pl = *ppl - 1; - assert(pl[1] <= MDBX_LIST_MAX && pl[1] <= pl[0]); - assert(num <= MDBX_LIST_MAX); - num += pl[0]; - if (unlikely(num > MDBX_LIST_MAX)) - return MDBX_TXN_FULL; +static int mdbx_pnl_grow(MDBX_PNL *ppl, size_t num) { + MDBX_PNL idn = *ppl - 1; /* grow it */ - pl = realloc(pl, (num + 2) * sizeof(pgno_t)); - if (unlikely(!pl)) + idn = realloc(idn, (*idn + num + 2) * sizeof(pgno_t)); + if (unlikely(!idn)) return MDBX_ENOMEM; - *pl = (pgno_t)num; - *ppl = pl + 1; - return MDBX_SUCCESS; + *idn++ += (pgno_t)num; + *ppl = idn; + return 0; +} + +static int mdbx_txl_grow(MDBX_TXL *ptr, size_t num) { + MDBX_TXL list = *ptr - 1; + /* grow it */ + list = realloc(list, ((size_t)*list + num + 2) * sizeof(txnid_t)); + if (unlikely(!list)) + return MDBX_ENOMEM; + *list++ += num; + *ptr = list; + return 0; } /* Make room for num additional elements in an PNL. * [in,out] ppl Address of the PNL. * [in] num Number of elements to make room for. * Returns 0 on success, MDBX_ENOMEM on failure. */ -static int __must_check_result mdbx_pnl_need(MDBX_PNL *ppl, size_t num) { - MDBX_PNL pl = *ppl - 1; - assert(pl[1] <= MDBX_LIST_MAX && pl[1] <= pl[0]); - assert(num <= MDBX_LIST_MAX); - num += pl[1]; - if (unlikely(num > pl[0])) { - if (unlikely(num > MDBX_LIST_MAX)) - return MDBX_TXN_FULL; - num = (num + num / 4 + (256 + 2)) & ~255u; - num = (num < MDBX_LIST_MAX + 2) ? num : MDBX_LIST_MAX + 2; - pl = realloc(pl, num * sizeof(pgno_t)); +static int mdbx_pnl_need(MDBX_PNL *ppl, size_t num) { + MDBX_PNL pl = *ppl; + num += pl[0]; + if (unlikely(num > pl[-1])) { + num = (num + num / 4 + (256 + 2)) & -256; + pl = realloc(pl - 1, num * sizeof(pgno_t)); if (unlikely(!pl)) return MDBX_ENOMEM; - *pl = (pgno_t)num - 2; - *ppl = pl + 1; + *pl++ = (pgno_t)num - 2; + *ppl = pl; } - return MDBX_SUCCESS; + return 0; } /* Append an ID onto an PNL. * [in,out] ppl Address of the PNL to append to. * [in] id The ID to append. * Returns 0 on success, MDBX_ENOMEM if the PNL is too large. */ -static int __must_check_result mdbx_pnl_append(MDBX_PNL *ppl, pgno_t id) { +static int mdbx_pnl_append(MDBX_PNL *ppl, pgno_t id) { MDBX_PNL pl = *ppl; /* Too big? */ if (unlikely(pl[0] >= pl[-1])) { - int rc = mdbx_pnl_grow(ppl, MDBX_LIST_MAX); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; + if (mdbx_pnl_grow(ppl, MDBX_PNL_UM_MAX)) + return MDBX_ENOMEM; pl = *ppl; } pl[0]++; pl[pl[0]] = id; - return MDBX_SUCCESS; + return 0; +} + +static int mdbx_txl_append(MDBX_TXL *ptr, txnid_t id) { + MDBX_TXL list = *ptr; + /* Too big? */ + if (unlikely(list[0] >= list[-1])) { + if (mdbx_txl_grow(ptr, (size_t)list[0])) + return MDBX_ENOMEM; + list = *ptr; + } + list[0]++; + list[list[0]] = id; + return 0; } /* Append an PNL onto an PNL. * [in,out] ppl Address of the PNL to append to. * [in] app The PNL to append. * Returns 0 on success, MDBX_ENOMEM if the PNL is too large. */ -static int __must_check_result mdbx_pnl_append_list(MDBX_PNL *ppl, - MDBX_PNL app) { +static int mdbx_pnl_append_list(MDBX_PNL *ppl, MDBX_PNL app) { MDBX_PNL pnl = *ppl; /* Too big? */ if (unlikely(pnl[0] + app[0] >= pnl[-1])) { - int rc = mdbx_pnl_grow(ppl, app[0]); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; + if (mdbx_pnl_grow(ppl, app[0])) + return MDBX_ENOMEM; pnl = *ppl; } memcpy(&pnl[pnl[0] + 1], &app[1], app[0] * sizeof(pgno_t)); pnl[0] += app[0]; - return MDBX_SUCCESS; + return 0; +} + +static int mdbx_txl_append_list(MDBX_TXL *ptr, MDBX_TXL append) { + MDBX_TXL list = *ptr; + /* Too big? */ + if (unlikely(list[0] + append[0] >= list[-1])) { + if (mdbx_txl_grow(ptr, (size_t)append[0])) + return MDBX_ENOMEM; + list = *ptr; + } + memcpy(&list[list[0] + 1], &append[1], (size_t)append[0] * sizeof(txnid_t)); + list[0] += append[0]; + return 0; } /* Append an ID range onto an PNL. @@ -772,29 +792,27 @@ static int __must_check_result mdbx_pnl_append_list(MDBX_PNL *ppl, * [in] id The lowest ID to append. * [in] n Number of IDs to append. * Returns 0 on success, MDBX_ENOMEM if the PNL is too large. */ -static int __must_check_result mdbx_pnl_append_range(MDBX_PNL *ppl, pgno_t id, - size_t n) { +static int mdbx_pnl_append_range(MDBX_PNL *ppl, pgno_t id, size_t n) { pgno_t *pnl = *ppl, len = pnl[0]; /* Too big? */ if (unlikely(len + n > pnl[-1])) { - int rc = mdbx_pnl_grow(ppl, n | MDBX_LIST_MAX); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; + if (mdbx_pnl_grow(ppl, n | MDBX_PNL_UM_MAX)) + return MDBX_ENOMEM; pnl = *ppl; } pnl[0] = len + (pgno_t)n; pnl += len; while (n) pnl[n--] = id++; - return MDBX_SUCCESS; + return 0; } /* Merge an PNL onto an PNL. The destination PNL must be big enough. * [in] pl The PNL to merge into. * [in] merge The PNL to merge. */ static void __hot mdbx_pnl_xmerge(MDBX_PNL pnl, MDBX_PNL merge) { - assert(mdbx_pnl_check(pnl, true)); - assert(mdbx_pnl_check(merge, false)); + assert(mdbx_pnl_check(pnl)); + assert(mdbx_pnl_check(merge)); pgno_t old_id, merge_id, i = merge[0], j = pnl[0], k = i + j, total = k; pnl[0] = MDBX_PNL_ASCENDING ? 0 : ~(pgno_t)0; /* delimiter for pl scan below */ @@ -806,58 +824,7 @@ static void __hot mdbx_pnl_xmerge(MDBX_PNL pnl, MDBX_PNL merge) { pnl[k--] = merge_id; } pnl[0] = total; - assert(mdbx_pnl_check(pnl, true)); -} - -static int __must_check_result mdbx_txl_grow(MDBX_TXL *ptr, size_t num) { - MDBX_TXL list = *ptr - 1; - /* grow it */ - list = realloc(list, ((size_t)*list + num + 2) * sizeof(txnid_t)); - if (unlikely(!list)) - return MDBX_ENOMEM; - *list += num; - *ptr = list + 1; - return MDBX_SUCCESS; -} - -static int mdbx_txl_cmp(const void *pa, const void *pb) { - const txnid_t a = *(MDBX_TXL)pa; - const txnid_t b = *(MDBX_TXL)pb; - return mdbx_cmp2int(b, a); -} - -static void mdbx_txl_sort(MDBX_TXL ptr) { - /* LY: temporary */ - qsort(ptr + 1, (size_t)ptr[0], sizeof(*ptr), mdbx_txl_cmp); -} - -static int __must_check_result mdbx_txl_append(MDBX_TXL *ptr, txnid_t id) { - MDBX_TXL list = *ptr; - /* Too big? */ - if (unlikely(list[0] >= list[-1])) { - int rc = mdbx_txl_grow(ptr, (size_t)list[0]); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; - list = *ptr; - } - list[0]++; - list[list[0]] = id; - return MDBX_SUCCESS; -} - -static int __must_check_result mdbx_txl_append_list(MDBX_TXL *ptr, - MDBX_TXL append) { - MDBX_TXL list = *ptr; - /* Too big? */ - if (unlikely(list[0] + append[0] >= list[-1])) { - int rc = mdbx_txl_grow(ptr, (size_t)append[0]); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; - list = *ptr; - } - memcpy(&list[list[0] + 1], &append[1], (size_t)append[0] * sizeof(txnid_t)); - list[0] += append[0]; - return MDBX_SUCCESS; + assert(mdbx_pnl_check(pnl)); } /* Search for an ID in an ID2L. @@ -906,45 +873,45 @@ static unsigned __hot mdbx_mid2l_search(MDBX_ID2L pnl, pgno_t id) { * [in,out] pnl The ID2L to insert into. * [in] id The ID2 to insert. * Returns 0 on success, -1 if the ID was already present in the ID2L. */ -static int __must_check_result mdbx_mid2l_insert(MDBX_ID2L pnl, MDBX_ID2 *id) { +static int mdbx_mid2l_insert(MDBX_ID2L pnl, MDBX_ID2 *id) { unsigned x = mdbx_mid2l_search(pnl, id->mid); if (unlikely(x < 1)) - return /* internal error */ MDBX_PROBLEM; + return /* internal error */ -2; - if (unlikely(pnl[x].mid == id->mid && x <= pnl[0].mid)) - return /* duplicate */ MDBX_PROBLEM; + if (x <= pnl[0].mid && pnl[x].mid == id->mid) + return /* duplicate */ -1; - if (unlikely(pnl[0].mid >= MDBX_LIST_MAX)) - return /* too big */ MDBX_TXN_FULL; + if (unlikely(pnl[0].mid >= MDBX_PNL_UM_MAX)) + return /* too big */ -2; /* insert id */ pnl[0].mid++; for (unsigned i = (unsigned)pnl[0].mid; i > x; i--) pnl[i] = pnl[i - 1]; pnl[x] = *id; - return MDBX_SUCCESS; + return 0; } /* Append an ID2 into a ID2L. * [in,out] pnl The ID2L to append into. * [in] id The ID2 to append. * Returns 0 on success, -2 if the ID2L is too big. */ -static int __must_check_result mdbx_mid2l_append(MDBX_ID2L pnl, MDBX_ID2 *id) { +static int mdbx_mid2l_append(MDBX_ID2L pnl, MDBX_ID2 *id) { #if MDBX_DEBUG for (unsigned i = pnl[0].mid; i > 0; --i) { assert(pnl[i].mid != id->mid); if (unlikely(pnl[i].mid == id->mid)) - return MDBX_PROBLEM; + return -1; } #endif /* Too big? */ - if (unlikely(pnl[0].mid >= MDBX_LIST_MAX)) - return /* too big */ MDBX_TXN_FULL; + if (unlikely(pnl[0].mid >= MDBX_PNL_UM_MAX)) + return -2; pnl[0].mid++; pnl[pnl[0].mid] = *id; - return MDBX_SUCCESS; + return 0; } /*----------------------------------------------------------------------------*/ @@ -1709,7 +1676,7 @@ static int mdbx_page_spill(MDBX_cursor *m0, MDBX_val *key, MDBX_val *data) { return MDBX_SUCCESS; if (!txn->mt_spill_pages) { - txn->mt_spill_pages = mdbx_pnl_alloc(MDBX_LIST_MAX); + txn->mt_spill_pages = mdbx_pnl_alloc(MDBX_PNL_UM_MAX); if (unlikely(!txn->mt_spill_pages)) return MDBX_ENOMEM; } else { @@ -1734,8 +1701,8 @@ static int mdbx_page_spill(MDBX_cursor *m0, MDBX_val *key, MDBX_val *data) { * of those pages will need to be used again. So now we spill only 1/8th * of the dirty pages. Testing revealed this to be a good tradeoff, * better than 1/2, 1/4, or 1/10. */ - if (need < MDBX_LIST_MAX / 8) - need = MDBX_LIST_MAX / 8; + if (need < MDBX_PNL_UM_MAX / 8) + need = MDBX_PNL_UM_MAX / 8; /* Save the page IDs of all the pages we're flushing */ /* flush from the tail forward, this saves a lot of shifting later on. */ @@ -2007,7 +1974,7 @@ static txnid_t mdbx_find_oldest(MDBX_txn *txn) { } /* Add a page to the txn's dirty list */ -static int __must_check_result mdbx_page_dirty(MDBX_txn *txn, MDBX_page *mp) { +static void mdbx_page_dirty(MDBX_txn *txn, MDBX_page *mp) { MDBX_ID2 mid; int rc, (*insert)(MDBX_ID2L, MDBX_ID2 *); @@ -2019,12 +1986,8 @@ static int __must_check_result mdbx_page_dirty(MDBX_txn *txn, MDBX_page *mp) { mid.mid = mp->mp_pgno; mid.mptr = mp; rc = insert(txn->mt_rw_dirtylist, &mid); - if (unlikely(rc != MDBX_SUCCESS)) { - txn->mt_flags |= MDBX_TXN_ERROR; - return rc; - } + mdbx_tassert(txn, rc == 0); txn->mt_dirtyroom--; - return MDBX_SUCCESS; } static int mdbx_mapresize(MDBX_env *env, const pgno_t size_pgno, @@ -2181,7 +2144,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, if (likely(flags & MDBX_ALLOC_GC)) { flags |= env->me_flags & (MDBX_COALESCE | MDBX_LIFORECLAIM); if (unlikely(mc->mc_flags & C_RECLAIMING)) { - /* If mc is updating the freeDB, then the befree-list cannot play + /* If mc is updating the freeDB, then the freelist cannot play * catch-up with itself by growing while trying to save it. */ flags &= ~(MDBX_ALLOC_GC | MDBX_ALLOC_KICK | MDBX_COALESCE | MDBX_LIFORECLAIM); @@ -2208,7 +2171,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, } } - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); pgno_t pgno, *repg_list = env->me_reclaimed_pglist; unsigned repg_pos = 0, repg_len = repg_list ? repg_list[0] : 0; txnid_t oldest = 0, last = 0; @@ -2228,7 +2191,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, /* Seek a big enough contiguous page range. * Prefer pages with lower pgno. */ - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (likely(flags & MDBX_ALLOC_CACHE) && repg_len > wanna_range && (!(flags & MDBX_COALESCE) || op == MDBX_FIRST)) { #if MDBX_PNL_ASCENDING @@ -2342,7 +2305,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, pgno_t *re_pnl = (pgno_t *)data.iov_base; mdbx_tassert(txn, re_pnl[0] == 0 || data.iov_len == (re_pnl[0] + 1) * sizeof(pgno_t)); - mdbx_tassert(txn, mdbx_pnl_check(re_pnl, false)); + mdbx_tassert(txn, mdbx_pnl_check(re_pnl)); repg_pos = re_pnl[0]; if (!repg_list) { if (unlikely(!(env->me_reclaimed_pglist = repg_list = @@ -2412,16 +2375,16 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, mdbx_info("refunded %" PRIaPGNO " pages: %" PRIaPGNO " -> %" PRIaPGNO, tail - txn->mt_next_pgno, tail, txn->mt_next_pgno); txn->mt_next_pgno = tail; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); } } /* Don't try to coalesce too much. */ - if (unlikely(repg_len > MDBX_LIST_MAX / 2)) + if (repg_len > MDBX_PNL_UM_SIZE / 2) break; if (flags & MDBX_COALESCE) { - if (repg_len /* current size */ >= env->me_maxgc_ov1page || - repg_pos /* prev size */ >= env->me_maxgc_ov1page / 2) + if (repg_len /* current size */ >= env->me_maxfree_1pg / 2 || + repg_pos /* prev size */ >= env->me_maxfree_1pg / 4) flags &= ~MDBX_COALESCE; } } @@ -2522,7 +2485,7 @@ static int mdbx_page_alloc(MDBX_cursor *mc, unsigned num, MDBX_page **mp, } fail: - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (mp) { *mp = NULL; txn->mt_flags |= MDBX_TXN_ERROR; @@ -2553,7 +2516,7 @@ done: repg_list[0] = repg_len -= num; for (unsigned i = repg_pos - num; i < repg_len;) repg_list[++i] = repg_list[++repg_pos]; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); } else { txn->mt_next_pgno = pgno + num; mdbx_assert(env, txn->mt_next_pgno <= txn->mt_end_pgno); @@ -2567,12 +2530,10 @@ done: np->mp_leaf2_ksize = 0; np->mp_flags = 0; np->mp_pages = num; - rc = mdbx_page_dirty(txn, np); - if (unlikely(rc != MDBX_SUCCESS)) - goto fail; + mdbx_page_dirty(txn, np); *mp = np; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); return MDBX_SUCCESS; } @@ -2607,8 +2568,7 @@ static void mdbx_page_copy(MDBX_page *dst, MDBX_page *src, unsigned psize) { * [in] mp the page being referenced. It must not be dirty. * [out] ret the writable page, if any. * ret is unchanged if mp wasn't spilled. */ -static int __must_check_result mdbx_page_unspill(MDBX_txn *txn, MDBX_page *mp, - MDBX_page **ret) { +static int mdbx_page_unspill(MDBX_txn *txn, MDBX_page *mp, MDBX_page **ret) { MDBX_env *env = txn->mt_env; const MDBX_txn *tx2; unsigned x; @@ -2647,10 +2607,7 @@ static int __must_check_result mdbx_page_unspill(MDBX_txn *txn, MDBX_page *mp, } /* otherwise, if belonging to a parent txn, the * page remains spilled until child commits */ - int rc = mdbx_page_dirty(txn, np); - if (unlikely(rc != MDBX_SUCCESS)) - return rc; - + mdbx_page_dirty(txn, np); np->mp_flags |= P_DIRTY; *ret = np; break; @@ -2712,26 +2669,23 @@ static int mdbx_page_touch(MDBX_cursor *mc) { " in the dirtylist[%d], expecting %p", dl[x].mptr, pgno, x, mp); mc->mc_flags &= ~(C_INITIALIZED | C_EOF); - rc = MDBX_PROBLEM; - goto fail; + txn->mt_flags |= MDBX_TXN_ERROR; + return MDBX_PROBLEM; } return MDBX_SUCCESS; } } mdbx_debug("clone db %d page %" PRIaPGNO, DDBI(mc), mp->mp_pgno); - mdbx_cassert(mc, dl[0].mid < MDBX_LIST_MAX); + mdbx_cassert(mc, dl[0].mid < MDBX_PNL_UM_MAX); /* No - copy it */ np = mdbx_page_malloc(txn, 1); - if (unlikely(!np)) { - rc = MDBX_ENOMEM; - goto fail; - } + if (unlikely(!np)) + return MDBX_ENOMEM; mid.mid = pgno; mid.mptr = np; rc = mdbx_mid2l_insert(dl, &mid); - if (unlikely(rc)) - goto fail; + mdbx_cassert(mc, rc == 0); } else { return MDBX_SUCCESS; } @@ -2967,6 +2921,7 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) { return MDBX_BAD_RSLOT; } else if (env->me_lck) { unsigned slot, nreaders; + const mdbx_pid_t pid = env->me_pid; const mdbx_tid_t tid = mdbx_thread_self(); mdbx_assert(env, env->me_lck->mti_magic_and_version == MDBX_LOCK_MAGIC); mdbx_assert(env, env->me_lck->mti_os_and_format == MDBX_LOCK_FORMAT); @@ -2976,13 +2931,13 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) { return rc; rc = MDBX_SUCCESS; - if (unlikely(env->me_live_reader != env->me_pid)) { + if (unlikely(env->me_live_reader != pid)) { rc = mdbx_rpid_set(env); if (unlikely(rc != MDBX_SUCCESS)) { mdbx_rdt_unlock(env); return rc; } - env->me_live_reader = env->me_pid; + env->me_live_reader = pid; } while (1) { @@ -3015,13 +2970,11 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) { env->me_lck->mti_numreaders = ++nreaders; if (env->me_close_readers < nreaders) env->me_close_readers = nreaders; - r->mr_pid = env->me_pid; + r->mr_pid = pid; mdbx_rdt_unlock(env); - if (likely(env->me_flags & MDBX_ENV_TXKEY)) { - assert(env->me_live_reader == env->me_pid); + if (likely(env->me_flags & MDBX_ENV_TXKEY)) mdbx_thread_rthc_set(env->me_txkey, r); - } } while (1) { @@ -3089,7 +3042,7 @@ static int mdbx_txn_renew0(MDBX_txn *txn, unsigned flags) { txn->mt_child = NULL; txn->mt_loose_pages = NULL; txn->mt_loose_count = 0; - txn->mt_dirtyroom = MDBX_LIST_MAX; + txn->mt_dirtyroom = MDBX_PNL_UM_MAX; txn->mt_rw_dirtylist = env->me_dirtylist; txn->mt_rw_dirtylist[0].mid = 0; txn->mt_befree_pages = env->me_free_pgs; @@ -3242,9 +3195,9 @@ int mdbx_txn_begin(MDBX_env *env, MDBX_txn *parent, unsigned flags, unsigned i; txn->mt_cursors = (MDBX_cursor **)(txn->mt_dbs + env->me_maxdbs); txn->mt_dbiseqs = parent->mt_dbiseqs; - txn->mt_rw_dirtylist = malloc(sizeof(MDBX_ID2) * (MDBX_LIST_MAX + 1)); + txn->mt_rw_dirtylist = malloc(sizeof(MDBX_ID2) * MDBX_PNL_UM_SIZE); if (!txn->mt_rw_dirtylist || - !(txn->mt_befree_pages = mdbx_pnl_alloc(MDBX_LIST_MAX))) { + !(txn->mt_befree_pages = mdbx_pnl_alloc(MDBX_PNL_UM_MAX))) { free(txn->mt_rw_dirtylist); free(txn); return MDBX_ENOMEM; @@ -3532,109 +3485,88 @@ static int mdbx_prep_backlog(MDBX_txn *txn, MDBX_cursor *mc) { return MDBX_SUCCESS; } -/* Cleanup reclaimed GC records, than save the befree-list as of this - * transaction to GC (aka freeDB). This recursive changes the reclaimed-list - * loose-list and befree-list. Keep trying until it stabilizes. */ -static int mdbx_update_gc(MDBX_txn *txn) { +/* Save the freelist as of this transaction to the freeDB. + * This changes the freelist. Keep trying until it stabilizes. */ +static int mdbx_freelist_save(MDBX_txn *txn) { /* env->me_reclaimed_pglist[] can grow and shrink during this call. - * env->me_last_reclaimed and txn->mt_befree_pages[] can only grow. - * Page numbers cannot disappear from txn->mt_befree_pages[]. */ - MDBX_env *const env = txn->mt_env; + * env->me_last_reclaimed and txn->mt_free_pages[] can only grow. + * Page numbers cannot disappear from txn->mt_free_pages[]. */ + MDBX_cursor mc; + MDBX_env *env = txn->mt_env; + int rc, more = 1; + txnid_t cleanup_reclaimed_id = 0, head_id = 0; + pgno_t befree_count = 0; + intptr_t head_room = 0, total_room = 0; + unsigned cleanup_reclaimed_pos = 0, refill_reclaimed_pos = 0; const bool lifo = (env->me_flags & MDBX_LIFORECLAIM) != 0; - MDBX_cursor mc; - int rc = mdbx_cursor_init(&mc, txn, FREE_DBI, NULL); + rc = mdbx_cursor_init(&mc, txn, FREE_DBI, NULL); if (unlikely(rc != MDBX_SUCCESS)) return rc; - const char *dbg_prefix_mode = lifo ? " lifo" : " fifo"; - mdbx_trace("\n>>> @%" PRIaTXN, txn->mt_txnid); - (void)dbg_prefix_mode; - unsigned befree_stored = 0, loop = 0; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); - -retry: - mdbx_trace(" >> restart"); - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); - unsigned placed = 0, cleaned_gc_slot = 0, reused_gc_slots = 0, - filled_gc_slot = ~0u; - txnid_t cleaned_gc_id = 0, head_gc_id = env->me_last_reclaimed - ? env->me_last_reclaimed - : ~(txnid_t)0; - - if (unlikely(/* paranoia */ ++loop > 42)) { - mdbx_error("too more loops %u, bailout", loop); - rc = MDBX_PROBLEM; - goto bailout; - } + /* MDBX_RESERVE cancels meminit in ovpage malloc (when no WRITEMAP) */ + const intptr_t clean_limit = + (env->me_flags & (MDBX_NOMEMINIT | MDBX_WRITEMAP)) ? SSIZE_MAX + : env->me_maxfree_1pg; + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); +again_on_freelist_change: + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); while (1) { - /* Come back here after each Put() in case befree-list changed */ + /* Come back here after each Put() in case freelist changed */ MDBX_val key, data; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (!lifo) { /* If using records from freeDB which we have not yet deleted, * now delete them and any we reserved for me_reclaimed_pglist. */ - while (cleaned_gc_id < env->me_last_reclaimed) { + while (cleanup_reclaimed_id < env->me_last_reclaimed) { rc = mdbx_cursor_first(&mc, &key, NULL); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; rc = mdbx_prep_backlog(txn, &mc); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; - cleaned_gc_id = head_gc_id = *(txnid_t *)key.iov_base; - mdbx_tassert(txn, cleaned_gc_id < *env->me_oldest); - mdbx_tassert(txn, cleaned_gc_id <= env->me_last_reclaimed); + cleanup_reclaimed_id = head_id = *(txnid_t *)key.iov_base; + total_room = head_room = 0; + more = 1; + mdbx_tassert(txn, cleanup_reclaimed_id <= env->me_last_reclaimed); mc.mc_flags |= C_RECLAIMING; - mdbx_trace("%s.cleanup-reclaimed-id %" PRIaTXN, dbg_prefix_mode, - cleaned_gc_id); rc = mdbx_cursor_del(&mc, 0); mc.mc_flags ^= C_RECLAIMING; - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; - placed = 0; } - } else if (txn->mt_lifo_reclaimed && - cleaned_gc_slot < txn->mt_lifo_reclaimed[0]) { + } else if (txn->mt_lifo_reclaimed) { /* LY: cleanup reclaimed records. */ - do { - cleaned_gc_id = txn->mt_lifo_reclaimed[++cleaned_gc_slot]; - assert(cleaned_gc_slot > 0 && cleaned_gc_id < *env->me_oldest); - head_gc_id = (head_gc_id > cleaned_gc_id) ? cleaned_gc_id : head_gc_id; - key.iov_base = &cleaned_gc_id; - key.iov_len = sizeof(cleaned_gc_id); + while (cleanup_reclaimed_pos < txn->mt_lifo_reclaimed[0]) { + cleanup_reclaimed_id = txn->mt_lifo_reclaimed[++cleanup_reclaimed_pos]; + key.iov_base = &cleanup_reclaimed_id; + key.iov_len = sizeof(cleanup_reclaimed_id); rc = mdbx_cursor_get(&mc, &key, NULL, MDBX_SET); - if (rc == MDBX_NOTFOUND) - continue; - if (unlikely(rc != MDBX_SUCCESS)) - goto bailout; - rc = mdbx_prep_backlog(txn, &mc); - if (unlikely(rc != MDBX_SUCCESS)) - goto bailout; - mdbx_tassert(txn, cleaned_gc_id < *env->me_oldest); - mc.mc_flags |= C_RECLAIMING; - mdbx_trace("%s.cleanup-reclaimed-id [%u]%" PRIaTXN, dbg_prefix_mode, - cleaned_gc_slot, cleaned_gc_id); - rc = mdbx_cursor_del(&mc, 0); - mc.mc_flags ^= C_RECLAIMING; - if (unlikely(rc != MDBX_SUCCESS)) - goto bailout; - } while (cleaned_gc_slot < txn->mt_lifo_reclaimed[0]); - mdbx_txl_sort(txn->mt_lifo_reclaimed); - assert(txn->mt_lifo_reclaimed[0] == 0 || - txn->mt_lifo_reclaimed[txn->mt_lifo_reclaimed[0]] == head_gc_id); + if (likely(rc != MDBX_NOTFOUND)) { + if (unlikely(rc)) + goto bailout; + rc = mdbx_prep_backlog(txn, &mc); + if (unlikely(rc)) + goto bailout; + mc.mc_flags |= C_RECLAIMING; + rc = mdbx_cursor_del(&mc, 0); + mc.mc_flags ^= C_RECLAIMING; + if (unlikely(rc)) + goto bailout; + } + } } - // handle loose pages - put ones into the reclaimed- or befree-list - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (txn->mt_loose_pages) { /* Return loose page numbers to me_reclaimed_pglist, * though usually none are left at this point. * The pages themselves remain in dirtylist. */ if (unlikely(!env->me_reclaimed_pglist) && !(lifo && env->me_last_reclaimed > 1)) { - /* Put loose page numbers in mt_befree_pages, + /* Put loose page numbers in mt_free_pages, * since unable to return them to me_reclaimed_pglist. */ if (unlikely((rc = mdbx_pnl_need(&txn->mt_befree_pages, txn->mt_loose_count)) != 0)) @@ -3643,9 +3575,8 @@ retry: mdbx_pnl_xappend(txn->mt_befree_pages, mp->mp_pgno); } else { /* Room for loose pages + temp PNL with same */ - rc = mdbx_pnl_need(&env->me_reclaimed_pglist, - 2 * txn->mt_loose_count + 1); - if (unlikely(rc != MDBX_SUCCESS)) + if ((rc = mdbx_pnl_need(&env->me_reclaimed_pglist, + 2 * txn->mt_loose_count + 1)) != 0) goto bailout; MDBX_PNL loose = env->me_reclaimed_pglist + MDBX_PNL_ALLOCLEN(env->me_reclaimed_pglist) - @@ -3681,9 +3612,9 @@ retry: txn->mt_loose_count = 0; } - // handle reclaimed pages - return suitable into unallocated space - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (env->me_reclaimed_pglist) { + /* Refund suitable pages into "unallocated" space */ pgno_t tail = txn->mt_next_pgno; pgno_t *const begin = env->me_reclaimed_pglist + 1; pgno_t *const end = begin + env->me_reclaimed_pglist[0]; @@ -3709,78 +3640,73 @@ retry: mdbx_info("refunded %" PRIaPGNO " pages: %" PRIaPGNO " -> %" PRIaPGNO, tail - txn->mt_next_pgno, tail, txn->mt_next_pgno); txn->mt_next_pgno = tail; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); } } - // handle befree-list - store ones into singe gc-record - if (befree_stored < txn->mt_befree_pages[0]) { - if (unlikely(!befree_stored)) { - /* Make sure last page of freeDB is touched and on befree-list */ + /* Save the PNL of pages freed by this txn, to a single record */ + if (befree_count < txn->mt_befree_pages[0]) { + if (unlikely(!befree_count)) { + /* Make sure last page of freeDB is touched and on freelist */ rc = mdbx_page_search(&mc, NULL, MDBX_PS_LAST | MDBX_PS_MODIFY); - if (unlikely(rc != MDBX_SUCCESS && rc != MDBX_NOTFOUND)) + if (unlikely(rc && rc != MDBX_NOTFOUND)) goto bailout; } + pgno_t *befree_pages = txn->mt_befree_pages; /* Write to last page of freeDB */ key.iov_len = sizeof(txn->mt_txnid); key.iov_base = &txn->mt_txnid; do { - data.iov_len = MDBX_PNL_SIZEOF(txn->mt_befree_pages); + befree_count = befree_pages[0]; + data.iov_len = MDBX_PNL_SIZEOF(befree_pages); rc = mdbx_cursor_put(&mc, &key, &data, MDBX_RESERVE); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; - /* Retry if mt_befree_pages[] grew during the Put() */ - } while (data.iov_len < MDBX_PNL_SIZEOF(txn->mt_befree_pages)); + /* Retry if mt_free_pages[] grew during the Put() */ + befree_pages = txn->mt_befree_pages; + } while (befree_count < befree_pages[0]); - befree_stored = (unsigned)txn->mt_befree_pages[0]; - mdbx_pnl_sort(txn->mt_befree_pages); - memcpy(data.iov_base, txn->mt_befree_pages, data.iov_len); - - mdbx_trace("%s.put-befree #%u @ %" PRIaTXN, dbg_prefix_mode, - befree_stored, txn->mt_txnid); + mdbx_pnl_sort(befree_pages); + memcpy(data.iov_base, befree_pages, data.iov_len); if (mdbx_debug_enabled(MDBX_DBG_EXTRA)) { - unsigned i = befree_stored; + unsigned i = (unsigned)befree_pages[0]; mdbx_debug_extra("PNL write txn %" PRIaTXN " root %" PRIaPGNO " num %u, PNL", txn->mt_txnid, txn->mt_dbs[FREE_DBI].md_root, i); for (; i; i--) - mdbx_debug_extra_print(" %" PRIaPGNO "", txn->mt_befree_pages[i]); + mdbx_debug_extra_print(" %" PRIaPGNO "", befree_pages[i]); mdbx_debug_extra_print("\n"); } continue; } - // handle reclaimed and loost pages - merge and store both into gc - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); - mdbx_tassert(txn, txn->mt_loose_count == 0); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); + const intptr_t rpl_len = + (env->me_reclaimed_pglist ? env->me_reclaimed_pglist[0] : 0) + + txn->mt_loose_count; + if (rpl_len && refill_reclaimed_pos == 0) + refill_reclaimed_pos = 1; - mdbx_trace(" >> reserving"); - const unsigned amount = - env->me_reclaimed_pglist ? env->me_reclaimed_pglist[0] : 0; - const unsigned left = amount - placed; - mdbx_trace("%s: amount %u, placed %d, left %d", dbg_prefix_mode, amount, - placed, (int)left); - if (0 >= (int)left) - break; + /* Reserve records for me_reclaimed_pglist[]. Split it if multi-page, + * to avoid searching freeDB for a page range. Use keys in + * range [1,me_last_reclaimed]: Smaller than txnid of oldest reader. */ + if (total_room >= rpl_len) { + if (total_room == rpl_len || --more < 0) + break; + } else if (head_room >= (intptr_t)env->me_maxfree_1pg && head_id > 1) { + /* Keep current record (overflow page), add a new one */ + head_id--; + refill_reclaimed_pos++; + head_room = 0; + } - txnid_t reservation_gc_id; if (lifo) { - assert(txn->mt_lifo_reclaimed != NULL); - if (unlikely(!txn->mt_lifo_reclaimed)) { - txn->mt_lifo_reclaimed = mdbx_txl_alloc(); - if (unlikely(!txn->mt_lifo_reclaimed)) { - rc = MDBX_ENOMEM; - goto bailout; - } - } - - if (head_gc_id > 1 && txn->mt_lifo_reclaimed[0] < INT16_MAX && - left > ((unsigned)txn->mt_lifo_reclaimed[0] - reused_gc_slots) * - env->me_maxgc_ov1page) { + if (refill_reclaimed_pos > + (txn->mt_lifo_reclaimed ? txn->mt_lifo_reclaimed[0] : 0)) { /* LY: need just a txn-id for save page list. */ rc = mdbx_page_alloc(&mc, 0, NULL, MDBX_ALLOC_GC | MDBX_ALLOC_KICK); - if (likely(rc == MDBX_SUCCESS)) + if (likely(rc == 0)) /* LY: ok, reclaimed from freedb. */ continue; if (unlikely(rc != MDBX_NOTFOUND)) @@ -3788,240 +3714,160 @@ retry: goto bailout; /* LY: freedb is empty, will look any free txn-id in high2low order. */ - do { - --head_gc_id; - assert(txn->mt_lifo_reclaimed[txn->mt_lifo_reclaimed[0]] > - head_gc_id); - rc = mdbx_txl_append(&txn->mt_lifo_reclaimed, head_gc_id); - if (unlikely(rc != MDBX_SUCCESS)) - goto bailout; - cleaned_gc_slot += 1 /* mark GC cleanup is not needed. */; - - mdbx_trace("%s: append @%" PRIaTXN - " to lifo-reclaimed, cleaned-gc-slot = %u", - dbg_prefix_mode, head_gc_id, cleaned_gc_slot); - } while (head_gc_id > 1 && txn->mt_lifo_reclaimed[0] < INT16_MAX && - left > - ((unsigned)txn->mt_lifo_reclaimed[0] - reused_gc_slots) * - env->me_maxgc_ov1page); - } - - if ((unsigned)txn->mt_lifo_reclaimed[0] <= reused_gc_slots) { - mdbx_notice("** restart: reserve depleted (reused_gc_slot %u >= " - "lifo_reclaimed %u" PRIaTXN, - reused_gc_slots, (unsigned)txn->mt_lifo_reclaimed[0]); - goto retry; - } - const unsigned i = (unsigned)txn->mt_lifo_reclaimed[0] - reused_gc_slots; - assert(i > 0 && i <= txn->mt_lifo_reclaimed[0]); - reservation_gc_id = txn->mt_lifo_reclaimed[i]; - mdbx_trace("%s: take @%" PRIaTXN " from lifo-reclaimed[%u]", - dbg_prefix_mode, reservation_gc_id, i); - } else { - mdbx_tassert(txn, txn->mt_lifo_reclaimed == NULL); - reservation_gc_id = head_gc_id--; - mdbx_trace("%s: take @%" PRIaTXN " from head-gc-id", dbg_prefix_mode, - reservation_gc_id); - } - - ++reused_gc_slots; - assert(txn->mt_lifo_reclaimed == NULL || - txn->mt_lifo_reclaimed[0] <= INT16_MAX); - unsigned chunk = left; - if (unlikely(chunk > env->me_maxgc_ov1page)) { - const unsigned avail_gs_slots = - lifo ? (unsigned)txn->mt_lifo_reclaimed[0] - reused_gc_slots - : (head_gc_id < INT16_MAX) ? (unsigned)head_gc_id : INT16_MAX; - if (avail_gs_slots > 1) { - if (chunk < env->me_maxgc_ov1page * 2) - chunk /= 2; - else { - const unsigned threshold = env->me_maxgc_ov1page * avail_gs_slots; - if (left < threshold) - chunk = env->me_maxgc_ov1page; - else { - const unsigned tail = left - threshold + env->me_maxgc_ov1page + 1; - unsigned span = 1; - unsigned avail = (unsigned)((pgno2bytes(env, span) - PAGEHDRSZ) / - sizeof(pgno_t)) /*- 1 + span */; - if (tail > avail) { - for (unsigned i = env->me_reclaimed_pglist[0] - span; i > 0; - --i) { - if (MDBX_PNL_ASCENDING - ? (env->me_reclaimed_pglist[i] + span) - : (env->me_reclaimed_pglist[i] - span) == - env->me_reclaimed_pglist[i + span]) { - span += 1; - avail = (unsigned)((pgno2bytes(env, span) - PAGEHDRSZ) / - sizeof(pgno_t)) - - 1 + span; - if (avail >= tail) - break; - } - } - } + if (unlikely(env->me_last_reclaimed < 1)) { + /* LY: not any txn in the past of freedb. */ + rc = MDBX_MAP_FULL; + goto bailout; + } - chunk = (avail >= tail) - ? tail - span - : (avail_gs_slots > 3 && reused_gc_slots < 42) - ? avail - span - : tail; + if (unlikely(!txn->mt_lifo_reclaimed)) { + txn->mt_lifo_reclaimed = mdbx_txl_alloc(); + if (unlikely(!txn->mt_lifo_reclaimed)) { + rc = MDBX_ENOMEM; + goto bailout; } } + /* LY: append the list. */ + rc = mdbx_txl_append(&txn->mt_lifo_reclaimed, + env->me_last_reclaimed - 1); + if (unlikely(rc)) + goto bailout; + --env->me_last_reclaimed; + /* LY: note that freeDB cleanup is not needed. */ + ++cleanup_reclaimed_pos; } + mdbx_tassert(txn, txn->mt_lifo_reclaimed != NULL); + head_id = txn->mt_lifo_reclaimed[refill_reclaimed_pos]; + } else { + mdbx_tassert(txn, txn->mt_lifo_reclaimed == NULL); } - assert(chunk > 0); - - mdbx_trace("%s: head_gc_id %" PRIaTXN ", reused_gc_slot %u, reservation-id " - "%" PRIaTXN, - dbg_prefix_mode, head_gc_id, reused_gc_slots, reservation_gc_id); - mdbx_trace("%s: chunk %u, gc-per-ovpage %u", dbg_prefix_mode, chunk, - env->me_maxgc_ov1page); - - mdbx_tassert(txn, reservation_gc_id < *env->me_oldest); - if (unlikely(reservation_gc_id < 1 || - reservation_gc_id >= *env->me_oldest)) { - /* LY: not any txn in the past of freedb. */ - rc = MDBX_PROBLEM; - goto bailout; + /* (Re)write {key = head_id, PNL length = head_room} */ + total_room -= head_room; + head_room = rpl_len - total_room; + if (head_room > (intptr_t)env->me_maxfree_1pg && head_id > 1) { + /* Overflow multi-page for part of me_reclaimed_pglist */ + head_room /= (head_id < INT16_MAX) ? (pgno_t)head_id + : INT16_MAX; /* amortize page sizes */ + head_room += env->me_maxfree_1pg - head_room % (env->me_maxfree_1pg + 1); + } else if (head_room < 0) { + /* Rare case, not bothering to delete this record */ + head_room = 0; + continue; } - - key.iov_len = sizeof(reservation_gc_id); - key.iov_base = &reservation_gc_id; - data.iov_len = (chunk + 1) * sizeof(pgno_t); - mdbx_trace("%s.reserve: %u [%u...%u] @%" PRIaTXN, dbg_prefix_mode, chunk, - placed + 1, placed + chunk + 1, reservation_gc_id); - rc = mdbx_cursor_put(&mc, &key, &data, MDBX_RESERVE | MDBX_NOOVERWRITE); - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); - if (unlikely(rc != MDBX_SUCCESS)) + key.iov_len = sizeof(head_id); + key.iov_base = &head_id; + data.iov_len = (head_room + 1) * sizeof(pgno_t); + rc = mdbx_cursor_put(&mc, &key, &data, MDBX_RESERVE); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); + if (unlikely(rc)) goto bailout; /* PNL is initially empty, zero out at least the length */ - memset(data.iov_base, 0, sizeof(pgno_t)); - placed += chunk; - mdbx_trace("%s.placed %u (+%u), continue", dbg_prefix_mode, placed, chunk); + pgno_t *pgs = (pgno_t *)data.iov_base; + intptr_t i = head_room > clean_limit ? head_room : 0; + do { + pgs[i] = 0; + } while (--i >= 0); + total_room += head_room; continue; } mdbx_tassert(txn, - cleaned_gc_slot == + cleanup_reclaimed_pos == (txn->mt_lifo_reclaimed ? txn->mt_lifo_reclaimed[0] : 0)); - mdbx_trace(" >> filling"); - /* Fill in the reserved records */ - filled_gc_slot = txn->mt_lifo_reclaimed - ? (unsigned)txn->mt_lifo_reclaimed[0] - reused_gc_slots - : reused_gc_slots; + /* Fill in the reserved me_reclaimed_pglist records */ rc = MDBX_SUCCESS; - mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist, true)); + mdbx_tassert(txn, mdbx_pnl_check(env->me_reclaimed_pglist)); if (env->me_reclaimed_pglist && env->me_reclaimed_pglist[0]) { MDBX_val key, data; key.iov_len = data.iov_len = 0; /* avoid MSVC warning */ key.iov_base = data.iov_base = NULL; - unsigned left = env->me_reclaimed_pglist[0]; - pgno_t *end = env->me_reclaimed_pglist + left; - if (txn->mt_lifo_reclaimed == nullptr) { + size_t rpl_left = env->me_reclaimed_pglist[0]; + pgno_t *rpl_end = env->me_reclaimed_pglist + rpl_left; + if (txn->mt_lifo_reclaimed == 0) { mdbx_tassert(txn, lifo == 0); rc = mdbx_cursor_first(&mc, &key, &data); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; } else { mdbx_tassert(txn, lifo != 0); } while (1) { - txnid_t fill_gc_id; - mdbx_trace("%s: left %u of %u", dbg_prefix_mode, left, - (unsigned)env->me_reclaimed_pglist[0]); - if (txn->mt_lifo_reclaimed == nullptr) { + txnid_t id; + if (txn->mt_lifo_reclaimed == 0) { mdbx_tassert(txn, lifo == 0); - fill_gc_id = *(txnid_t *)key.iov_base; - if (filled_gc_slot-- == 0 || fill_gc_id > env->me_last_reclaimed) { - mdbx_notice( - "** restart: reserve depleted (filled_slot %u, fill_id %" PRIaTXN - " > last_reclaimed %" PRIaTXN, - filled_gc_slot, fill_gc_id, env->me_last_reclaimed); - goto retry; - } + id = *(txnid_t *)key.iov_base; + mdbx_tassert(txn, id <= env->me_last_reclaimed); } else { mdbx_tassert(txn, lifo != 0); - if (++filled_gc_slot > (unsigned)txn->mt_lifo_reclaimed[0]) { - mdbx_notice("** restart: reserve depleted (filled_gc_slot %u > " - "lifo_reclaimed %u" PRIaTXN, - filled_gc_slot, (unsigned)txn->mt_lifo_reclaimed[0]); - goto retry; - } - fill_gc_id = txn->mt_lifo_reclaimed[filled_gc_slot]; - mdbx_trace("%s.seek-reservaton @%" PRIaTXN " at lifo_reclaimed[%u]", - dbg_prefix_mode, fill_gc_id, filled_gc_slot); - key.iov_base = &fill_gc_id; - key.iov_len = sizeof(fill_gc_id); + mdbx_tassert(txn, + refill_reclaimed_pos > 0 && + refill_reclaimed_pos <= txn->mt_lifo_reclaimed[0]); + id = txn->mt_lifo_reclaimed[refill_reclaimed_pos--]; + key.iov_base = &id; + key.iov_len = sizeof(id); rc = mdbx_cursor_get(&mc, &key, &data, MDBX_SET); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; } mdbx_tassert( - txn, cleaned_gc_slot == + txn, cleanup_reclaimed_pos == (txn->mt_lifo_reclaimed ? txn->mt_lifo_reclaimed[0] : 0)); mdbx_tassert(txn, data.iov_len >= sizeof(pgno_t) * 2); - const size_t space = (data.iov_len / sizeof(pgno_t)) - 1; - const unsigned chunk = (space > left) ? left : (unsigned)space; - data.iov_len = (chunk + 1) * sizeof(pgno_t); - mdbx_tassert(txn, fill_gc_id > 0 && fill_gc_id < *env->me_oldest); - key.iov_base = &fill_gc_id; - key.iov_len = sizeof(fill_gc_id); - - end -= chunk; - data.iov_base = end; - pgno_t save = end[0]; - end[0] = (pgno_t)chunk; - mdbx_tassert(txn, mdbx_pnl_check(end, false)); + size_t chunk_len = (data.iov_len / sizeof(pgno_t)) - 1; + if (chunk_len > rpl_left) + chunk_len = rpl_left; + data.iov_len = (chunk_len + 1) * sizeof(pgno_t); + key.iov_base = &id; + key.iov_len = sizeof(id); + + rpl_end -= chunk_len; + data.iov_base = rpl_end; + pgno_t save = rpl_end[0]; + rpl_end[0] = (pgno_t)chunk_len; + mdbx_tassert(txn, mdbx_pnl_check(rpl_end)); mc.mc_flags |= C_RECLAIMING; rc = mdbx_cursor_put(&mc, &key, &data, MDBX_CURRENT); mc.mc_flags ^= C_RECLAIMING; - mdbx_tassert(txn, mdbx_pnl_check(end, false)); + mdbx_tassert(txn, mdbx_pnl_check(rpl_end)); mdbx_tassert( - txn, cleaned_gc_slot == + txn, cleanup_reclaimed_pos == (txn->mt_lifo_reclaimed ? txn->mt_lifo_reclaimed[0] : 0)); - pgno_t *from = end + 1, *to = end + end[0]; - mdbx_trace("%s.fill: %u [ %u:%" PRIaPGNO "...%u:%" PRIaPGNO - "] @%" PRIaTXN, - dbg_prefix_mode, (unsigned)end[0], - (unsigned)(from - env->me_reclaimed_pglist), *from, - (unsigned)(to - env->me_reclaimed_pglist), *to, fill_gc_id); - end[0] = save; - if (unlikely(rc != MDBX_SUCCESS)) + rpl_end[0] = save; + if (unlikely(rc)) goto bailout; - left -= chunk; - if (left == 0) { - rc = MDBX_SUCCESS; + rpl_left -= chunk_len; + if (rpl_left == 0) break; - } if (!lifo) { rc = mdbx_cursor_next(&mc, &key, &data, MDBX_NEXT); - if (unlikely(rc != MDBX_SUCCESS)) + if (unlikely(rc)) goto bailout; } } } - mdbx_tassert(txn, rc == MDBX_SUCCESS); - if (unlikely( - filled_gc_slot != - (txn->mt_lifo_reclaimed ? (unsigned)txn->mt_lifo_reclaimed[0] : 0))) { - mdbx_notice("** restart: reserve excess (filled-slot %u)", filled_gc_slot); - goto retry; - } - bailout: if (txn->mt_lifo_reclaimed) { - mdbx_tassert(txn, rc != MDBX_SUCCESS || - cleaned_gc_slot == txn->mt_lifo_reclaimed[0]); + mdbx_tassert(txn, rc || cleanup_reclaimed_pos == txn->mt_lifo_reclaimed[0]); + if (rc == MDBX_SUCCESS && + cleanup_reclaimed_pos != txn->mt_lifo_reclaimed[0]) { + mdbx_tassert(txn, cleanup_reclaimed_pos < txn->mt_lifo_reclaimed[0]); + /* LY: zeroed cleanup_idx to force cleanup + * and refill created freeDB records. */ + cleanup_reclaimed_pos = 0; + /* LY: restart filling */ + total_room = head_room = refill_reclaimed_pos = 0; + more = 1; + goto again_on_freelist_change; + } txn->mt_lifo_reclaimed[0] = 0; if (txn != env->me_txn0) { mdbx_txl_free(txn->mt_lifo_reclaimed); @@ -4029,7 +3875,6 @@ bailout: } } - mdbx_trace("<<< rc = %d", rc); return rc; } @@ -4152,7 +3997,7 @@ static __cold bool mdbx_txn_import_dbi(MDBX_txn *txn, MDBX_dbi dbi) { (env->me_dbflags[i] & MDBX_VALID)) { txn->mt_dbs[i].md_flags = env->me_dbflags[i] & PERSISTENT_FLAGS; txn->mt_dbflags[i] = DB_VALID | DB_USRVALID | DB_STALE; - mdbx_tassert(txn, txn->mt_dbxs[i].md_cmp != NULL); + assert(txn->mt_dbxs[i].md_cmp != NULL); } } txn->mt_numdbs = snap_numdbs; @@ -4313,7 +4158,7 @@ int mdbx_txn_commit(MDBX_txn *txn) { } } } else { /* Simplify the above for single-ancestor case */ - len = MDBX_LIST_MAX - txn->mt_dirtyroom; + len = MDBX_PNL_UM_MAX - txn->mt_dirtyroom; } /* Merge our dirty list with parent's */ y = src[0].mid; @@ -4396,7 +4241,7 @@ int mdbx_txn_commit(MDBX_txn *txn) { } } - rc = mdbx_update_gc(txn); + rc = mdbx_freelist_save(txn); if (unlikely(rc != MDBX_SUCCESS)) goto fail; @@ -5002,8 +4847,19 @@ int __cold mdbx_env_get_maxkeysize(MDBX_env *env) { #define mdbx_maxkey(nodemax) ((nodemax) - (NODESIZE + sizeof(MDBX_db))) -#define mdbx_maxgc_ov1page(pagesize) \ - (((pagesize)-PAGEHDRSZ) / sizeof(pgno_t) - 1) +#define mdbx_maxfree1pg(pagesize) (((pagesize)-PAGEHDRSZ) / sizeof(pgno_t) - 1) + +int mdbx_get_maxkeysize(size_t pagesize) { + if (pagesize == 0) + pagesize = mdbx_syspagesize(); + + intptr_t nodemax = mdbx_nodemax(pagesize); + if (nodemax < 0) + return -MDBX_EINVAL; + + intptr_t maxkey = mdbx_maxkey(nodemax); + return (maxkey > 0 && maxkey < INT_MAX) ? (int)maxkey : -MDBX_EINVAL; +} static void __cold mdbx_setup_pagesize(MDBX_env *env, const size_t pagesize) { STATIC_ASSERT(SSIZE_MAX > MAX_MAPSIZE); @@ -5013,11 +4869,11 @@ static void __cold mdbx_setup_pagesize(MDBX_env *env, const size_t pagesize) { mdbx_ensure(env, pagesize <= MAX_PAGESIZE); env->me_psize = (unsigned)pagesize; - STATIC_ASSERT(mdbx_maxgc_ov1page(MIN_PAGESIZE) > 42); - STATIC_ASSERT(mdbx_maxgc_ov1page(MAX_PAGESIZE) < MDBX_LIST_MAX); - const intptr_t maxgc_ov1page = (pagesize - PAGEHDRSZ) / sizeof(pgno_t) - 1; - mdbx_ensure(env, maxgc_ov1page > 42 && maxgc_ov1page < MDBX_LIST_MAX); - env->me_maxgc_ov1page = (unsigned)maxgc_ov1page; + STATIC_ASSERT(mdbx_maxfree1pg(MIN_PAGESIZE) > 42); + STATIC_ASSERT(mdbx_maxfree1pg(MAX_PAGESIZE) < MDBX_PNL_DB_MAX); + const intptr_t maxfree_1pg = (pagesize - PAGEHDRSZ) / sizeof(pgno_t) - 1; + mdbx_ensure(env, maxfree_1pg > 42 && maxfree_1pg < MDBX_PNL_DB_MAX); + env->me_maxfree_1pg = (unsigned)maxfree_1pg; STATIC_ASSERT(mdbx_nodemax(MIN_PAGESIZE) > 42); STATIC_ASSERT(mdbx_nodemax(MAX_PAGESIZE) < UINT16_MAX); @@ -5929,8 +5785,8 @@ int __cold mdbx_env_open(MDBX_env *env, const char *path, unsigned flags, flags &= ~(MDBX_WRITEMAP | MDBX_MAPASYNC | MDBX_NOSYNC | MDBX_NOMETASYNC | MDBX_COALESCE | MDBX_LIFORECLAIM | MDBX_NOMEMINIT); } else { - if (!((env->me_free_pgs = mdbx_pnl_alloc(MDBX_LIST_MAX)) && - (env->me_dirtylist = calloc(MDBX_LIST_MAX + 1, sizeof(MDBX_ID2))))) + if (!((env->me_free_pgs = mdbx_pnl_alloc(MDBX_PNL_UM_MAX)) && + (env->me_dirtylist = calloc(MDBX_PNL_UM_SIZE, sizeof(MDBX_ID2))))) rc = MDBX_ENOMEM; } @@ -6089,8 +5945,6 @@ static void __cold mdbx_env_close0(MDBX_env *env) { if (env->me_flags & MDBX_ENV_TXKEY) mdbx_rthc_remove(env->me_txkey); - if (env->me_live_reader) - (void)mdbx_rpid_clear(env); if (env->me_map) { mdbx_munmap(&env->me_dxb_mmap); @@ -6498,14 +6352,9 @@ static int mdbx_page_get(MDBX_cursor *mc, pgno_t pgno, MDBX_page **ret, mapped: p = pgno2page(env, pgno); + /* TODO: check p->mp_validator here */ done: - if ((p->mp_flags & P_OVERFLOW) == 0 && - unlikely(p->mp_upper < p->mp_lower || - PAGEHDRSZ + p->mp_upper > env->me_psize)) - return MDBX_CORRUPTED; - /* TODO: more checks here, including p->mp_validator */ - *ret = p; if (lvl) *lvl = level; @@ -7643,7 +7492,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, DVAL((flags & MDBX_RESERVE) ? nullptr : data), data->iov_len); int dupdata_flag = 0; - if ((flags & MDBX_CURRENT) != 0 && (mc->mc_flags & C_SUB) == 0) { + if (flags & MDBX_CURRENT) { /* Опция MDBX_CURRENT означает, что запрошено обновление текущей записи, * на которой сейчас стоит курсор. Проверяем что переданный ключ совпадает * со значением в текущей позиции курсора. @@ -7864,7 +7713,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, offset *= 4; /* space for 4 more */ break; } - /* FALLTHRU: Big enough MDBX_DUPFIXED sub-page */ + /* FALLTHRU: Big enough MDBX_DUPFIXaED sub-page */ __fallthrough; case MDBX_CURRENT | MDBX_NODUPDATA: case MDBX_CURRENT: @@ -7951,8 +7800,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, ovpages = omp->mp_pages; /* Is the ov page large enough? */ - if (ovpages == - /* LY: add configuragle theshold to keep reserve space */ dpages) { + if (ovpages >= dpages) { if (!(omp->mp_flags & P_DIRTY) && (level || (env->me_flags & MDBX_WRITEMAP))) { rc = mdbx_page_unspill(mc->mc_txn, omp, &omp); @@ -7975,10 +7823,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, id2.mptr = np; /* Note - this page is already counted in parent's dirtyroom */ rc2 = mdbx_mid2l_insert(mc->mc_txn->mt_rw_dirtylist, &id2); - if (unlikely(rc2 != MDBX_SUCCESS)) { - rc = rc2; - goto fail; - } + mdbx_cassert(mc, rc2 == 0); /* Currently we make the page look as with put() in the * parent txn, in case the user peeks at MDBX_RESERVEd @@ -8015,6 +7860,8 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, memcpy(olddata.iov_base, data->iov_base, data->iov_len); else { mdbx_cassert(mc, NUMKEYS(mc->mc_pg[mc->mc_top]) == 1); + mdbx_cassert(mc, mc->mc_pg[mc->mc_top]->mp_upper == + mc->mc_pg[mc->mc_top]->mp_lower); mdbx_cassert(mc, IS_LEAF(mc->mc_pg[mc->mc_top]) && !IS_LEAF2(mc->mc_pg[mc->mc_top])); mdbx_cassert(mc, NODEDSZ(leaf) == 0); @@ -8022,7 +7869,7 @@ int mdbx_cursor_put(MDBX_cursor *mc, MDBX_val *key, MDBX_val *data, mdbx_cassert(mc, key->iov_len < UINT16_MAX); leaf->mn_ksize = (uint16_t)key->iov_len; memcpy(NODEKEY(leaf), key->iov_base, key->iov_len); - assert((char *)NODEKEY(leaf) + NODEDSZ(leaf) < + assert((char *)NODEDATA(leaf) + NODEDSZ(leaf) < (char *)(mc->mc_pg[mc->mc_top]) + env->me_psize); goto fix_parent; } @@ -8167,7 +8014,6 @@ new_sub: /* should not happen, we deleted that item */ rc = MDBX_PROBLEM; } -fail: mc->mc_txn->mt_flags |= MDBX_TXN_ERROR; return rc; } @@ -11068,10 +10914,10 @@ int mdbx_dbi_open_ex(MDBX_txn *txn, const char *table_name, unsigned user_flags, } unsigned dbflag = DB_FRESH | DB_VALID | DB_USRVALID; - MDBX_db db_dummy; if (unlikely(rc)) { /* MDBX_NOTFOUND and MDBX_CREATE: Create new DB */ assert(rc == MDBX_NOTFOUND); + MDBX_db db_dummy; memset(&db_dummy, 0, sizeof(db_dummy)); db_dummy.md_root = P_INVALID; db_dummy.md_flags = user_flags & PERSISTENT_FLAGS; @@ -12384,58 +12230,6 @@ int mdbx_dbi_sequence(MDBX_txn *txn, MDBX_dbi dbi, uint64_t *result, } /*----------------------------------------------------------------------------*/ - -__cold intptr_t mdbx_limits_keysize_max(intptr_t pagesize) { - if (pagesize < 1) - pagesize = (intptr_t)mdbx_syspagesize(); - else if (unlikely(pagesize < (intptr_t)MIN_PAGESIZE || - pagesize > (intptr_t)MAX_PAGESIZE || - !mdbx_is_power2((size_t)pagesize))) - return -MDBX_EINVAL; - - return mdbx_maxkey(mdbx_nodemax(pagesize)); -} - -__cold int mdbx_limits_pgsize_min(void) { return MIN_PAGESIZE; } - -__cold int mdbx_limits_pgsize_max(void) { return MAX_PAGESIZE; } - -__cold intptr_t mdbx_limits_dbsize_min(intptr_t pagesize) { - if (pagesize < 1) - pagesize = (intptr_t)mdbx_syspagesize(); - else if (unlikely(pagesize < (intptr_t)MIN_PAGESIZE || - pagesize > (intptr_t)MAX_PAGESIZE || - !mdbx_is_power2((size_t)pagesize))) - return -MDBX_EINVAL; - - return MIN_PAGENO * pagesize; -} - -__cold intptr_t mdbx_limits_dbsize_max(intptr_t pagesize) { - if (pagesize < 1) - pagesize = (intptr_t)mdbx_syspagesize(); - else if (unlikely(pagesize < (intptr_t)MIN_PAGESIZE || - pagesize > (intptr_t)MAX_PAGESIZE || - !mdbx_is_power2((size_t)pagesize))) - return -MDBX_EINVAL; - - const uint64_t limit = MAX_PAGENO * (uint64_t)pagesize; - return (limit < (intptr_t)MAX_MAPSIZE) ? (intptr_t)limit - : (intptr_t)MAX_PAGESIZE; -} - -__cold intptr_t mdbx_limits_txnsize_max(intptr_t pagesize) { - if (pagesize < 1) - pagesize = (intptr_t)mdbx_syspagesize(); - else if (unlikely(pagesize < (intptr_t)MIN_PAGESIZE || - pagesize > (intptr_t)MAX_PAGESIZE || - !mdbx_is_power2((size_t)pagesize))) - return -MDBX_EINVAL; - - return pagesize * (MDBX_LIST_MAX - 1); -} - -/*----------------------------------------------------------------------------*/ /* attribute support functions for Nexenta */ static __inline int mdbx_attr_peek(MDBX_val *data, mdbx_attr_t *attrptr) { diff --git a/libs/libmdbx/src/src/osal.h b/libs/libmdbx/src/src/osal.h index a1feb998d2..daa79064f9 100644 --- a/libs/libmdbx/src/src/osal.h +++ b/libs/libmdbx/src/src/osal.h @@ -552,6 +552,7 @@ int mdbx_lck_init(MDBX_env *env); int mdbx_lck_seize(MDBX_env *env); int mdbx_lck_downgrade(MDBX_env *env, bool complete); +int mdbx_lck_upgrade(MDBX_env *env); void mdbx_lck_destroy(MDBX_env *env); int mdbx_rdt_lock(MDBX_env *env); diff --git a/libs/libmdbx/src/src/tools/mdbx_chk.c b/libs/libmdbx/src/src/tools/mdbx_chk.c index 8fec23e3a8..51096c4053 100644 --- a/libs/libmdbx/src/src/tools/mdbx_chk.c +++ b/libs/libmdbx/src/src/tools/mdbx_chk.c @@ -340,16 +340,12 @@ static int handle_freedb(const uint64_t record_number, const MDBX_val *key, data->iov_len); else { const pgno_t number = *iptr++; - if (number < 1 || number > MDBX_LIST_MAX) + if (number >= MDBX_PNL_UM_MAX) problem_add("entry", record_number, "wrong idl length", "%" PRIiPTR "", number); - else if ((number + 1) * sizeof(pgno_t) > data->iov_len) - problem_add("entry", record_number, "trimmed idl", - "%" PRIuSIZE " > %" PRIuSIZE " (corruption)", - (number + 1) * sizeof(pgno_t), data->iov_len); - else if ((number + 1) * sizeof(pgno_t) < data->iov_len) - problem_add("entry", record_number, "extra idl space", - "%" PRIuSIZE " < %" PRIuSIZE " (minor, not a trouble)", + else if ((number + 1) * sizeof(pgno_t) != data->iov_len) + problem_add("entry", record_number, "mismatch idl length", + "%" PRIuSIZE " != %" PRIuSIZE "", (number + 1) * sizeof(pgno_t), data->iov_len); else { freedb_pages += number; diff --git a/libs/libmdbx/src/test/config.cc b/libs/libmdbx/src/test/config.cc index c17c0d71e0..cbff68ce4e 100644 --- a/libs/libmdbx/src/test/config.cc +++ b/libs/libmdbx/src/test/config.cc @@ -43,11 +43,6 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, if (narg + 1 < argc && strncmp("--", argv[narg + 1], 2) != 0) { *value = argv[narg + 1]; - if (strcmp(*value, "default") == 0) { - if (!default_value) - failure("Option '--%s' doen't accept default value\n", option); - *value = default_value; - } ++narg; return true; } @@ -62,15 +57,9 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool parse_option(int argc, char *const argv[], int &narg, const char *option, std::string &value, bool allow_empty) { - return parse_option(argc, argv, narg, option, value, allow_empty, - allow_empty ? "" : nullptr); -} - -bool parse_option(int argc, char *const argv[], int &narg, const char *option, - std::string &value, bool allow_empty, - const char *default_value) { const char *value_cstr; - if (!parse_option(argc, argv, narg, option, &value_cstr, default_value)) + if (!parse_option(argc, argv, narg, option, &value_cstr, + allow_empty ? "" : nullptr)) return false; if (!allow_empty && strlen(value_cstr) == 0) @@ -86,7 +75,7 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, if (!parse_option(argc, argv, narg, option, &list)) return false; - unsigned clear = 0; + mask = 0; while (*list) { if (*list == ',' || *list == ' ' || *list == '\t') { ++list; @@ -94,21 +83,14 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, } const char *const comma = strchr(list, ','); - const bool strikethrough = *list == '-' || *list == '~'; - if (strikethrough || *list == '+') - ++list; - else - mask = clear; const size_t len = (comma) ? comma - list : strlen(list); const option_verb *scan = verbs; - while (true) { if (!scan->verb) failure("Unknown verb '%.*s', for option '==%s'\n", (int)len, list, option); if (strlen(scan->verb) == len && strncmp(list, scan->verb, len) == 0) { - mask = strikethrough ? mask & ~scan->mask : mask | scan->mask; - clear = strikethrough ? clear & ~scan->mask : clear | scan->mask; + mask |= scan->mask; list += len; break; } @@ -121,36 +103,15 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool parse_option(int argc, char *const argv[], int &narg, const char *option, uint64_t &value, const scale_mode scale, - const uint64_t minval, const uint64_t maxval, - const uint64_t default_value) { + const uint64_t minval, const uint64_t maxval) { const char *value_cstr; if (!parse_option(argc, argv, narg, option, &value_cstr)) return false; - if (default_value && strcmp(value_cstr, "default") == 0) { - value = default_value; - return true; - } - - if (strcmp(value_cstr, "min") == 0 || strcmp(value_cstr, "minimal") == 0) { - value = minval; - return true; - } - - if (strcmp(value_cstr, "max") == 0 || strcmp(value_cstr, "maximal") == 0) { - value = maxval; - return true; - } - char *suffix = nullptr; errno = 0; - unsigned long long raw = strtoull(value_cstr, &suffix, 0); - if ((suffix && *suffix) || errno) { - suffix = nullptr; - errno = 0; - raw = strtoull(value_cstr, &suffix, 10); - } + unsigned long raw = strtoul(value_cstr, &suffix, 0); if (errno) failure("Option '--%s' expects a numeric value (%s)\n", option, test_strerror(errno)); @@ -206,58 +167,28 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool parse_option(int argc, char *const argv[], int &narg, const char *option, unsigned &value, const scale_mode scale, - const unsigned minval, const unsigned maxval, - const unsigned default_value) { + const unsigned minval, const unsigned maxval) { uint64_t huge; - if (!parse_option(argc, argv, narg, option, huge, scale, minval, maxval, - default_value)) + if (!parse_option(argc, argv, narg, option, huge, scale, minval, maxval)) return false; value = (unsigned)huge; return true; } bool parse_option(int argc, char *const argv[], int &narg, const char *option, - uint8_t &value, const uint8_t minval, const uint8_t maxval, - const uint8_t default_value) { + uint8_t &value, const uint8_t minval, const uint8_t maxval) { uint64_t huge; - if (!parse_option(argc, argv, narg, option, huge, no_scale, minval, maxval, - default_value)) + if (!parse_option(argc, argv, narg, option, huge, no_scale, minval, maxval)) return false; value = (uint8_t)huge; return true; } bool parse_option(int argc, char *const argv[], int &narg, const char *option, - int64_t &value, const int64_t minval, const int64_t maxval, - const int64_t default_value) { - uint64_t proxy = (uint64_t)value; - if (parse_option(argc, argv, narg, option, proxy, config::binary, - (uint64_t)minval, (uint64_t)maxval, - (uint64_t)default_value)) { - value = (int64_t)proxy; - return true; - } - return false; -} - -bool parse_option(int argc, char *const argv[], int &narg, const char *option, - int32_t &value, const int32_t minval, const int32_t maxval, - const int32_t default_value) { - uint64_t proxy = (uint64_t)value; - if (parse_option(argc, argv, narg, option, proxy, config::binary, - (uint64_t)minval, (uint64_t)maxval, - (uint64_t)default_value)) { - value = (int32_t)proxy; - return true; - } - return false; -} - -bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool &value) { - const char *value_cstr = nullptr; + const char *value_cstr = NULL; if (!parse_option(argc, argv, narg, option, &value_cstr, "yes")) { const char *current = argv[narg]; if (strncmp(current, "--no-", 5) == 0 && strcmp(current + 5, option) == 0) { @@ -357,12 +288,8 @@ void dump(const char *title) { : i->params.pathname_log.c_str()); } - log_info("database: %s, size %" PRIuPTR "[%" PRIiPTR "..%" PRIiPTR - ", %i %i, %i]\n", - i->params.pathname_db.c_str(), i->params.size_now, - i->params.size_lower, i->params.size_upper, - i->params.shrink_threshold, i->params.growth_step, - i->params.pagesize); + log_info("database: %s, size %" PRIu64 "\n", i->params.pathname_db.c_str(), + i->params.size); dump_verbs("mode", i->params.mode_flags, mode_bits); dump_verbs("table", i->params.table_flags, table_bits); diff --git a/libs/libmdbx/src/test/config.h b/libs/libmdbx/src/test/config.h index e8dc87577d..86f37fbed8 100644 --- a/libs/libmdbx/src/test/config.h +++ b/libs/libmdbx/src/test/config.h @@ -63,10 +63,6 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, std::string &value, bool allow_empty = false); bool parse_option(int argc, char *const argv[], int &narg, const char *option, - std::string &value, bool allow_empty, - const char *default_value); - -bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool &value); struct option_verb { @@ -79,25 +75,16 @@ bool parse_option(int argc, char *const argv[], int &narg, const char *option, bool parse_option(int argc, char *const argv[], int &narg, const char *option, uint64_t &value, const scale_mode scale, - const uint64_t minval = 0, const uint64_t maxval = INT64_MAX, - const uint64_t default_value = 0); + const uint64_t minval = 0, const uint64_t maxval = INT64_MAX); bool parse_option(int argc, char *const argv[], int &narg, const char *option, unsigned &value, const scale_mode scale, - const unsigned minval = 0, const unsigned maxval = INT32_MAX, - const unsigned default_value = 0); + const unsigned minval = 0, const unsigned maxval = INT32_MAX); bool parse_option(int argc, char *const argv[], int &narg, const char *option, uint8_t &value, const uint8_t minval = 0, - const uint8_t maxval = 255, const uint8_t default_value = 0); + const uint8_t maxval = 255); -bool parse_option(int argc, char *const argv[], int &narg, const char *option, - int64_t &value, const int64_t minval, const int64_t maxval, - const int64_t default_value = -1); - -bool parse_option(int argc, char *const argv[], int &narg, const char *option, - int32_t &value, const int32_t minval, const int32_t maxval, - const int32_t default_value = -1); //----------------------------------------------------------------------------- #pragma pack(push, 1) @@ -216,12 +203,7 @@ struct actor_params_pod { unsigned mode_flags; unsigned table_flags; - intptr_t size_lower; - intptr_t size_now; - intptr_t size_upper; - int shrink_threshold; - int growth_step; - int pagesize; + uint64_t size; unsigned test_duration; unsigned test_nops; diff --git a/libs/libmdbx/src/test/gc.sh b/libs/libmdbx/src/test/gc.sh deleted file mode 100644 index 84f31a50e7..0000000000 --- a/libs/libmdbx/src/test/gc.sh +++ /dev/null @@ -1,35 +0,0 @@ -#!/bin/bash -set -euo pipefail -TESTDB_PREFIX=${1:-/dev/shm/mdbx-gc-test} - -function rep9 { printf "%*s" $1 '' | tr ' ' '9'; } -function join { local IFS="$1"; shift; echo "$*"; } -function bit2option { local -n arr=$1; (( ($2&(1<<$3)) != 0 )) && echo -n '+' || echo -n '-'; echo "${arr[$3]}"; } - -options=(writemap coalesce lifo) - -function bits2list { - local -n arr=$1 - local i - local list=() - for ((i=0; i<${#arr[@]}; ++i)) do - list[$i]=$(bit2option $1 $2 $i) - done - join , "${list[@]}" -} - -for nops in {7..1}; do - for ((wbatch=nops; wbatch > 0; --wbatch)); do - for ((bits=2**${#options[@]}; --bits >= 0; )); do - echo "=================================== $(date)" - rm -f ${TESTDB_PREFIX}* - echo --nops=$( rep9 $nops ) --batch.write=$( rep9 $wbatch ) --mode=$(bits2list options $bits) - ./mdbx_test --pathname=${TESTDB_PREFIX} --pagesize=min --size=8G --keylen.min=1 --keylen.max=250 --datalen.min=1 --datalen.max=1500 \ - --nops=$( rep9 $nops ) --batch.write=$( rep9 $wbatch ) --mode=$(bits2list options $bits) \ - --keygen.seed=$(date +%N) --hill | bzip2 -c > ${TESTDB_PREFIX}.log.bz2 - ./mdbx_chk -nvv ${TESTDB_PREFIX} | tee ${TESTDB_PREFIX}-chk.log - done - done -done - -echo "=== ALL DONE ====================== $(date)" diff --git a/libs/libmdbx/src/test/hill.cc b/libs/libmdbx/src/test/hill.cc index 0d609b8692..c9115784d4 100644 --- a/libs/libmdbx/src/test/hill.cc +++ b/libs/libmdbx/src/test/hill.cc @@ -156,6 +156,8 @@ bool testcase_hill::run() { a_serial); generate_pair(a_serial, a_key, a_data_0, 0); generate_pair(a_serial, a_key, a_data_1, age_shift); + if (a_serial == 808) + log_trace("!!!"); int rc = mdbx_replace(txn_guard.get(), dbi, &a_key->value, &a_data_1->value, &a_data_0->value, update_flags); if (unlikely(rc != MDBX_SUCCESS)) diff --git a/libs/libmdbx/src/test/keygen.cc b/libs/libmdbx/src/test/keygen.cc index 1b18fa0033..99b46f2976 100644 --- a/libs/libmdbx/src/test/keygen.cc +++ b/libs/libmdbx/src/test/keygen.cc @@ -122,16 +122,16 @@ void maker::setup(const config::actor_params_pod &actor, unsigned thread_number) { key_essentials.flags = actor.table_flags & (MDBX_INTEGERKEY | MDBX_REVERSEKEY); - assert(actor.keylen_min <= UINT8_MAX); + assert(actor.keylen_min < UINT8_MAX); key_essentials.minlen = (uint8_t)actor.keylen_min; - assert(actor.keylen_max <= UINT16_MAX); + assert(actor.keylen_max < UINT16_MAX); key_essentials.maxlen = (uint16_t)actor.keylen_max; value_essentials.flags = actor.table_flags & (MDBX_INTEGERDUP | MDBX_REVERSEDUP); - assert(actor.datalen_min <= UINT8_MAX); + assert(actor.datalen_min < UINT8_MAX); value_essentials.minlen = (uint8_t)actor.datalen_min; - assert(actor.datalen_max <= UINT16_MAX); + assert(actor.datalen_max < UINT16_MAX); value_essentials.maxlen = (uint16_t)actor.datalen_max; assert(thread_number < 2); diff --git a/libs/libmdbx/src/test/log.h b/libs/libmdbx/src/test/log.h index 3e9f9483ab..e97e954cea 100644 --- a/libs/libmdbx/src/test/log.h +++ b/libs/libmdbx/src/test/log.h @@ -17,7 +17,16 @@ #include "base.h" void __noreturn usage(void); + +#ifdef __GNUC__ +#define __printf_args(format_index, first_arg) \ + __attribute__((format(printf, format_index, first_arg))) +#else +#define __printf_args(format_index, first_arg) +#endif + void __noreturn __printf_args(1, 2) failure(const char *fmt, ...); + void __noreturn failure_perror(const char *what, int errnum); const char *test_strerror(int errnum); diff --git a/libs/libmdbx/src/test/main.cc b/libs/libmdbx/src/test/main.cc index 1cac3506a3..bc3198ed3a 100644 --- a/libs/libmdbx/src/test/main.cc +++ b/libs/libmdbx/src/test/main.cc @@ -1,4 +1,4 @@ -/* +/* * Copyright 2017-2018 Leonid Yuriev <leo@yuriev.ru> * and other libmdbx authors: please see AUTHORS file. * All rights reserved. @@ -35,13 +35,7 @@ void actor_params::set_defaults(const std::string &tmpdir) { mode_flags = MDBX_NOSUBDIR | MDBX_WRITEMAP | MDBX_MAPASYNC | MDBX_NORDAHEAD | MDBX_NOMEMINIT | MDBX_COALESCE | MDBX_LIFORECLAIM; table_flags = MDBX_DUPSORT; - - size_lower = -1; - size_now = 1024 * 1024 * 4; - size_upper = -1; - shrink_threshold = -1; - growth_step = -1; - pagesize = -1; + size = 1024 * 1024 * 4; keygen.seed = 1; keygen.keycase = kc_random; @@ -156,34 +150,8 @@ int main(int argc, char *const argv[]) { if (config::parse_option(argc, argv, narg, "table", params.table_flags, config::table_bits)) continue; - - if (config::parse_option(argc, argv, narg, "pagesize", params.pagesize, - mdbx_limits_pgsize_min(), - mdbx_limits_pgsize_max())) - continue; - if (config::parse_option(argc, argv, narg, "size-lower", params.size_lower, - mdbx_limits_dbsize_min(params.pagesize), - mdbx_limits_dbsize_max(params.pagesize))) - continue; - if (config::parse_option(argc, argv, narg, "size", params.size_now, - mdbx_limits_dbsize_min(params.pagesize), - mdbx_limits_dbsize_max(params.pagesize))) - continue; - if (config::parse_option(argc, argv, narg, "size-upper", params.size_upper, - mdbx_limits_dbsize_min(params.pagesize), - mdbx_limits_dbsize_max(params.pagesize))) - continue; - if (config::parse_option( - argc, argv, narg, "shrink-threshold", params.shrink_threshold, 0, - (int)std::min((intptr_t)INT_MAX, - mdbx_limits_dbsize_max(params.pagesize) - - mdbx_limits_dbsize_min(params.pagesize)))) - continue; - if (config::parse_option( - argc, argv, narg, "growth-step", params.growth_step, 0, - (int)std::min((intptr_t)INT_MAX, - mdbx_limits_dbsize_max(params.pagesize) - - mdbx_limits_dbsize_min(params.pagesize)))) + if (config::parse_option(argc, argv, narg, "size", params.size, + config::binary, 4096 * 4)) continue; if (config::parse_option(argc, argv, narg, "keygen.width", @@ -220,33 +188,20 @@ int main(int argc, char *const argv[]) { config::duration, 1)) continue; if (config::parse_option(argc, argv, narg, "keylen.min", params.keylen_min, - config::no_scale, 0, UINT8_MAX)) { - if (params.keylen_max < params.keylen_min) - params.keylen_max = params.keylen_min; + config::no_scale, 0, params.keylen_max)) continue; - } if (config::parse_option(argc, argv, narg, "keylen.max", params.keylen_max, - config::no_scale, 0, - std::min((unsigned)mdbx_limits_keysize_max(0), - (unsigned)UINT16_MAX))) { - if (params.keylen_min > params.keylen_max) - params.keylen_min = params.keylen_max; + config::no_scale, params.keylen_min, + mdbx_get_maxkeysize(0))) continue; - } if (config::parse_option(argc, argv, narg, "datalen.min", params.datalen_min, config::no_scale, 0, - UINT8_MAX)) { - if (params.datalen_max < params.datalen_min) - params.datalen_max = params.datalen_min; + params.datalen_max)) continue; - } if (config::parse_option(argc, argv, narg, "datalen.max", - params.datalen_max, config::no_scale, 0, - std::min((int)UINT16_MAX, MDBX_MAXDATASIZE))) { - if (params.datalen_min > params.datalen_max) - params.datalen_min = params.datalen_max; + params.datalen_max, config::no_scale, + params.datalen_min, MDBX_MAXDATASIZE)) continue; - } if (config::parse_option(argc, argv, narg, "batch.read", params.batch_read, config::no_scale, 1)) continue; diff --git a/libs/libmdbx/src/test/osal-windows.cc b/libs/libmdbx/src/test/osal-windows.cc index b8cdb53513..109c835a96 100644 --- a/libs/libmdbx/src/test/osal-windows.cc +++ b/libs/libmdbx/src/test/osal-windows.cc @@ -53,7 +53,7 @@ void osal_wait4barrier(void) { } } -static HANDLE make_inheritable(HANDLE hHandle) { +static HANDLE make_inharitable(HANDLE hHandle) { assert(hHandle != NULL && hHandle != INVALID_HANDLE_VALUE); if (!DuplicateHandle(GetCurrentProcess(), hHandle, GetCurrentProcess(), &hHandle, 0, TRUE, @@ -71,7 +71,7 @@ void osal_setup(const std::vector<actor_config> &actors) { HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (!hEvent) failure_perror("CreateEvent()", GetLastError()); - hEvent = make_inheritable(hEvent); + hEvent = make_inharitable(hEvent); log_trace("osal_setup: event %" PRIuPTR " -> %p", i, hEvent); events[i] = hEvent; } @@ -79,12 +79,12 @@ void osal_setup(const std::vector<actor_config> &actors) { hBarrierSemaphore = CreateSemaphore(NULL, 0, (LONG)actors.size(), NULL); if (!hBarrierSemaphore) failure_perror("CreateSemaphore(BarrierSemaphore)", GetLastError()); - hBarrierSemaphore = make_inheritable(hBarrierSemaphore); + hBarrierSemaphore = make_inharitable(hBarrierSemaphore); hBarrierEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (!hBarrierEvent) failure_perror("CreateEvent(BarrierEvent)", GetLastError()); - hBarrierEvent = make_inheritable(hBarrierEvent); + hBarrierEvent = make_inharitable(hBarrierEvent); } void osal_broadcast(unsigned id) { diff --git a/libs/libmdbx/src/test/test.cc b/libs/libmdbx/src/test/test.cc index 80694827a6..3750af525f 100644 --- a/libs/libmdbx/src/test/test.cc +++ b/libs/libmdbx/src/test/test.cc @@ -149,10 +149,7 @@ void testcase::db_prepare() { if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_oomfunc()", rc); - rc = mdbx_env_set_geometry( - env, config.params.size_lower, config.params.size_now, - config.params.size_upper, config.params.growth_step, - config.params.shrink_threshold, config.params.pagesize); + rc = mdbx_env_set_mapsize(env, (size_t)config.params.size); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_mapsize()", rc); diff --git a/libs/libmdbx/src/test/utils.cc b/libs/libmdbx/src/test/utils.cc index 53a750e314..0855c7eef3 100644 --- a/libs/libmdbx/src/test/utils.cc +++ b/libs/libmdbx/src/test/utils.cc @@ -93,7 +93,7 @@ bool hex2data(const char *hex_begin, const char *hex_end, void *ptr, //----------------------------------------------------------------------------- -/* TODO: replace my 'libmera' from t1ha. */ +/* TODO: replace my 'libmera' fomr t1ha. */ uint64_t entropy_ticks(void) { #if defined(EMSCRIPTEN) return (uint64_t)emscripten_get_now(); |