classe ara::core::PolymorphicAllocator

A função-membro allocate da classe ara::core::PolymorphicAllocator destina-se à requisição síncrona de memória não inicializada para n objetos do tipo Tp [SWS_CORE_06547]. Ela baseia-se na funcionalidade de [mem.poly.allocator.class], mas desvia deliberadamente do padrão C++ pela declaração como noexcept e pelo atributo [[nodiscard]] [SWS_CORE_06547].

Em caso de erro, allocate não lança uma exceção como std::bad_alloc, mas retorna um nullptr em seu lugar [SWS_CORE_06547]. Devido a [[nodiscard]], o chamador deve receber explicitamente o valor de retorno e verificar contra nullptr antes de utilizar a região de memória [SWS_CORE_06547]. Em relação à concorrência, a função é classificada como Exception-Safe, mas é considerada não thread-safe (not thread-safe) [SWS_CORE_06547]. Interpretação: Uma chamada síncrona através do mesmo alocador a partir de diferentes threads deve, portanto, exigir proteção externa por parte do chamador. Pergunta Q-b00116faadf930fe (aberta)

O comportamento tolerante a falhas sem exceções corresponde diretamente à interface ara::core::MemoryResource::allocate [SWS_CORE_06503], que também é definida como noexcept e retorna nullptr em caso de falha. Instâncias predefinidas como NullMemoryResource [SWS_CORE_06563] também utilizam esse princípio e retornam consistentemente nullptr em chamadas de alocação. Em um nível superior, esse mecanismo interage com contêineres como ara::core::Vector [SWS_CORE_01315], cujos operadores de atribuição são ajustados a tais propriedades de alocação.

usar

A função membro allocate_bytes da classe ara::core::PolymorphicAllocator reserva memória bruta no volume de nbytes com o alinhamento especificado alignment [SWS_CORE_06549]. O valor padrão para o alinhamento corresponde a alignof(std::max_align_t) [SWS_CORE_06549]. A função é incluída por meio do cabeçalho ara/core/memory_resource.h e executada sincronicamente [SWS_CORE_06549].

Tratamento de erros e semântica

Diferentemente do comportamento padrão segundo [mem.poly.allocator.class], a implementação apresenta dois desvios [SWS_CORE_06549]:

• A função é declarada como noexcept e não lança exceções [SWS_CORE_06549].
• Se a alocação falhar, a função retorna nullptr em vez de disparar uma exceção [SWS_CORE_06549].

Devido ao atributo [[nodiscard]], o valor de retorno deve ser avaliado pelo chamador, em particular por meio de uma verificação de nullptr antes do acesso à região de memória [SWS_CORE_06549].

Simultaneidade e restrições

Quanto à segurança de threads, o método é especificado como not thread-safe [SWS_CORE_06549]. Chamadas paralelas na mesma instância provavelmente necessitam, portanto, de uma sincronização externa [SWS_CORE_06549]. Pergunta Q-85c74d55563cae38 (aberta) Em relação à segurança contra exceções, a operação é considerada exception safe [SWS_CORE_06549].

usar

A função membro de template allocate_object é parte integrante da classe ara::core::PolymorphicAllocator e é disponibilizada por meio do arquivo de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_06551]. Ela aloca memória sincronicamente para n objetos do tipo T, sendo o parâmetro n preenchido por padrão com o valor 1 [SWS_CORE_06551]. O atributo de compilador [[nodiscard]] obriga os chamadores a não ignorar o ponteiro tipado T* retornado.

Tratamento de erros

A especificação define dois desvios explícitos do padrão [mem.poly.allocator.class] [SWS_CORE_06551]:

• Sem exceções: A função é declarada como noexcept e especificada como segura contra exceções (exception safe) [SWS_CORE_06551].
• Ponteiro nulo em caso de erro: Se a alocação de memória falhar, nenhuma exceção é lançada, mas nullptr é obrigatoriamente retornado [SWS_CORE_06551].

O chamador deve, portanto, verificar se o ponteiro fornecido é nullptr imediatamente antes de utilizá-lo posteriormente.

Simultaneidade e restrições

A operação é especificada como não segura para threads (not thread-safe) [SWS_CORE_06551]. No caso de uso concorrente da mesma instância de alocador, uma sincronização externa provavelmente será necessária para evitar condições de corrida (data races). Além disso, a função reserva memória pura (interpretação: a construção de objetos na memória reservada cabe a mecanismos posteriores). Pergunta Q-c41df2caaeb4c503 (aberta)

