classe ara::core::MemoryResource

A função-membro allocate da classe ara::core::MemoryResource destina-se à alocação de memória linear com tamanho em bytes e alinhamento pré-definidos [SWS_CORE_06503]. Ela orienta-se pela interface padrão C++ [mem.res], mas desvia significativamente no tratamento de exceções [SWS_CORE_06503].

Utilização e parâmetros

A chamada ocorre de forma síncrona por meio dos parâmetros bytes (número de bytes a serem solicitados) e o opcional alignment, que é configurado por padrão como alignof(std::max_align_t) [SWS_CORE_06503]. O valor de retorno possui o atributo [[nodiscard]], razão pela qual o ponteiro fornecido do tipo void* deve obrigatoriamente ser avaliado no chamador [SWS_CORE_06503].

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

Diferentemente do comportamento padrão, a função não lança exceção do tipo std::bad_alloc em caso de erro, mas é declarada como noexcept e considerada segura contra exceções (exception safe) [SWS_CORE_06503]:

• Sucesso: Retorna um ponteiro válido para a região de memória alocada de acordo com [mem.res] [SWS_CORE_06503].
• Falha: Se a alocação de memória falhar, a função retorna nullptr em vez disso [SWS_CORE_06503]. O chamador deve, portanto, verificar sempre explicitamente se o resultado é um ponteiro nulo.

Concorrência e interação

A função é especificada como não thread-safe (not thread-safe) [SWS_CORE_06503]. Chamadas paralelas na mesma instância de MemoryResource exigem, consequentemente, sincronização externa pelo chamador. Esse padrão tolerante a falhas e livre de exceções é encontrado consistentemente em outros componentes de memória da AUTOSAR Adaptive: assim, ara::core::PolymorphicAllocator::allocate utiliza a mesma abordagem sem exceções [SWS_CORE_06547], e a instância especial NullMemoryResource também sinaliza esgotamento de memória retornando nullptr [SWS_CORE_06563].

A função deallocate da classe ara::core::MemoryResource serve para a liberação de regiões de memória de acordo com [SWS_CORE_06504]. O uso segue fundamentalmente o comportamento padrão de [mem.res], mas apresenta desvios específicos. A chamada ocorre de forma síncrona por meio da assinatura void deallocate(void *p, std::size_t bytes, std::size_t alignment=max_align) noexcept, sendo passados o ponteiro p para o bloco a ser liberado, o tamanho bytes e, opcionalmente, o alinhamento [SWS_CORE_06504].

Quanto ao comportamento em caso de erro, a função é especificada como noexcept e segura contra exceções (exception safe) [SWS_CORE_06504]. Se a liberação falhar, os erros serão ignorados silenciosamente (errors will be silently ignored) [SWS_CORE_06504]. Nenhuma exceção é lançada e nenhuma mensagem de erro é emitida via DET ou DEM.

Em relação à concorrência, a função é categorizada expressamente como não thread-safe (not thread-safe) [SWS_CORE_06504]. Acessos simultâneos à mesma instância de recurso devem, portanto, ser sincronizados externamente pelo chamador.

Na integração com o conceito de alocador, esta função corresponde à interface tipada deallocate da classe ara::core::PolymorphicAllocator de [SWS_CORE_06548], que apresenta desvios semelhantes em relação a noexcept e ao tratamento silencioso de erros.

O método puramente virtual do_allocate da classe ara::core::MemoryResource destina-se à alocação de blocos de memória com tamanho em bytes e alinhamento predefinidos [SWS_CORE_06566]. Como parâmetros, ele aceita a quantidade de bytes (bytes) bem como o alinhamento exigido (alignment). Em caso de alocação bem-sucedida, ele retorna sincronamente um ponteiro do tipo void * para a área de memória reservada [SWS_CORE_06566].

Com relação ao tratamento de erros, a função desvia deliberadamente do padrão C++ regular: ela é declarada como noexcept e, em caso de falhas, não lança uma exceção std::bad_alloc, mas retorna nullptr em seu lugar [SWS_CORE_06566]. Os chamadores devem, portanto, sempre verificar o resultado da alocação quanto a um ponteiro nulo.

