класс ara::core::UnsynchronizedPoolResource

Объявление конструктора копирования удаленным (=delete) в ara::core::UnsynchronizedPoolResource согласно [SWS_CORE_00046] исключает любое дублирование экземпляра пула. Для создания объектов вместо этого доступны специфические конструкторы, например без аргументов [SWS_CORE_00063], с указанием вышестоящего ресурса памяти [SWS_CORE_00064], с PoolOptions [SWS_CORE_00068] или с обоими параметрами [SWS_CORE_00067].

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

• Вызов и обработка ошибок: попытка копирования отклоняется компилятором как ошибка еще на этапе компиляции. Ошибки выделения памяти при последующем использовании памяти через do_allocate не приводят к исключениям, а возвращают nullptr [SWS_CORE_00058], в то время как ошибки освобождения в do_deallocate молчаливо игнорируются [SWS_CORE_00059].
• Параллелизм: отдельные операции с памятью на данном экземпляре объявлены непотокобезопасными [SWS_CORE_00058], [SWS_CORE_00059]. Интерпретация: удаление конструктора копирования, вероятно, призвано обеспечить эксклюзивную ответственность за управляемые блоки памяти и предотвратить несогласованные состояния при параллельном использовании или преждевременном освобождении через release [SWS_CORE_00065]. Вопрос Q-d97dd87dddb2379d (открытый)
• Взаимодействие: ограничение корреспондирует с также удаленным оператором присваивания [SWS_CORE_00047]. Деструктор класса выполнен невиртуальным [SWS_CORE_00062], тогда как проверки идентичности могут выполняться через do_is_equal [SWS_CORE_00060].

Оператор копирующего присваивания ara::core::UnsynchronizedPoolResource согласно [SWS_CORE_00047] явно объявлен удалённым (=delete). Присваивание одного экземпляра другому тем самым синтаксически исключено и приводит к ошибке компилятора уже во время компиляции. Вместе с также удалённым конструктором копирования [SWS_CORE_00046] это гарантирует, что экземпляры класса ресурсов не могут быть ни скопированы, ни размножены путём присваивания. Интерпретация: это, вероятно, предотвращает многократное ссылание на внутренние блоки памяти и управляющую информацию или их некорректное освобождение. Вопрос Q-75cee08bebc61976 (открытый)

Вместо этого новые экземпляры создаются через предоставленные конструкторы, например без параметров через [SWS_CORE_00063], с вышестоящим ресурсом через [SWS_CORE_00064] или с указанием PoolOptions через [SWS_CORE_00067] либо [SWS_CORE_00068]. Связанный вышестоящий ресурс можно запросить через [SWS_CORE_00056], а параметры конфигурации — через [SWS_CORE_00057]. Управляемая память может быть явно освобождена с помощью [SWS_CORE_00065] до того, как время жизни завершится невиртуальным деструктором [SWS_CORE_00062].

Поскольку присваивания исключены с помощью [SWS_CORE_00047], экземпляры при необходимости должны передаваться по ссылке или указателю. При этом следует учитывать, что операции выделения через [SWS_CORE_00058] и освобождения через [SWS_CORE_00059] специфицированы как непотокобезопасные. Если запрос памяти завершается неудачей, исключение не генерируется, а возвращается nullptr [SWS_CORE_00058]; ошибки при деаллокации молча игнорируются [SWS_CORE_00059].

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

Метод upstream_resource() класса ara::core::UnsynchronizedPoolResource синхронно возвращает указатель на вышестоящий MemoryResource [SWS_CORE_00056]. Вызов является бессимвольным (без параметров) и объявлен как const. Подключение и объявления типов выполняются через заголовочный файл #include "ara/core/memory_resource.h" [SWS_CORE_00056].

Обработка ошибок

Функция специфицирована как noexcept, а также exception safe [SWS_CORE_00056]. Она не генерирует исключений и не сообщает ни о специфических кодах ошибок, ни о событиях DET или DEM. Если предшествующая инициализация через конструкторы завершается неудачей, они отчасти не являются исключениебезопасными [SWS_CORE_00063], тогда как сам запрос всегда остаётся безошибочным.

Параллелизм и ограничения

Метод upstream_resource() явно классифицирован как thread-safe [SWS_CORE_00056]. Это контрастирует с внутренними процедурами выделения памяти do_allocate() [SWS_CORE_00058] и do_deallocate() [SWS_CORE_00059], которые специфицированы как not thread-safe. Кроме того, конструктор копирования и оператор присваивания класса удалены [SWS_CORE_00046], [SWS_CORE_00047].

Взаимодействие