A função de template construct da classe ara::core::PolymorphicAllocator ([SWS_CORE_06555]) serve para a criação síncrona de um objeto do tipo T no endereço de memória fornecido p com o encaminhamento dos argumentos args.... Ela é definida por meio do cabeçalho ara/core/memory_resource.h e segue essencialmente os requisitos de [mem.poly.allocator.class].

Um desvio explícito do padrão C++ diz respeito ao tratamento de exceções: de acordo com [SWS_CORE_06555], a função é declarada condicionalmente como noexcept, dependendo se std::is_nothrow_constructible<T, Args...>::value se aplica. A especificação atribui a ela, assim, o atributo conditionally exception safe. Interpretação: Desde que T não possa ser construído livre de exceções, eventuais exceções do construtor devem ser propagadas livremente ao chamador, pois não estão definidos códigos de erro internos nem mecanismos especiais de interceptação. Pergunta Q-ad77510f396e59ae (aberta)

Em relação à concorrência e às condições de contorno, construct é especificado como não seguro para threads (not thread-safe) ([SWS_CORE_06555]). Em acessos paralelos à mesma instância de Allocator ou à mesma região de memória, uma sincronização externa no contexto de chamada é, portanto, estritamente necessária.

O padrão arquitetural de uma declaração noexcept dependente do tipo corresponde às convenções em ara::core, como também empregado, entre outros, nos construtores de ara::core::Result ([SWS_CORE_00725], [SWS_CORE_00726]).

usar

A função-membro deallocate da classe ara::core::PolymorphicAllocator libera memória previamente alocada para n objetos do tipo Tp a partir do endereço p [SWS_CORE_06548]. A declaração ocorre por meio do cabeçalho ara/core/memory_resource.h [SWS_CORE_06548]. A função segue fundamentalmente a semântica do alocador C++ padrão de acordo com [mem.poly.allocator.class], mas apresenta dois desvios específicos [SWS_CORE_06548].

Tratamento de erros e segurança de exceções

Como desvio essencial, a operação é declarada como noexcept e especificada como segura contra exceções (exception safe) [SWS_CORE_06548]. Se a liberação da memória falhar, os erros ocorridos serão ignorados silenciosamente (silently ignored), de modo que nenhuma exceção é lançada nem códigos de erro explícitos são retornados [SWS_CORE_06548].

Concorrência e interação

Em relação ao contexto de chamada, deallocate é classificada como não thread-safe (not thread-safe) [SWS_CORE_06548]. No conceito de gerenciamento de memória, esta função corresponde ao método deallocate da classe base subjacente ara::core::MemoryResource [SWS_CORE_06504], para a qual se aplicam os mesmos desvios quanto a noexcept e ao tratamento silencioso de erros.

A função deallocate_bytes da classe ara::core::PolymorphicAllocator serve para a liberação de uma região de memória previamente alocada de acordo com [SWS_CORE_06550]. Ela é disponibilizada por meio do cabeçalho ara/core/memory_resource.h e orienta-se essencialmente pela semântica de [mem.poly.allocator.class].

A chamada ocorre de forma síncrona e espera os seguintes parâmetros, de acordo com [SWS_CORE_06550]:

• p: ponteiro (void*) para a região de memória a ser liberada.
• nbytes: tamanho da memória a ser liberada em bytes (std::size_t).
• alignment: alinhamento desejado (valor padrão alignof(std::max_align_t)).

Em relação ao comportamento de falha, a implementação apresenta desvios específicos em relação ao padrão: a função é declarada como noexcept e considerada segura contra exceções (exception safe). Se a liberação falhar, os erros ocorridos são silenciosamente ignorados (silently ignored), de acordo com [SWS_CORE_06550]. Nenhuma exceção é lançada e nenhum valor de retorno é fornecido.

Em relação à concorrência e às restrições, a função é especificada explicitamente como não segura para threads (not thread-safe) [SWS_CORE_06550]. Um acesso concorrente à mesma instância de alocador sem sincronização externa provavelmente levaria, portanto, a um comportamento indefinido. Pergunta Q-33c80e3bb50ed64f (aberta)

A função de template deallocate_object da classe ara::core::PolymorphicAllocator serve para a liberação de memória de objetos previamente reservada [SWS_CORE_06552]. Ela se orienta pelo uso correspondente do padrão C++ de acordo com [mem.poly.allocator.class], apresentando, no entanto, desvios específicos [SWS_CORE_06552].

