Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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:

  1. Ordem de chamadas de método - ManageServable () (e variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. Não agende carregamentos e descarregamentos simultâneos do mesmo serviço.
  3. 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 :: Gestor

Construtores 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 usando
std::function< void(const Status &status)>
Callback chamado no final de {Load, Unload} Servable ().
PreLoadHook usando
std::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.