Метод тесно взаимодействует с конструкторами UnsynchronizedPoolResource, которым опционально может быть передан вышестоящий MemoryResource [SWS_CORE_00064], [SWS_CORE_00067]. Интерпретация: возвращаемый указатель, вероятно, указывает именно на экземпляр MemoryResource, определённый при инстанцировании. Вопрос Q-aefbc7d0f7d085d1 (открытый) Другие свойства ресурса пула можно запросить через options() [SWS_CORE_00057], в то время как выделенная память может быть освобождена через release() [SWS_CORE_00065].

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

Функция-член options() класса ara::core::UnsynchronizedPoolResource служит для синхронного запроса конфигурации пула памяти [SWS_CORE_00057]. Метод объявлен в #include "ara/core/memory_resource.h", не ожидает входных параметров и возвращает экземпляр типа PoolOptions по значению [SWS_CORE_00057]. Будучи const-квалифицированной функцией, он не модифицирует объект и ведет себя в соответствии со спецификацией в [mem.res.pool] [SWS_CORE_00057].

Обработка ошибок и безопасность исключений

Интерфейс определен как noexcept и гарантирует полную безопасность относительно исключений (exception safe) [SWS_CORE_00057]. Исключения не выбрасываются, и возвращаемые значения ошибок отсутствуют; выборка опций всегда завершается успешно.

Параллелизм и ограничения

В спецификации options() обозначен как потокобезопасный (thread-safe) [SWS_CORE_00057]. Это контрастирует с функциями выделения памяти того же класса, такими как do_allocate [SWS_CORE_00058] и do_deallocate [SWS_CORE_00059], которые явно не являются потокобезопасными. Таким образом, метод может выполняться параллельно для опроса состояния.

Взаимодействие

Возвращаемые PoolOptions, предположительно, отражают параметры, с которыми ресурс пула был параметризован через соответствующие конструкторы [SWS_CORE_00067], [SWS_CORE_00068], либо представляют стандартные опции при использовании конструкторов по умолчанию [SWS_CORE_00063], [SWS_CORE_00064]. Вопрос Q-19fa8ad6e3e6b1c6 (открытый) Помимо options(), для инспекции также доступна функция upstream_resource() [SWS_CORE_00056], тогда как операции копирования ресурса запрещены удаленными операторами [SWS_CORE_00046], [SWS_CORE_00047].

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

Метод do_allocate класса ara::core::UnsynchronizedPoolResource выделяет память для запрошенного размера в байтах (bytes) и выравнивания (alignment) [SWS_CORE_00058]. Интерпретация: поскольку метод специфицирован с защищенной видимостью (protected), в штатном режиме работы он, вероятно, вызывается не напрямую из прикладного кода, а косвенно через интерфейс выделения памяти базового класса. Вопрос Q-5a702813496f8071 (открытый) Объявление выполняется через заголовочный файл #include "ara/core/memory_resource.h" [SWS_CORE_00058].

Обработка ошибок

В отличие от стандартного поведения согласно [mem.res.pool], функция объявлена как noexcept и не выбрасывает исключений, таких как std::bad_alloc, при ошибках выделения памяти [SWS_CORE_00058]. Вместо этого в случае неудачи она обязательно возвращает nullptr [SWS_CORE_00058]. Следовательно, вызывающий код должен всегда явно проверять результат на равенство нулевому указателю.

Параллелизм и ограничения

Функция классифицирована как not thread-safe [SWS_CORE_00058]. Параллельные вызовы на одном и том же экземпляре UnsynchronizedPoolResource недопустимы без внешней синхронизации. Конструктор копирования и оператор присваивания класса удалены (delete), поэтому экземпляры не могут быть скопированы ([SWS_CORE_00046], [SWS_CORE_00047]).

Взаимодействие

Для освобождения памяти существует аналог do_deallocate, который также спроектирован как защищенный, noexcept и непотокобезопасный, а также молча игнорирует ошибки [SWS_CORE_00059]. Пул внутренне использует вышестоящий ресурс (upstream resource), сконфигурированный при инстанцировании ([SWS_CORE_00056], [SWS_CORE_00064], [SWS_CORE_00067]). С помощью release() полученная от пула память может быть освобождена пакетно [SWS_CORE_00065].

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