Em relação aos parâmetros e ao contexto de chamada, aplicam-se as seguintes propriedades [SWS_CORE_06552]:

• Assinatura: template <class T> void deallocate_object (T *p, std::size_t n=1) noexcept; [SWS_CORE_06552].
• Cabeçalho: A função está disponível via #include "ara/core/memory_resource.h" [SWS_CORE_06552].
• Valor de retorno: A operação não fornece valor de retorno (void) [SWS_CORE_06552].
• Comportamento de ponteiro nulo: Como desvio explícito, é especificado que a função atua ou suporta ponteiros nulos na passagem de nullptr («Function is nullptr») [SWS_CORE_06552].

Quanto ao tratamento de erros, a função é declarada como noexcept e considerada segura contra exceções (exception safe) [SWS_CORE_06552]. Se uma desalocação falhar, os erros ocorridos são silenciosamente ignorados («errors will be silently ignored»), de modo que nenhuma exceção seja propagada para o exterior [SWS_CORE_06552].

Como restrição essencial, deallocate_object é classificado como não seguro para threads (not thread-safe) [SWS_CORE_06552]. Em acessos paralelos à mesma instância de Allocator a partir de várias threads, as chamadas devem, portanto, ser protegidas por mecanismos externos de sincronização.

A função membro delete_object da classe ara::core::PolymorphicAllocator serve, de acordo com [SWS_CORE_06554], para a destruição e liberação de um objeto do tipo T apontado pelo ponteiro fornecido p. A função é disponibilizada por meio do arquivo de cabeçalho #include "ara/core/memory_resource.h" e segue o comportamento de [mem.poly.allocator.class] com desvios específicos.

Em relação ao contexto de chamada e à semântica, aplicam-se as seguintes propriedades:

• Valor de retorno e exceções: A função não possui valor de retorno (void). Ela é condicionalmente segura contra exceções (conditionally noexcept) com a especificação noexcept(std::is_nothrow_destructible<T>::value), ou seja, não lança exceções desde que o destrutor de T seja declarado como não lançador [SWS_CORE_06554].
• Tratamento de erros: Se a operação falhar, os erros ocorridos são silenciosamente ignorados (errors will be silently ignored) [SWS_CORE_06554]. Interpretação: Os chamadores, portanto, não recebem mensagem de erro, código de erro nem exceção em caso de falha. Pergunta Q-9393b0f68a055e4b (aberta)
• Segurança de threads: A operação é especificada como não segura para threads (not thread-safe) [SWS_CORE_06554]. No uso concorrente do mesmo alocador entre múltiplas threads, a sincronização cabe ao chamador.

usar

A função membro de template destroy da classe ara::core::PolymorphicAllocator ([SWS_CORE_06556]) serve para a destruição de um objeto do tipo T para o qual o ponteiro p aponta. A função é declarada no cabeçalho ara/core/memory_resource.h e segue essencialmente o comportamento padronizado de [mem.poly.allocator.class] ([SWS_CORE_06556]). A chamada de método não fornece valor de retorno e é executada sincronicamente no contexto da thread chamadora. Interpretação: Pressupõe-se aqui que p aponte para um objeto válido, previamente instanciado. Pergunta Q-a4faf7034eb683dd (aberta)

Tratamento de erros e segurança de exceções

Em relação ao tratamento de erros, a função é classificada como condicionalmente segura contra exceções (conditionally exception safe) ([SWS_CORE_06556]). Como desvio específico do requisito padrão [mem.poly.allocator.class], destroy é declarada condicionalmente com noexcept(std::is_nothrow_destructible<T>::value) ([SWS_CORE_06556]). Se o destrutor do tipo fornecido T não lançar exceções, a ausência de exceções aplica-se a toda a chamada; caso contrário, exceções resultantes do destrutor podem escapar.

Simultaneidade e restrições

Quanto ao comportamento de concorrência, destroy é especificado como não seguro para threads (not thread-safe) ([SWS_CORE_06556]). Se várias threads acessarem simultaneamente a mesma instância de ara::core::PolymorphicAllocator ou o objeto a ser destruído, mecanismos externos adequados de sincronização devem ser estabelecidos.

