classe ara::core::SynchronizedPoolResource

Uso e semântica de alocação

A função-membro do_allocate da classe ara::core::SynchronizedPoolResource do arquivo de cabeçalho #include "ara/core/memory_resource.h" destina-se à alocação de áreas de memória com o tamanho em bytes bytes e alinhamento alignment especificados [SWS_CORE_00061]. Em caso de sucesso, a chamada síncrona retorna, conforme [mem.res.pool], um ponteiro válido do tipo void* para o bloco de memória alocado [SWS_CORE_00061].

Tratamento de erros e desvios

Em relação ao comportamento de erro, a implementação desvia-se explicitamente dos requisitos de [mem.res.pool]: o método é declarado como noexcept e não lança exceção std::bad_alloc [SWS_CORE_00061]. Em caso de falha da solicitação de memória, o ponteiro retornado é, em vez disso, obrigatoriamente nullptr [SWS_CORE_00061]. Portanto, os chamadores devem obrigatoriamente verificar se o valor de retorno é um ponteiro nulo para capturar erros de alocação de forma confiável.

Concorrência e interação

A função é especificada como exception safe e, ao contrário de outros recursos de memória, como thread-safe [SWS_CORE_00061]. Devido à sua visibilidade protected, na prática ela deve funcionar principalmente como uma sobrescrita interna da interface base puramente virtual do_allocate de ara::core::MemoryResource [SWS_CORE_06566]. Pergunta Q-95ba181693426bfc (aberta) Enquanto ara::core::SynchronizedPoolResource protege o acesso concorrente [SWS_CORE_00061], implementações comparáveis como ara::core::UnsynchronizedPoolResource::do_allocate [SWS_CORE_00058] e ara::core::MonotonicBufferResource::do_allocate [SWS_CORE_06569] são definidas como not thread-safe.

A função-membro protegida do_deallocate da classe ara::core::SynchronizedPoolResource destina-se à liberação de uma área de memória previamente alocada conforme [SWS_CORE_00041]. Sua chamada ocorre de forma síncrona e espera como parâmetros um ponteiro p para a área de memória, o tamanho bytes em bytes e o alinhamento de memória alignment. Como a função-membro é declarada com visibilidade protected, ela provavelmente não é chamada diretamente no código de aplicação regular, mas executada por meio da interface pública de desalocação da classe base superior ara::core::MemoryResource ([SWS_CORE_06567]). Pergunta Q-badea921c907c214 (aberta)

Em relação ao tratamento de erros e ao comportamento de exceção, a especificação define dois desvios obrigatórios do padrão:

• A função é declarada como noexcept e totalmente segura para exceções (exception safe) ([SWS_CORE_00041]).
• Se a desalocação não for bem-sucedida, os erros ocorridos serão ignorados silenciosamente ([SWS_CORE_00041]). Não há lançamento de exceção nem retorno de código de erro.

No âmbito da concorrência, a implementação em ara::core::SynchronizedPoolResource destaca-se por ser explicitamente especificada como segura para threads (thread-safe) ([SWS_CORE_00041]). Assim, ela é adequada para a chamada simultânea a partir de múltiplas threads. Nisso ela se diferencia substancialmente dos recursos relacionados ara::core::UnsynchronizedPoolResource ([SWS_CORE_00059]) e ara::core::MonotonicBufferResource ([SWS_CORE_06570]), que são classificados como não seguros para threads.

A função-membro protegida do_is_equal verifica a igualdade de uma instância de ara::core::SynchronizedPoolResource com outro recurso de memória [SWS_CORE_00042]. Ela sobrescreve o método puramente virtual da classe base de ara::core::MemoryResource [SWS_CORE_06568] de acordo com a especificação para recursos de pool em [mem.res.pool].

Uso e interface: Como parâmetro, é passada uma referência para outro objeto ara::core::MemoryResource (const MemoryResource &other). O valor de retorno do tipo bool indica se ambos os recursos são equivalentes. Interpretação: Devido à visibilidade protected, a função não é chamada diretamente no fluxo regular da aplicação, mas é executada por meio do método público de comparação da classe base. Pergunta Q-29fb2980d1241fae (aberta)

Tratamento de erros e segurança: O método é declarado com o identificador noexcept e especificado como exception safe [SWS_CORE_00042]. Não ocorrem exceções nem códigos de erro específicos. A execução ocorre de forma síncrona.

Concorrência: De acordo com [SWS_CORE_00042], do_is_equal é especificado como thread-safe, de modo que comparações simultâneas entre várias threads são permitidas sem sincronização externa adicional.

