classe ara::core::UnsynchronizedPoolResource

A declaração do construtor de cópia como eliminado (=delete) em ara::core::UnsynchronizedPoolResource de acordo com [SWS_CORE_00046] impede qualquer duplicação de uma instância de pool. Em alternativa, para a criação de objetos estão disponíveis construtores específicos, por exemplo sem argumentos [SWS_CORE_00063], com especificação de um recurso de memória a montante [SWS_CORE_00064], com PoolOptions [SWS_CORE_00068] ou com ambos os parâmetros [SWS_CORE_00067].

Para a utilização e o comportamento em tempo de execução aplicam-se as seguintes condições de enquadramento:

• Chamada e tratamento de erros: uma tentativa de cópia é rejeitada logo em tempo de compilação pelo compilador como erro. Falhas de alocação no uso posterior de memória através de do_allocate não conduzem a exceções, mas retornam nullptr [SWS_CORE_00058], enquanto erros de desalocação em do_deallocate são silenciosamente ignorados [SWS_CORE_00059].
• Concorrência: operações individuais de memória na instância estão declaradas como não seguras para threads [SWS_CORE_00058], [SWS_CORE_00059]. Interpretação: a eliminação do construtor de cópia deverá assegurar a responsabilidade exclusiva pelos blocos de memória geridos e evitar estados inconsistentes em caso de utilização paralela ou desalocação prematura através de release [SWS_CORE_00065]. Pergunta Q-d97dd87dddb2379d (aberta)
• Interação: a restrição corresponde ao operador de atribuição também eliminado [SWS_CORE_00047]. O destrutor da classe não é implementado como virtual [SWS_CORE_00062], enquanto verificações de identidade podem ser efetuadas através de do_is_equal [SWS_CORE_00060].

O operador de atribuição por cópia de ara::core::UnsynchronizedPoolResource é explicitamente declarado como excluído (=delete) de acordo com [SWS_CORE_00047]. A atribuição de uma instância a outra é, portanto, sintaticamente excluída e resulta em um erro de compilador logo no momento da compilação. Juntamente com o construtor de cópia [SWS_CORE_00046], igualmente excluído, isso garante que instâncias da classe de recursos não possam ser copiadas nem duplicadas por atribuição. Interpretação: isso provavelmente deve evitar que blocos de memória internos e informações de gerenciamento sejam referenciados múltiplas vezes ou desalocados incorretamente. Pergunta Q-75cee08bebc61976 (aberta)

Novas instâncias são, em vez disso, criadas através dos construtores disponibilizados, por exemplo, sem parâmetros através de [SWS_CORE_00063], com recurso upstream através de [SWS_CORE_00064] ou especificando PoolOptions através de [SWS_CORE_00067] ou [SWS_CORE_00068]. O recurso upstream associado pode ser consultado através de [SWS_CORE_00056] e as opções de configuração através de [SWS_CORE_00057]. A memória gerenciada pode ser liberada explicitamente com [SWS_CORE_00065], antes que o tempo de vida termine com o destrutor não virtual [SWS_CORE_00062].

Como as atribuições são excluídas por [SWS_CORE_00047], as instâncias devem ser passadas por referência ou ponteiro quando necessário. Deve-se observar aqui que alocações através de [SWS_CORE_00058] e desalocações através de [SWS_CORE_00059] são especificadas como não seguras para threads. Se uma solicitação de memória falhar, nenhuma exceção é disparada, sendo retornado nullptr [SWS_CORE_00058]; erros na desalocação são ignorados silenciosamente [SWS_CORE_00059].

usar

O método upstream_resource() da classe ara::core::UnsynchronizedPoolResource retorna de forma síncrona um ponteiro para o MemoryResource superior [SWS_CORE_00056]. A chamada é sem parâmetros e declarada como const. A inclusão e as declarações de tipo ocorrem através do arquivo de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_00056].

Tratamento de erros