Em relação à concorrência, o método é especificado como not thread-safe [SWS_CORE_06566]. Chamadas paralelas sobre a mesma instância requerem sincronização externa, a menos que a implementação derivada forneça sua própria proteção. Devido à visibilidade privada, a chamada pelos usuários normalmente deve ocorrer de forma indireta por meio da interface de nível superior da classe base. Pergunta Q-5cbdabf121ed4550 (aberta)

Na interação do gerenciamento de memória, o método forma o equivalente direto a do_deallocate, que é responsável pela liberação da memória alocada e ignora erros silenciosamente [SWS_CORE_06567]. A função de comparação do_is_equal verifica, além disso, se duas instâncias de recursos são compatíveis entre si em relação à alocação e à liberação [SWS_CORE_06568].

A função membro puramente virtual do_deallocate da classe ara::core::MemoryResource (declarada em ara/core/memory_resource.h) destina-se, de acordo com [SWS_CORE_06567], à liberação de memória previamente reservada. Ela recebe o ponteiro p para a área de memória, bem como seu tamanho bytes e o alinhamento exigido alignment. A semântica corresponde fundamentalmente ao padrão C++ [mem.res], apresentando contudo dois desvios significativos específicos da Adaptive [SWS_CORE_06567].

Em primeiro lugar, a função é declarada como noexcept e garante segurança contra exceções (exception safe) [SWS_CORE_06567]. Em segundo lugar, eventuais erros durante a liberação são ignorados silenciosamente, de modo que operações com falha não devem disparar mensagens de erro nem interromper o fluxo do programa [SWS_CORE_06567].

Em relação à concorrência, do_deallocate é especificado como not thread-safe e possui visibilidade private [SWS_CORE_06567]. Como detalhe de implementação de um recurso de memória polimórfico, ele deve ser executado de forma síncrona por meio da interface de chamada pública de nível superior. Pergunta Q-3f97e122ee7fb281 (aberta) Liberações concorrentes sobre o mesmo recurso devem ser sincronizadas de forma autônoma pelas classes derivadas, se necessário.

No módulo core, a função constitui a contrapartida para a alocação do_allocate [SWS_CORE_06566], que em caso de erro fornece nullptr em vez de uma exceção. A comparação com outros recursos ocorre por meio do método do_is_equal [SWS_CORE_06568], que, ao contrário da desalocação, é explicitamente definido como thread-safe.

A função-membro puramente virtual do_is_equal é declarada no cabeçalho #include "ara/core/memory_resource.h" no espaço de nomes de ara::core::MemoryResource ([SWS_CORE_06568]). De acordo com a especificação C++ [mem.res], ela serve para a comparação síncrona de igualdade do recurso de memória atual com uma referência transmitida const MemoryResource &other ([SWS_CORE_06568]). Como o método está definido com visibilidade privada (private), presume-se que a sua chamada seja processada como detalhe de implementação de forma polimórfica por meio da interface pública da classe ara::core::MemoryResource ([SWS_CORE_06568]). Pergunta Q-cbe02f652b43d6ec (aberta)

Em relação à execução e segurança contra falhas, do_is_equal está declarada como exception safe e noexcept ([SWS_CORE_06568]). Portanto, ela não pode lançar exceções sob nenhuma circunstância e sinaliza o resultado diretamente por meio do valor de retorno booleano ([SWS_CORE_06568]). Além disso, o método é especificado como thread-safe, de modo que implementações derivadas também devem garantir thread-safety em comparações concorrentes ([SWS_CORE_06568]).

Na interação com os demais métodos virtuais do gerenciamento de memória, do_is_equal completa o trio de pontos de customização das classes de recursos derivadas ([SWS_CORE_06568]). Enquanto a alocação de memória do_allocate fornece nullptr em caso de falha ([SWS_CORE_06566]) e do_deallocate ignora falhas silenciosamente ([SWS_CORE_06567]), ambas as funções são designadas, ao contrário de do_is_equal, como não thread-safe (not thread-safe) ([SWS_CORE_06566], [SWS_CORE_06567]). Isso enfatiza o requisito especial de do_is_equal para proteger comparações concorrentes de recursos ([SWS_CORE_06568]).