Виртуальная функция-член do_deallocate объявлена как protected в области видимости ara::core::UnsynchronizedPoolResource (заголовочный файл #include "ara/core/memory_resource.h") [SWS_CORE_00059]. Она выполняет синхронное освобождение блока памяти на основе переданных параметров p (указатель на область памяти), bytes (размер в байтах) и alignment (выравнивание). Интерпретация: будучи защищенным методом, вызов, вероятно, обычно происходит косвенно через открытый интерфейс ресурса памяти. Вопрос Q-f4992f515c10ee01 (открытый)

Обработка ошибок

По сравнению со стандартным поведением в [mem.res.pool] функция имеет два специфических отличия: она объявлена как noexcept и, следовательно, безопасна относительно исключений [SWS_CORE_00059]. Если освобождение памяти завершается сбоем, ошибки молчаливо игнорируются (errors will be silently ignored); не существует ни кода ошибки, ни отдельного сообщения об ошибке.

Параллелизм и ограничения

Операция явно обозначена как непотокобезопасная (not thread-safe) [SWS_CORE_00059]. Если области памяти одного и того же экземпляра ресурса освобождаются из нескольких потоков, доступ обязательно должен быть синхронизирован извне.

Взаимодействие

Метод дополняет do_allocate [SWS_CORE_00058], который также специфицирован как noexcept и непотокобезопасный и возвращает nullptr при неудаче. Для полного освобождения всей выделенной памяти пула доступен потокобезопасный метод release [SWS_CORE_00065]. Экземпляры класса не могут быть скопированы, поскольку конструктор копирования [SWS_CORE_00046] и оператор присваивания [SWS_CORE_00047] удалены.

Защищенная функция-член do_is_equal класса ara::core::UnsynchronizedPoolResource выполняет сравнение ресурсов памяти на равенство согласно [SWS_CORE_00060]. Она предоставляется через заголовочный файл ara/core/memory_resource.h. Поскольку метод имеет видимость protected, он предназначен для внутреннего вызова через базовый класс MemoryResource ([SWS_CORE_00060]). Он синхронно сравнивает текущий экземпляр с переданной ссылкой типа MemoryResource и возвращает значение bool ([SWS_CORE_00060]). Согласно [mem.res.pool], сравнение, как правило, должно проверять идентичность обоих ресурсов (this == &other), поскольку пулы памяти функционируют изолированно. Вопрос Q-679a5e17d2e2903f (открытый)

Метод объявлен как noexcept и имеет спецификацию exception safe ([SWS_CORE_00060]). Он не генерирует исключений и не использует сообщений об ошибках DET или DEM.

С точки зрения параллелизма do_is_equal классифицируется как thread-safe ([SWS_CORE_00060]). Поскольку он работает исключительно на чтение как константная функция-член, его можно вызывать параллельно из нескольких потоков. Это контрастирует с операциями выделения памяти, такими как do_allocate ([SWS_CORE_00058]) и do_deallocate ([SWS_CORE_00059]), которые явно не являются потокобезопасными.

В рамках взаимодействия ресурсов памяти класс не допускает ни копирования, ни присваивания ([SWS_CORE_00046], [SWS_CORE_00047]). Экземпляры могут инициализироваться через конструкторы, такие как [SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067] или [SWS_CORE_00068]. Вышестоящие источники памяти можно запросить с помощью upstream_resource() ([SWS_CORE_00056]), тогда как перед уничтожением ([SWS_CORE_00062]) занятая память может быть освобождена посредством release() ([SWS_CORE_00065]).

Деструктор ~UnsynchronizedPoolResource() ([SWS_CORE_00062]) завершает время жизни экземпляра класса управления памятью ara::core::UnsynchronizedPoolResource из заголовочного файла ara/core/memory_resource.h. Вызов выполняется синхронно и объявлен как noexcept, благодаря чему операция безопасна относительно исключений ([SWS_CORE_00062]).

Семантика в целом соответствует использованию пула в [mem.res.pool], однако имеет существенное отличие: деструктор не является виртуальным ([SWS_CORE_00062]). Интерпретация: из невиртуальности деструктора, вероятно, следует, что экземпляры нельзя полиморфно освобождать через указатель базового класса на MemoryResource. Вопрос Q-5578b2bf008b98c5 (открытый)

В отношении жизненного цикла и взаимодействия действуют следующие условия:

• Управление ресурсами: при уничтожении экземпляра управляемая память освобождается аналогично явному освобождению через release() ([SWS_CORE_00065]) в направлении вышестоящего ресурса ([SWS_CORE_00056]).
• Параллелизм: хотя сам деструктор классифицирован как потокобезопасный ([SWS_CORE_00062]), внутренние подпрограммы выделения памяти do_allocate ([SWS_CORE_00058]) и do_deallocate ([SWS_CORE_00059]) определены как непотокобезопасные. Поэтому вызов деструктора не должен происходить одновременно с операциями выделения памяти того же экземпляра.
• Создание и копирование: экземпляры могут быть сконструированы с опциями или без них, а также с ресурсом upstream ([SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]). Конструктор копирования и оператор присваивания копированием удалены ([SWS_CORE_00046], [SWS_CORE_00047]).

Конструктор по умолчанию без параметров [SWS_CORE_00063] инициализирует экземпляр ara::core::UnsynchronizedPoolResource согласно семантике из [mem.res.pool]. Интерпретация: при этом, вероятно, используются стандартные параметры пула и стандартный восходящий (upstream) ресурс памяти, которые позже можно запросить через [SWS_CORE_00057] и [SWS_CORE_00056]. Вопрос Q-d76bae1c251fa516 (открытый)

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

• Защита от копирования и перегрузка: конструктор копирования [SWS_CORE_00046] и оператор присваивания [SWS_CORE_00047] удалены (delete). Наряду с созданием экземпляра без параметров доступны перегруженные конструкторы с явными опциями пула или ресурсами upstream ([SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]).
• Обработка ошибок и безопасность исключений: конструктор объявлен как небезопасный относительно исключений (not exception safe) [SWS_CORE_00063]. При последующей работе с памятью операции выделения отличаются от стандартных исключений: в случае ошибки do_allocate возвращает nullptr вместо исключения [SWS_CORE_00058], тогда как do_deallocate молча игнорирует ошибки [SWS_CORE_00059].
• Параллелизм: сам вызов конструктора является потокобезопасным (thread-safe) [SWS_CORE_00063]. Однако последующие операции выделения и освобождения памяти созданного экземпляра (do_allocate, do_deallocate) явно специфицированы как непотокобезопасные (not thread-safe) ([SWS_CORE_00058], [SWS_CORE_00059]).
• Освобождение ресурсов и уничтожение: занятая память может быть освобождена через [SWS_CORE_00065]. Деструктор является noexcept, но реализован как невиртуальный [SWS_CORE_00062].

Использование и назначение

Конструктор explicit UnsynchronizedPoolResource (MemoryResource *upstream) инициализирует экземпляр класса ara::core::UnsynchronizedPoolResource из заголовочного файла #include "ara/core/memory_resource.h" согласно [mem.res.pool] [SWS_CORE_00064]. Через параметр upstream передаётся вышестоящий ресурс памяти, который впоследствии может быть запрошен через метод upstream_resource() [SWS_CORE_00056]. В качестве альтернатив доступны конструктор по умолчанию без параметров [SWS_CORE_00063], а также перегрузки с PoolOptions [SWS_CORE_00067], [SWS_CORE_00068].

Обработка ошибок и поведение при исключениях

Инстанцирование специфицировано как not exception safe [SWS_CORE_00064], поэтому во время конструирования могут возникать исключения. Для последующих выделений памяти действуют другие правила: внутренняя функция аллокации do_allocate не генерирует исключений, а возвращает nullptr при сбоях [SWS_CORE_00058], в то время как ошибки при do_deallocate молча игнорируются [SWS_CORE_00059].

Параллелизм и ограничения

Сам вызов конструктора считается потокобезопасным (thread-safe) [SWS_CORE_00064]. Операции копирования запрещены, так как конструктор копирования [SWS_CORE_00046] и оператор присваивания [SWS_CORE_00047] удалены. После конструирования операции аллокации и деаллокации не являются потокобезопасными (not thread-safe) [SWS_CORE_00058], [SWS_CORE_00059]. Кроме того, деструктор не объявлен виртуальным [SWS_CORE_00062]. Занятая память может быть освобождена досрочно через release() [SWS_CORE_00065]. Интерпретация: поскольку передаётся нативный указатель upstream, нижележащий upstream-ресурс, по всей видимости, должен оставаться действительным на протяжении всего жизненного цикла экземпляра пула. Вопрос Q-3e6c23bae834b912 (открытый)

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

Функция-член release() относится к области видимости класса ara::core::UnsynchronizedPoolResource и объявляется через заголовочный файл ara/core/memory_resource.h [SWS_CORE_00065]. Функция не имеет входных параметров и возвращаемого значения (void). Ее функциональная семантика основана на стандарте C++ [mem.res.pool] [SWS_CORE_00065]; данная ссылка, вероятно, означает, что функция синхронно возвращает вышестоящему ресурсу памяти (upstream_resource()) всю память, которая была выделена через экземпляр пула [SWS_CORE_00056]. Вопрос Q-e0c7e00cde5d5a34 (открытый)

Обработка ошибок

Функция определена как noexcept, а также как exception safe [SWS_CORE_00065]. Она не генерирует исключений при выполнении. Поскольку в спецификации не указаны конкретные коды ошибок или сообщения DET/DEM, при ошибках освобождения памяти явная обратная связь об ошибках через release() отсутствует.

Параллелизм и ограничения

Согласно спецификации, release() классифицируется как thread-safe [SWS_CORE_00065]. Это контрастирует с внутренними функциями управления памятью класса: как выделение с помощью do_allocate [SWS_CORE_00058], так и освобождение через do_deallocate [SWS_CORE_00059] явно классифицированы как not thread-safe.

Взаимодействие

Метод тесно взаимодействует с другими свойствами и требованиями UnsynchronizedPoolResource:

• Ресурсы памяти: он возвращает память сконфигурированному вышестоящему ресурсу (upstream resource) [SWS_CORE_00056] без необходимости уничтожения самого объекта пула, как это происходит в деструкторе ~UnsynchronizedPoolResource() [SWS_CORE_00062].
• Конфигурация: поведение и размеры чанков (chunk) пула зависят от параметров, заданных при инстанцировании [SWS_CORE_00057], [SWS_CORE_00067], [SWS_CORE_00068].
• Защита от копирования: дублирование пула недопустимо, поскольку конструктор копирования [SWS_CORE_00046] и оператор присваивания [SWS_CORE_00047] удалены (delete).

Конструктор [SWS_CORE_00067] инициализирует экземпляр ara::core::UnsynchronizedPoolResource со специфическими опциями пула (opts) и вышестоящим ресурсом памяти (upstream). Вызов выполняется синхронно и специфицирован как noexcept, благодаря чему создание объекта является исключениебезопасным. Копирование экземпляра исключено, поскольку как конструктор копирования [SWS_CORE_00046], так и оператор присваивания [SWS_CORE_00047] удалены (=delete).

Сохранённые настройки и вышестоящие ресурсы могут быть прочитаны во время выполнения через options() [SWS_CORE_00057], а также upstream_resource() [SWS_CORE_00056]. В качестве альтернатив доступны конструктор по умолчанию [SWS_CORE_00063] и перегрузки, принимающие исключительно upstream [SWS_CORE_00064] или opts [SWS_CORE_00068]. Занятая память может быть освобождена через release() [SWS_CORE_00065] или деструктор [SWS_CORE_00062], причём деструктор, в отличие от стандарта, не является виртуальным.

Что касается параллелизма, само конструирование объявлено потокобезопасным [SWS_CORE_00067]. Напротив, фактические функции управления памятью экземпляра — do_allocate [SWS_CORE_00058] и do_deallocate [SWS_CORE_00059] — явно не являются потокобезопасными («not thread-safe») и требуют внешних механизмов защиты при параллельном доступе. Ошибки при этом обрабатываются без исключений: неудачные выделения памяти возвращают nullptr [SWS_CORE_00058], тогда как ошибки деаллокации молча игнорируются [SWS_CORE_00059]. Интерпретация: переданный объект upstream, предположительно, должен оставаться валидным на протяжении всего жизненного цикла пула. Вопрос Q-2439ec8f9fb8bb3e (открытый)

Конструктор [SWS_CORE_00068] служит для синхронной инициализации ara::core::UnsynchronizedPoolResource с указанием специфических параметров конфигурации через параметр opts (тип PoolOptions). Поведение соответствует стандарту [mem.res.pool] из заголовочного файла ara/core/memory_resource.h. Переданные настройки могут быть запрошены после инстанцирования с помощью options() [SWS_CORE_00057], тогда как вышестоящий менеджер памяти доступен через upstream_resource() [SWS_CORE_00056].

Что касается обработки ошибок, функция специфицирована как не являющаяся исключениебезопасной («not exception safe») [SWS_CORE_00068]. Интерпретация: если внутреннее предоставление управляющих структур при инстанцировании терпит неудачу, вероятно, выбрасывается исключение, чем этот вызов отличается от варианта noexcept [SWS_CORE_00067]. Вопрос Q-479a016f4e0ddde7 (открытый) В то время как сам конструктор классифицируется как потокобезопасный («thread-safe») [SWS_CORE_00068], последующие операции с памятью созданного экземпляра, такие как do_allocate [SWS_CORE_00058] и do_deallocate [SWS_CORE_00059], явно не являются потокобезопасными («not thread-safe»); следовательно, они не должны выполняться параллельно без защиты.

Во взаимодействии с жизненным циклом класса следует учитывать, что конструктор копирования [SWS_CORE_00046] и оператор присваивания [SWS_CORE_00047] удалены (delete). Выделенная память остаётся в пуле до тех пор, пока не будет освобождена через release() [SWS_CORE_00065] или пока объект не будет уничтожен через невиртуальный деструктор [SWS_CORE_00062].