A função é especificada como noexcept bem como exception safe [SWS_CORE_00056]. Ela não dispara exceções e não reporta códigos de erro específicos nem eventos DET ou DEM. Caso a inicialização anterior através de construtores falhe, alguns deles não são seguros contra exceções [SWS_CORE_00063], enquanto a consulta em si permanece sempre livre de erros.

Simultaneidade e restrições

O método upstream_resource() é explicitamente classificado como thread-safe [SWS_CORE_00056]. Isso contrasta com as rotinas internas de alocação do_allocate() [SWS_CORE_00058] e do_deallocate() [SWS_CORE_00059], que são especificadas como not thread-safe. Além disso, o construtor de cópia e o operador de atribuição da classe foram excluídos [SWS_CORE_00046], [SWS_CORE_00047].

Interação

O método interage estreitamente com os construtores de UnsynchronizedPoolResource, aos quais pode ser passado opcionalmente um MemoryResource superior [SWS_CORE_00064], [SWS_CORE_00067]. Interpretação: o ponteiro retornado provavelmente deve apontar exatamente para a instância de MemoryResource definida na instanciação. Outras propriedades do recurso de pool podem ser consultadas através de options() [SWS_CORE_00057], enquanto a memória alocada pode ser liberada através de release() [SWS_CORE_00065]. Pergunta Q-aefbc7d0f7d085d1 (aberta)

usar

A função-membro options() da classe ara::core::UnsynchronizedPoolResource destina-se à consulta síncrona da configuração do pool de memória [SWS_CORE_00057]. O método é declarado em #include "ara/core/memory_resource.h", não espera parâmetros de entrada e retorna uma instância do tipo PoolOptions por valor [SWS_CORE_00057]. Como função qualificada como const, ela não modifica o objeto e comporta-se conforme a especificação em [mem.res.pool] [SWS_CORE_00057].

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

A interface está definida como noexcept e garante segurança completa contra exceções (exception safe) [SWS_CORE_00057]. Nenhuma exceção é lançada e não existem valores de retorno de erro; a consulta das opções é sempre bem-sucedida sem erros.

Simultaneidade e restrições

Na especificação, options() está indicada como segura para threads (thread-safe) [SWS_CORE_00057]. Isso contrasta com funções de alocação da mesma classe, como do_allocate [SWS_CORE_00058] e do_deallocate [SWS_CORE_00059], que explicitamente não são seguras para threads. O método pode, portanto, ser executado concorrentemente para a consulta de estado.

Interação

As PoolOptions retornadas refletem presumivelmente os parâmetros com os quais o recurso de pool foi parametrizado por meio dos construtores correspondentes [SWS_CORE_00067], [SWS_CORE_00068], ou representam as opções padrão ao usar construtores padrão [SWS_CORE_00063], [SWS_CORE_00064]. Pergunta Q-19fa8ad6e3e6b1c6 (aberta) Além de options(), a função upstream_resource() também está disponível para inspeção [SWS_CORE_00056], enquanto operações de cópia do recurso são impedidas por operadores excluídos [SWS_CORE_00046], [SWS_CORE_00047].

usar

O método do_allocate da classe ara::core::UnsynchronizedPoolResource aloca memória para o tamanho em bytes (bytes) e alinhamento (alignment) solicitados [SWS_CORE_00058]. Interpretação: uma vez que o método está especificado com visibilidade protegida (protected), no fluxo regular não deverá ser chamado diretamente pelo código da aplicação, mas sim indiretamente através da interface de alocação da classe base. Pergunta Q-5a702813496f8071 (aberta) A declaração é feita através do ficheiro de cabeçalho #include "ara/core/memory_resource.h" [SWS_CORE_00058].

Tratamento de erros