Interação: A função constitui a contraparte thread-safe da implementação em ara::core::UnsynchronizedPoolResource [SWS_CORE_00060]. Da mesma forma, ara::core::MonotonicBufferResource fornece uma sobrescrita correspondente, que também é identificada como noexcept [SWS_CORE_06571].

A função-membro options da classe ara::core::SynchronizedPoolResource retorna síncronamente as definições configuradas para o recurso de memória do tipo PoolOptions [SWS_CORE_00039]. A chamada é feita sem parâmetros numa instância da classe e é declarada através do cabeçalho ara/core/memory_resource.h [SWS_CORE_00039]. O comportamento baseia-se, segundo a especificação, em [mem.res.pool] [SWS_CORE_00039], o que deverá ser interpretado como uma referência aos recursos de pool da norma C++. Pergunta Q-9abfddc2cf8dc88c (aberta)

No que concerne ao tratamento de erros e à segurança face a exceções, o método é declarado como noexcept e é considerado totalmente seguro face a exceções (exception safe) [SWS_CORE_00039]. Não existem códigos de erro específicos ou mensagens para o DET ou DEM para esta função de consulta.

Relativamente à concorrência, o método é especificado como const, bem como expressamente seguro para threads (thread-safe) [SWS_CORE_00039]. Pode, assim, ser chamado em paralelo e em segurança a partir de várias threads sem medidas adicionais de sincronização ao nível do utilizador.

Na interação dentro de ara::core, [SWS_CORE_00057] disponibiliza o equivalente não sincronizado: para ara::core::UnsynchronizedPoolResource existe uma função homónima e com a mesma assinatura options com semântica idêntica de acordo com [mem.res.pool].

A função-membro síncrona release() pertence à classe ara::core::SynchronizedPoolResource e é disponibilizada através do ficheiro de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_00037]. Possui a assinatura void release () noexcept;, não aceita parâmetros e não possui valor de retorno. A semântica funcional rege-se pela respetiva utilização em [mem.res.pool] [SWS_CORE_00037], libertando assim a memória gerida pelo recurso de memória.

Relativamente ao tratamento de erros, a função é declarada como segura contra exceções (exception safe) e noexcept [SWS_CORE_00037]. Não ocorrem exceções C++; códigos de erro específicos ou relatórios de erros através de DET ou DEM não são definidos no âmbito da especificação.

No que diz respeito à concorrência, a operação é expressamente especificada como segura para threads (thread-safe) [SWS_CORE_00037]. Uma chamada simultânea a partir de múltiplas threads sobre a mesma instância de recurso deverá, por conseguinte, ser admissível sem bloqueios adicionais do lado da aplicação. Pergunta Q-3da3b45ca2070b3e (aberta)

Na interação mútua, o comportamento corresponde ao do método funcionalmente idêntico em ara::core::UnsynchronizedPoolResource [SWS_CORE_00065], que remete igualmente para [mem.res.pool] e é identificado como noexcept e thread-safe. Em contrapartida, a função análoga release() de ara::core::MonotonicBufferResource [SWS_CORE_06530] não é, de acordo com a especificação, segura para threads (not thread-safe), embora esteja também sujeita à garantia noexcept.

usar

A função-membro upstream_resource() da classe ara::core::SynchronizedPoolResource fornece um ponteiro para o recurso de memória a montante subjacente (MemoryResource*) de acordo com [SWS_CORE_00038]. A chamada processa-se de forma síncrona e requer a inclusão do ficheiro de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_00038]. A função não aceita parâmetros de passagem e serve como puro inspetor para a unidade de gestão de memória a montante.

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

O método é declarado como noexcept e classificado, de acordo com a especificação, como seguro contra exceções (exception safe) [SWS_CORE_00038]. Uma falha da consulta ou o desencadeamento de exceções estão excluídos; não existem códigos de erro para esta chamada.

Simultaneidade e restrições

A função é especificada como const e explicitamente como segura para threads (thread-safe) [SWS_CORE_00038]. Ela pode, portanto, ser chamada concorrentemente a partir de múltiplos contextos de execução sem sincronização externa adicional.

Interação

O conceito de um recurso de memória upstream é fornecido de forma consistente em diferentes implementações de pool de memória do AUTOSAR Adaptive Core:

• Em ara::core::UnsynchronizedPoolResource, o método funcionalmente idêntico [SWS_CORE_00056] também disponibiliza um ponteiro para o recurso upstream, mas é direcionado a cenários de pool não sincronizados internamente.
• Em ara::core::MonotonicBufferResource, existe com [SWS_CORE_06531] um equivalente correspondente que também é especificado como noexcept e seguro para threads.