tensorflow:: servindo:: BasicManager
Esta é uma classe abstrata.#include <basic_manager.h>Ajuda a gerenciar o ciclo de vida de serviços, incluindo carregamento, serviço e descarga.
Resumo
O gerenciador aceita serviços na forma de carregadores.
Começamos a gerenciar um servable por meio de um dos métodos ManageServable *. Você pode ir para carregar o que possa ser veiculado após isso chamando LoadServable () . O carregamento também tornará o servidor disponível para veiculação. Depois de decidir a descarregá-lo, você pode chamar UnloadServable () sobre ele, o que irá torná-lo indisponível para servir, em seguida, descarregar o que possa ser veiculado.
Servables são retidos até StopManagingServable () é chamado. Isso permite que um gerente de nível superior com mais informações decida quando é seguro esquecer um serviço.
BasicManager rastreia os recursos (por exemplo RAM) usados por servables carregados, e só permite carregar novos servables que se encaixam dentro do pool geral de recursos.
BasicManager pode ser configurado para usar um fio-pool de fazê-lo de carga e descarrega. Isso faz com que o LoadServable () e UnloadServable () métodos agendar a carga / descarrega em vez de executá-los de forma síncrona. Se houver mais carregamentos / descarregamentos pendentes do que encadeamentos no pool de encadeamentos, eles serão processados na ordem FIFO.
Na presença de carregadores que superestimam as necessidades de recursos de seus servables e / ou apenas vinculam os recursos de seus servables a instâncias de dispositivo, a simultaneidade de carga / descarga pode ser reduzida abaixo do tamanho do pool de threads. Isso ocorre porque podemos ter que esperar o carregamento / descarregamento de um servable terminar para definir a disponibilidade de recursos para carregar outro servable.
REQUER:
- Ordem de chamadas de método - ManageServable () (e variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
- Não agende carregamentos e descarregamentos simultâneos do mesmo serviço.
- Não chame load ou unload várias vezes no mesmo serviço.
Esta classe é segura para thread.
Exemplo de utilização:
const ServableId id = {kServableName, 0};
std::unique_ptr<Loader> loader = ...;
...
BasicManager manager;
TF_CHECK_OK(manager.ManageServable(
CreateServableData(id, std::move(loader))));
TF_CHECK_OK(manager.LoadServable(id));
...
TF_CHECK_OK(manager.GetServableHandle(
ServableRequest::Latest(kServableName), &handle));
...
TF_CHECK_OK(manager.UnloadServable(id));
TF_CHECK_OK(manager.StopManagingServable(id)); Herança
Herda: tensorflow :: servindo :: GestorConstrutores e Destruidores | |
|---|---|
~BasicManager () Se configurado para usar um pool de threads de carregamento / descarregamento, espera até que todas as cargas e descargas programadas tenham terminado e, a seguir, destrói o conjunto de threads. |
Tipos públicos | |
|---|---|
DoneCallback | usandostd::function< void(const Status &status)> Callback chamado no final de {Load, Unload} Servable (). |
PreLoadHook | usandostd::function< void(const ServableId &)> |
Aulas de amigos | |
|---|---|
test_util::BasicManagerTestAccess | friend class |
Funções estáticas públicas | |
|---|---|
Create ( Options options, std::unique_ptr< BasicManager > *manager) | Status |
Funções públicas | |
|---|---|
CancelLoadServableRetry (const ServableId & id) | void Cancela de repetir a carga que possa ser veiculado durante LoadServable () . |
GetAdditionalServableState (const ServableId & id) | T * |
GetAvailableUntypedServableHandles () const override | virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > > |
GetManagedServableNames () const | std::vector< string > |
GetManagedServableStateSnapshot (const ServableId & id) | optional< ServableStateSnapshot< T > > |
GetManagedServableStateSnapshots (const string & servable_name) const | std::vector< ServableStateSnapshot< T > > |
GetUntypedServableHandle (const ServableRequest & request, std::unique_ptr< UntypedServableHandle > *untyped_handle) override | virtual Status |
ListAvailableServableIds () const override | virtual std::vector< ServableId > Obtém uma lista de todos os IDs de serviço disponíveis, ou seja, |
LoadServable (const ServableId & id, DoneCallback done_callback) | void Carrega o servable com este id e atualiza o mapa de veiculação também. |
ManageServable (ServableData< std::unique_ptr< Loader >> servable) | Status Começa a gerenciar o servable. |
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state) | Status Semelhante ao método acima, mas os chamadores, geralmente outros gerenciadores construídos sobre este, podem associar um estado adicional ao servable. |
StopManagingServable (const ServableId & id) | Status Diz ao gerente para parar de gerenciar este serviço. |
UnloadServable (const ServableId & id, DoneCallback done_callback) | void Descarrega o servable com este id e atualiza o mapa de veiculação também. |
Structs | |
|---|---|
| tensorflow :: servindo :: BasicManager :: Opções | Opções de configuração e objetos conectáveis que serão utilizados pelo BasicManager . |
Tipos públicos
DoneCallback
std::function< void(const Status &status)> DoneCallback
Callback chamado no final de {Load, Unload} Servable ().
Passamos o status da operação para o callback.
PreLoadHook
std::function< void(const ServableId &)> PreLoadHook
Aulas de amigos
test_util :: BasicManagerTestAccess
friend class test_util::BasicManagerTestAccess
Funções estáticas públicas
Crio
Status Create( Options options, std::unique_ptr< BasicManager > *manager )
Funções públicas
CancelLoadServableRetry
void CancelLoadServableRetry( const ServableId & id )
Cancela de repetir a carga que possa ser veiculado durante LoadServable () .
Não faz nada se o serviço não for gerenciado.
Se as novas tentativas forem canceladas, o servable vai para um estado dependente do último Load () chamado nele. Se o último Load () foi bem-sucedido, ele estará no estado kReady, senão em kError.
GetAdditionalServableState
T * GetAdditionalServableState( const ServableId & id )
REQUER: Este gerenciador já deveria estar gerenciando este servable, caso contrário, retornaremos nullptr.
| Detalhes | |
|---|---|
| Devoluções | o estado adicional para o serviço. Retorna nullptr se não houver configuração de estado adicional ou se houver uma incompatibilidade de tipo entre o que foi configurado e o que está sendo solicitado. |
GetAvailableUntypedServableHandles
virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > > GetAvailableUntypedServableHandles() const override
GetManagedServableNames
std::vector< string > GetManagedServableNames() const
| Detalhes | |
|---|---|
| Devoluções | os nomes de todos os servables gerenciados por este gerenciador. Os nomes estarão livres de duplicatas e não estarão em uma ordem específica. |
GetManagedServableStateSnapshot
optional< ServableStateSnapshot< T > > GetManagedServableStateSnapshot( const ServableId & id )
REQUER: Este gerenciador já deveria estar gerenciando este servable, caso contrário, retornaremos nullopt.
| Detalhes | |
|---|---|
| Devoluções | o instantâneo do estado de um determinado servable-id gerenciado por este gerenciador, se disponível. |
GetManagedServableStateSnapshots
std::vector< ServableStateSnapshot< T > > GetManagedServableStateSnapshots( const string & servable_name ) const
T é o tipo de estado adicional, se houver.
| Detalhes | |
|---|---|
| Devoluções | os instantâneos de estado de todos os servables de um determinado fluxo, gerenciados por este gerenciador. |
GetUntypedServableHandle
virtual Status GetUntypedServableHandle( const ServableRequest & request, std::unique_ptr< UntypedServableHandle > *untyped_handle ) override
ListAvailableServableIds
virtual std::vector< ServableId > ListAvailableServableIds() const override
Obtém uma lista de todos os IDs de serviço disponíveis, ou seja,
cada um deles pode ser recuperado usando GetServableHandle.
LoadServable
void LoadServable( const ServableId & id, DoneCallback done_callback )
Carrega o servable com este id e atualiza o mapa de veiculação também.
Chamadas done_callback com ok sse o que possa ser veiculado foi carregado com êxito, retorna outra pessoa um status de erro.
Se estiver usando um pool de encadeamentos, este método faz a transição do arnês de serviço para o estado kLoading, agenda a carga e retorna, caso contrário, conclui a carga antes de retornar.
RODA: Este gerente deveria ter vindo a gerir este que possa ser veiculado já, para que possa ser carregado, outra coisa que chamamos done_callback com um status de erro. Não chame isso várias vezes no mesmo serviço. Apenas um deles terá êxito e o restante falhará com um status de erro.
ManageServable
Status ManageServable( ServableData< std::unique_ptr< Loader >> servable )
Começa a gerenciar o servable.
Retorna um erro se for fornecido um servable que já está sendo gerenciado.
Se que possa ser veiculado está em um estado de erro, este método não retorna um erro. Em vez disso, o gerenciador aceita o serviço, coloca-o no estado kError (com uma notificação enviada ao barramento de eventos) e para imediatamente de gerenciá-lo. Esse comportamento facilita o tratamento uniforme de erros que ocorrem nas origens (por exemplo, caminho de arquivo inválido para dados de serviço) e aqueles que ocorrem no gerenciador (por exemplo, recursos insuficientes para carregar o serviço).
ManageServableWithAdditionalState
Status ManageServableWithAdditionalState( ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state )
Semelhante ao método acima, mas os chamadores, geralmente outros gerenciadores construídos sobre este, podem associar um estado adicional ao servable.
O estado adicional pode ser ACL ou metadados vitalícios para esse serviço. A propriedade do estado é transferida para esta classe.
StopManagingServable
Status StopManagingServable( const ServableId & id )
Diz ao gerente para parar de gerenciar este serviço.
Requer que o servidor esteja sendo gerenciado e que seu estado seja {kNew, kError, kDisabled}.
UnloadServable
void UnloadServable( const ServableId & id, DoneCallback done_callback )
Descarrega o servable com este id e atualiza o mapa de veiculação também.
Chamadas done_callback com ok sse o que possa ser veiculado foi descarregado com sucesso, retorna outra pessoa um status de erro.
Se estiver usando um pool de encadeamentos, este método faz a transição do arnês de serviço para o estado kQuiescing, agenda o descarregamento e retorna, caso contrário, ele conclui o descarregamento antes de retornar.
RODA: Este gerente deveria ter carregado e fez esta que possa ser veiculado disponíveis, para que possa ser descarregado, chamadas else done_callback com um status de erro. Não chame isso várias vezes no mesmo serviço. Apenas um deles terá êxito e o restante falhará com um status de erro.
~ BasicManager
~BasicManager() override
Se configurado para usar um pool de threads de carregamento / descarregamento, espera até que todas as cargas e descargas programadas tenham terminado e, a seguir, destrói o conjunto de threads.