Ao contrário do comportamento padrão segundo [mem.res.pool], a função está declarada como noexcept e não lança nenhuma exceção como std::bad_alloc em caso de falhas de alocação [SWS_CORE_00058]. Em vez disso, retorna obrigatoriamente nullptr em caso de insucesso [SWS_CORE_00058]. Por conseguinte, o código chamador deve verificar sempre e explicitamente se o resultado é um ponteiro nulo.

Simultaneidade e restrições

A função está classificada como not thread-safe [SWS_CORE_00058]. Chamadas paralelas na mesma instância de UnsynchronizedPoolResource são inadmissíveis sem sincronização externa. O construtor de cópia e o operador de atribuição da classe estão eliminados (delete), de modo que as instâncias não podem ser copiadas ([SWS_CORE_00046], [SWS_CORE_00047]).

Interação

Para a libertação de memória existe a contrapartida do_deallocate, que também foi concebida como protegida, noexcept e não segura para threads, ignorando adicionalmente erros de forma silenciosa [SWS_CORE_00059]. O pool utiliza internamente o recurso a montante configurado durante a instanciação ([SWS_CORE_00056], [SWS_CORE_00064], [SWS_CORE_00067]). Com release(), a memória obtida do pool pode ser libertada em bloco [SWS_CORE_00065].

usar