A função membro de template new_object da classe ara::core::PolymorphicAllocator (definida em #include "ara/core/memory_resource.h") aloca memória de forma síncrona e constrói um objeto do tipo T com os argumentos de construtor fornecidos ctor_args [SWS_CORE_06553].

O uso está sujeito às seguintes definições e desvios do padrão [mem.poly.allocator.class] [SWS_CORE_06553]:

• Chamada e valor de retorno: Em caso de criação bem-sucedida do objeto, é retornado um ponteiro tipado T* para a nova instância. O atributo [[nodiscard]] obriga os chamadores a avaliar o valor de retorno.
• Tratamento de erros: No caso de falha, diferentemente de [mem.poly.allocator.class], nenhuma exceção é disparada, mas nullptr é retornado. O chamador deve, portanto, verificar obrigatoriamente se o ponteiro resultante é nullptr antes do acesso.
• Segurança contra exceções: A função é especificada como condicionalmente segura contra exceções (conditionally exception safe). Ela é noexcept se, e somente se, a própria criação do objeto garantir que nenhuma exceção será lançada (noexcept(std::is_nothrow_constructible<T, CtorArgs...>::value)).
• Concorrência: A função é declarada como não segura para threads (not thread-safe). Interpretação: No caso de acesso simultâneo à mesma instância de ara::core::PolymorphicAllocator, o chamador provavelmente é responsável por uma sincronização externa adequada. Pergunta Q-3d0ecfe34187c91e (aberta)

O método resource é uma função membro constante da classe ara::core::PolymorphicAllocator do arquivo de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_06557]. Ele serve, de acordo com a referência de especificação a [mem.poly.allocator.class], para a obtenção síncrona do recurso de memória associado [SWS_CORE_06557].

Uso e assinatura

A assinatura da função é MemoryResource * resource () const noexcept; [SWS_CORE_06557]. A chamada ocorre sem parâmetros e de forma síncrona em uma instância de ara::core::PolymorphicAllocator. Como valor de retorno, a função fornece um ponteiro do tipo MemoryResource* [SWS_CORE_06557]. Interpretação: O ponteiro retornado provavelmente aponta diretamente para o recurso de memória concreto que o alocador utiliza para operações de memória. Pergunta Q-392683a38a4e490b (aberta)

Tratamento de erros e simultaneidade

• Segurança contra exceções: A função é declarada como noexcept e classificada como exception safe [SWS_CORE_06557]. Ela não lança exceções e não há códigos de erro específicos definidos.
• Segurança de threads: A especificação classifica o método explicitamente como thread-safe [SWS_CORE_06557]. Pela qualificação como const, o acesso concorrente de leitura entre várias threads é seguro.

Interação

No módulo core, resource disponibiliza a interface para consultar o MemoryResource encapsulado por ara::core::PolymorphicAllocator e acionar suas operações [SWS_CORE_06557].

usar

A função membro select_on_container_copy_construction pertence ao escopo da classe ara::core::PolymorphicAllocator e é declarada por meio do arquivo de cabeçalho #include "ara/core/memory_resource.h" ([SWS_CORE_06573]). Ela é chamada sincronicamente para criar uma nova instância de PolymorphicAllocator na construção por cópia de um contêiner ([SWS_CORE_06573]). O comportamento funcional segue a especificação [mem.poly.allocator.class] ([SWS_CORE_06573]). Interpretação: O alocador resultante provavelmente é construído por padrão e, portanto, recorre ao recurso de memória padrão, em vez de copiar compulsoriamente o recurso de memória do contêiner de origem. Pergunta Q-134ed967dc22e133 (aberta)

Tratamento de erros e segurança de exceções

Um desvio central em relação à especificação geral do C++ consiste no fato de a função ser declarada explicitamente como noexcept no AUTOSAR ([SWS_CORE_06573]). A execução é definida como segura contra exceções (exception safe) ([SWS_CORE_06573]). Códigos de erro específicos, valores de retorno para indicação de erros ou mensagens para DET ou DEM não estão previstos para esta interface, visto que a chamada termina garantidamente sem erros.

Simultaneidade e restrições

Segundo a especificação, a função é classificada como not thread-safe ([SWS_CORE_06573]). Isso significa que chamadas simultâneas na mesma instância de PolymorphicAllocator a partir de várias threads sem sincronização externa podem levar a condições de corrida (data races). Antes de copiar um contêiner em ambientes concorrentes, o acesso ao objeto alocador deve ser protegido pelo usuário.