A função-membro virtual do_deallocate está declarada como protected no âmbito de ara::core::UnsynchronizedPoolResource (cabeçalho #include "ara/core/memory_resource.h") [SWS_CORE_00059]. Assume a desalocação síncrona de um bloco de memória com base nos parâmetros passados p (ponteiro para a região de memória), bytes (tamanho em bytes) e alignment (alinhamento). Interpretação: como método protegido, a chamada deverá ocorrer tipicamente de forma indireta através da interface pública do recurso de memória. Pergunta Q-f4992f515c10ee01 (aberta)

Tratamento de erros

Em comparação com o comportamento padrão em [mem.res.pool], a função apresenta dois desvios específicos: está declarada como noexcept e, portanto, é segura contra exceções [SWS_CORE_00059]. Se a desalocação falhar, os erros são ignorados silenciosamente (errors will be silently ignored); não existe qualquer código de erro nem mensagem de erro dedicada.

Simultaneidade e restrições

A operação está explicitamente identificada como não segura para threads (not thread-safe) [SWS_CORE_00059]. Se regiões de memória da mesma instância de recurso forem libertadas a partir de múltiplas threads, o acesso deve ser obrigatoriamente sincronizado de forma externa.

Interação

O método complementa do_allocate [SWS_CORE_00058], o qual também está especificado como noexcept e não seguro para threads, retornando nullptr em caso de insucesso. Para libertar completamente toda a memória reservada do pool, está disponível o método seguro para threads release [SWS_CORE_00065]. As instâncias da classe não são copiáveis, uma vez que o construtor de cópia [SWS_CORE_00046] e o operador de atribuição [SWS_CORE_00047] estão eliminados.

A função-membro protegida do_is_equal da classe ara::core::UnsynchronizedPoolResource realiza a comparação de igualdade para recursos de memória de acordo com [SWS_CORE_00060]. Ela é disponibilizada por meio do cabeçalho ara/core/memory_resource.h. Como o método possui visibilidade protected, destina-se à chamada interna por meio da classe base MemoryResource ([SWS_CORE_00060]). Ela compara de forma síncrona a instância atual com uma referência transmitida do tipo MemoryResource e retorna um valor bool ([SWS_CORE_00060]). De acordo com [mem.res.pool], a comparação deve tipicamente verificar a identidade de ambos os recursos (this == &other), já que os pools de memória atuam de forma isolada. Pergunta Q-679a5e17d2e2903f (aberta)

O método é declarado como noexcept e possui a especificação exception safe ([SWS_CORE_00060]). Ele não lança exceções e não utiliza mensagens de erro DET ou DEM.

Em relação à concorrência, do_is_equal é classificada como thread-safe ([SWS_CORE_00060]). Como ela atua exclusivamente para leitura sendo uma função-membro constante, pode ser chamada de forma concorrente por múltiplas threads. Isto contrasta com operações de alocação como do_allocate ([SWS_CORE_00058]) e do_deallocate ([SWS_CORE_00059]), que explicitamente não são seguras para threads.

Na interação dos recursos de memória, a classe não permite cópia nem atribuição ([SWS_CORE_00046], [SWS_CORE_00047]). As instâncias podem ser inicializadas por meio de construtores como [SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067] ou [SWS_CORE_00068]. Fontes de memória de nível superior podem ser consultadas com upstream_resource() ([SWS_CORE_00056]), enquanto, antes da destruição ([SWS_CORE_00062]), a memória ocupada pode ser liberada mediante release() ([SWS_CORE_00065]).

O destrutor ~UnsynchronizedPoolResource() ([SWS_CORE_00062]) encerra o tempo de vida de uma instância da classe de memória ara::core::UnsynchronizedPoolResource do cabeçalho ara/core/memory_resource.h. A chamada ocorre sincronamente e está declarada como noexcept, tornando a operação segura contra exceções ([SWS_CORE_00062]).

A semântica corresponde fundamentalmente à utilização de pool em [mem.res.pool], mas apresenta uma divergência essencial: o destrutor não é virtual ([SWS_CORE_00062]). Interpretação: Do fato de o destrutor não ser virtual deverá resultar que as instâncias não podem ser liberadas polimorficamente através de um ponteiro de classe base para MemoryResource. Pergunta Q-5578b2bf008b98c5 (aberta)

Relativamente ao ciclo de vida e à interação, aplicam-se as seguintes condições:

• Gerenciamento de recursos: Na destruição da instância, a memória gerenciada é liberada, de forma análoga à liberação explícita através de release() ([SWS_CORE_00065]) em direção ao recurso de nível superior ([SWS_CORE_00056]).
• Concorrência: Embora o próprio destrutor esteja classificado como thread-safe ([SWS_CORE_00062]), as rotinas internas de alocação do_allocate ([SWS_CORE_00058]) e do_deallocate ([SWS_CORE_00059]) estão identificadas como não thread-safe. A chamada do destrutor não pode, portanto, ocorrer simultaneamente com processos de alocação da mesma instância.
• Criação e cópia: As instâncias podem ser construídas com ou sem opções e recurso upstream ([SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]). A construção por cópia e a atribuição por cópia estão excluídas ([SWS_CORE_00046], [SWS_CORE_00047]).

O construtor padrão sem parâmetros [SWS_CORE_00063] inicializa uma instância de ara::core::UnsynchronizedPoolResource de acordo com a semântica de [mem.res.pool]. Interpretação: Nisso deverão ser utilizadas opções de pool padrão e um recurso de memória upstream padrão, os quais podem ser consultados posteriormente via [SWS_CORE_00057] e [SWS_CORE_00056]. Pergunta Q-d76bae1c251fa516 (aberta)

Relativamente ao ciclo de vida e à utilização, aplicam-se as seguintes condições de enquadramento:

• Proteção contra cópia e sobrecarga: O construtor de cópia [SWS_CORE_00046] e o operador de atribuição [SWS_CORE_00047] estão excluídos (delete). Além da instanciação sem parâmetros, estão disponíveis construtores sobrecarregados com opções de pool explícitas ou recursos upstream ([SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]).
• Tratamento de erros e segurança contra exceções: O construtor está declarado como não seguro contra exceções (not exception safe) [SWS_CORE_00063]. Na operação posterior de memória, as operações de memória divergem de exceções padrão: do_allocate fornece nullptr em vez de uma exceção [SWS_CORE_00058] em caso de erro, enquanto do_deallocate ignora erros silenciosamente [SWS_CORE_00059].
• Concorrência: A chamada do construtor em si é thread-safe [SWS_CORE_00063]. Contudo, as operações posteriores de atribuição e liberação da instância criada (do_allocate, do_deallocate) estão explicitamente especificadas como não seguras para threads (not thread-safe) ([SWS_CORE_00058], [SWS_CORE_00059]).
• Liberação de recursos e destruição: A memória ocupada pode ser liberada via [SWS_CORE_00065]. O destrutor é noexcept, porém implementado como não virtual [SWS_CORE_00062].

Uso e finalidade

O construtor explicit UnsynchronizedPoolResource (MemoryResource *upstream) inicializa uma instância da classe ara::core::UnsynchronizedPoolResource a partir do arquivo de cabeçalho #include "ara/core/memory_resource.h" de acordo com [mem.res.pool] [SWS_CORE_00064]. Através do parâmetro upstream, é passado o recurso de memória de nível superior, que posteriormente pode ser consultado através do método upstream_resource() [SWS_CORE_00056]. Como alternativas, estão disponíveis um construtor padrão sem parâmetros [SWS_CORE_00063] bem como sobrecargas com PoolOptions [SWS_CORE_00067], [SWS_CORE_00068].

Tratamento de erros e comportamento com exceções

A instanciação é especificada como not exception safe [SWS_CORE_00064], de modo que exceções podem ocorrer durante a construção. Para alocações de memória posteriores, aplicam-se regras divergentes: a função de alocação interna do_allocate não lança exceção, mas retorna nullptr em caso de falhas [SWS_CORE_00058], enquanto erros em do_deallocate são silenciosamente ignorados [SWS_CORE_00059].

Simultaneidade e restrições

A chamada do construtor em si é considerada thread-safe [SWS_CORE_00064]. Operações de cópia são impedidas, pois tanto o construtor de cópia [SWS_CORE_00046] quanto o operador de atribuição [SWS_CORE_00047] estão excluídos. Após a construção, as operações de alocação e desalocação não são thread-safe [SWS_CORE_00058], [SWS_CORE_00059]. Além disso, o destrutor não é declarado como virtual [SWS_CORE_00062]. A memória alocada pode ser liberada prematuramente através de release() [SWS_CORE_00065]. Interpretação: como um ponteiro nativo upstream é passado, o recurso upstream referenciado provavelmente deve permanecer válido durante toda a vida útil da instância do pool. Pergunta Q-3e6c23bae834b912 (aberta)

usar

A função-membro release() pertence ao âmbito da classe ara::core::UnsynchronizedPoolResource e é declarada através do ficheiro de cabeçalho ara/core/memory_resource.h [SWS_CORE_00065]. A função não possui parâmetros de passagem nem valor de retorno (void). A sua semântica funcional orienta-se pelo padrão C++ [mem.res.pool] [SWS_CORE_00065]; a referência deverá significar que a função devolve sincronicamente toda a memória alocada através da instância do pool ao recurso de memória a montante (upstream_resource()) [SWS_CORE_00056]. Pergunta Q-e0c7e00cde5d5a34 (aberta)

Tratamento de erros

A função está definida como noexcept bem como exception safe [SWS_CORE_00065]. Não dispara exceções durante a execução. Uma vez que a especificação não lista códigos de erro específicos nem mensagens DET/DEM, não ocorre nenhum feedback de erro explícito através de release() em caso de falhas na libertação de memória.

Simultaneidade e restrições

De acordo com a especificação, release() está classificado como thread-safe [SWS_CORE_00065]. Isto contrasta com as funções internas de gestão de memória da classe: tanto a alocação por meio de do_allocate [SWS_CORE_00058] como a desalocação através de do_deallocate [SWS_CORE_00059] estão explicitamente categorizadas como not thread-safe.

Interação

O método interage estreitamente com outras propriedades e requisitos de UnsynchronizedPoolResource:

• Recursos de memória: devolve a memória ao recurso a montante configurado [SWS_CORE_00056], sem que o próprio objeto de pool tenha de ser destruído, como acontece com o destrutor ~UnsynchronizedPoolResource() [SWS_CORE_00062].
• Configuração: o comportamento e os tamanhos dos chunks do pool dependem das opções definidas durante a instanciação [SWS_CORE_00057], [SWS_CORE_00067], [SWS_CORE_00068].
• Proteção contra cópia: a duplicação do pool é inadmissível, dado que o construtor de cópia [SWS_CORE_00046] e o operador de atribuição [SWS_CORE_00047] estão eliminados (delete).

O construtor [SWS_CORE_00067] inicializa uma instância de ara::core::UnsynchronizedPoolResource com opções específicas de pool (opts) e um recurso de memória superior (upstream). A chamada ocorre de forma síncrona e é especificada como noexcept, tornando a criação do objeto segura contra exceções. A cópia da instância está excluída, pois tanto o construtor de cópia [SWS_CORE_00046] quanto o operador de atribuição [SWS_CORE_00047] estão excluídos (=delete).

As configurações e recursos upstream armazenados podem ser lidos em tempo de execução através de options() [SWS_CORE_00057] e upstream_resource() [SWS_CORE_00056]. Como alternativas, estão disponíveis um construtor padrão [SWS_CORE_00063] bem como sobrecargas que aceitam exclusivamente upstream [SWS_CORE_00064] ou opts [SWS_CORE_00068]. A memória ocupada pode ser liberada através de release() [SWS_CORE_00065] ou pelo destrutor [SWS_CORE_00062], sendo que o destrutor, diferentemente do padrão, não é virtual.

Em relação à concorrência, a própria construção é declarada como thread-safe [SWS_CORE_00067]. As funções reais de gerenciamento de memória da instância – do_allocate [SWS_CORE_00058] e do_deallocate [SWS_CORE_00059] –, por outro lado, são expressamente não thread-safe («not thread-safe») e exigem mecanismos de proteção externos em caso de acesso paralelo. Os erros são processados sem exceções: alocações malsucedidas retornam nullptr [SWS_CORE_00058], enquanto erros de desalocação são silenciosamente ignorados [SWS_CORE_00059]. Interpretação: o objeto upstream passado provavelmente precisa permanecer válido durante todo o ciclo de vida do pool. Pergunta Q-2439ec8f9fb8bb3e (aberta)

O construtor [SWS_CORE_00068] serve para a inicialização síncrona de um ara::core::UnsynchronizedPoolResource com especificação de parâmetros de configuração específicos através do parâmetro opts (tipo PoolOptions). O comportamento orienta-se pelo padrão [mem.res.pool] do arquivo de cabeçalho ara/core/memory_resource.h. As configurações passadas podem ser obtidas após a instanciação com options() [SWS_CORE_00057], enquanto o gerenciador de memória upstream pode ser acessado através de upstream_resource() [SWS_CORE_00056].

Em relação ao tratamento de erros, a função é especificada como não segura contra exceções („not exception safe”) [SWS_CORE_00068]. Interpretação: se a disponibilização interna de estruturas de gerenciamento falhar durante a instanciação, uma exceção provavelmente será lançada, diferenciando esta chamada da variante noexcept [SWS_CORE_00067]. Pergunta Q-479a016f4e0ddde7 (aberta) Enquanto o construtor em si é classificado como seguro para threads („thread-safe”) [SWS_CORE_00068], operações de memória posteriores da instância resultante, como do_allocate [SWS_CORE_00058] e do_deallocate [SWS_CORE_00059], são expressamente não seguras para threads („not thread-safe”); consequentemente, elas não devem ser executadas concorrentemente sem proteção.

Em conjunto com o ciclo de vida da classe, deve-se observar que a construção por cópia [SWS_CORE_00046] e o operador de atribuição [SWS_CORE_00047] foram excluídos (delete). A memória alocada permanece no pool até ser liberada via release() [SWS_CORE_00065] ou até que o objeto seja destruído através do destrutor não virtual [SWS_CORE_00062].