Unisciti alla community di SIG TFX-Addons e aiutaci a rendere TFX ancora migliore! Iscriviti a SIG TFX-Addons

tensorflow :: servendo:: BasicManager

Questa è una classe astratta.

#include <basic_manager.h>

Aiuta a gestire il ciclo di vita dei servizi, incluso il caricamento, il servizio e lo scarico.

Sommario

Il gestore accetta servizi in forma di caricatori.

Iniziamo a gestire un servable tramite uno dei metodi ManageServable *. Puoi continuare a caricare il servable dopo questo chiamando LoadServable () . Il caricamento renderà anche il pubblicabile disponibile per la pubblicazione. Una volta deciso di scaricarlo, puoi chiamare UnloadServable () su di esso, che lo renderà non disponibile per la pubblicazione, quindi scaricare il servable.

I servable vengono conservati fino a quando non viene chiamato StopManagingServable () . Ciò consente a un manager di livello superiore con più informazioni di decidere quando è sicuro dimenticare un servable.

BasicManager tiene traccia delle risorse (ad es. RAM) utilizzate dai servable caricati e consente solo il caricamento di nuovi servable che si adattano al pool di risorse complessivo.

BasicManager può essere configurato per utilizzare un pool di thread per eseguire il caricamento e lo scaricamento. Questo fa sì che i metodi LoadServable () e UnloadServable () pianifichino il caricamento / scaricamento anziché eseguirli in modo sincrono. Se sono presenti più operazioni di caricamento / scaricamento in sospeso rispetto ai thread nel pool di thread, vengono elaborati in ordine FIFO.

In presenza di caricatori che sovrastimano le esigenze di risorse dei loro servable e / o collegano solo le risorse dei loro servable alle istanze del dispositivo, la concorrenza di caricamento / scaricamento può essere ridotta al di sotto della dimensione del pool di thread. Questo perché potremmo dover attendere il termine del caricamento / scaricamento di un servable per bloccare la disponibilità delle risorse per il caricamento di un altro servable.

RICHIEDE:

  1. Ordine delle chiamate al metodo - ManageServable () (e varianti) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. Non pianificare il caricamento e lo scaricamento simultanei dello stesso servable.
  3. Non chiamare load o unload più volte sullo stesso servable.

Questa classe è thread-safe.

Utilizzo di esempio:

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));  

Eredità

Eredita da: tensorflow :: serving :: Manager

Costruttori e distruttori

~BasicManager ()
Se configurato per utilizzare un pool di thread di caricamento / scaricamento, attende che tutti i caricamenti e gli scaricamenti pianificati siano terminati e quindi distrugge il set di thread.

Tipi pubblici

DoneCallback utilizzando
std::function< void(const Status &status)>
Callback chiamato alla fine di {Load, Unload} Servable ().
PreLoadHook utilizzando
std::function< void(const ServableId &)>

Classi di amici

test_util::BasicManagerTestAccess
friend class

Funzioni statiche pubbliche

Create ( Options options, std::unique_ptr< BasicManager > *manager)
Status

Funzioni pubbliche

CancelLoadServableRetry (const ServableId & id)
void
Annulla il nuovo tentativo di caricamento servibile 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 >
Ottiene un elenco di tutti gli ID pubblicabili disponibili, ad es
LoadServable (const ServableId & id, DoneCallback done_callback)
void
Carica il servable con questo ID e aggiorna anche la mappa di servizio.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)
Status
Inizia a gestire il servable.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)
Status
Simile al metodo precedente, ma i chiamanti, di solito altri gestori costruiti sopra questo, possono associare uno stato aggiuntivo al servable.
StopManagingServable (const ServableId & id)
Status
Indica al manager di interrompere la gestione di questo servibile.
UnloadServable (const ServableId & id, DoneCallback done_callback)
void
Scarica il servable con questo ID e aggiorna anche la mappa di servizio.

Structs

tensorflow :: serving :: BasicManager :: Opzioni

Opzioni di configurazione e oggetti collegabili che verranno utilizzati dal BasicManager .

Tipi pubblici

DoneCallback

std::function< void(const Status &status)> DoneCallback

Callback chiamato alla fine di {Load, Unload} Servable ().

Passiamo lo stato dell'operazione alla richiamata.

PreLoadHook

std::function< void(const ServableId &)> PreLoadHook

Classi di amici

test_util :: BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

Funzioni statiche pubbliche

Creare

Status Create(
  Options options,
  std::unique_ptr< BasicManager > *manager
)

Funzioni pubbliche

CancelLoadServableRetry

void CancelLoadServableRetry(
  const ServableId & id
)

Annulla il nuovo tentativo di caricamento servibile durante LoadServable () .

Non fa nulla se il servable non è gestito.

Se i nuovi tentativi vengono annullati, il servable entra in uno stato dipendente dall'ultimo Load () chiamato su di esso. Se l'ultimo Load () ha avuto successo, sarà nello stato kReady, altrimenti in kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

RICHIEDE: Questo gestore avrebbe dovuto gestire già questo servable, altrimenti restituiamo nullptr.

Dettagli
ritorna
lo stato aggiuntivo per il servibile. Restituisce nullptr se non esiste un'ulteriore configurazione dello stato o se c'è una mancata corrispondenza del tipo tra ciò che è stato impostato e ciò che viene richiesto.

GetAvailableUntypedServableHandles

virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > > GetAvailableUntypedServableHandles() const override

GetManagedServableNames

std::vector< string > GetManagedServableNames() const 

Dettagli
ritorna
i nomi di tutti i servizi gestiti da questo gestore. I nomi saranno privi di duplicati e non in un ordine particolare.

GetManagedServableStateSnapshot

optional< ServableStateSnapshot< T > > GetManagedServableStateSnapshot(
  const ServableId & id
)

RICHIEDE: Questo manager avrebbe dovuto gestire già questo servable, altrimenti torniamo nullopt.

Dettagli
ritorna
l'istantanea dello stato di un particolare servable-id gestito da questo gestore, se disponibile.

GetManagedServableStateSnapshots

std::vector< ServableStateSnapshot< T > > GetManagedServableStateSnapshots(
  const string & servable_name
) const 

T è il tipo di stato aggiuntivo, se esiste.

Dettagli
ritorna
gli snapshot di stato di tutti i servables di un determinato flusso, gestiti da questo gestore.

GetUntypedServableHandle

virtual Status GetUntypedServableHandle(
  const ServableRequest & request,
  std::unique_ptr< UntypedServableHandle > *untyped_handle
) override

ListAvailableServableIds

virtual std::vector< ServableId > ListAvailableServableIds() const override

Ottiene un elenco di tutti gli ID pubblicabili disponibili, ad es

ognuno di questi può essere recuperato utilizzando GetServableHandle.

LoadServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Carica il servable con questo ID e aggiorna anche la mappa di servizio.

Chiama done_callback con ok se e solo se il servable è stato caricato correttamente, altrimenti restituisce uno stato di errore.

Se si utilizza un pool di thread, questo metodo fa passare il cablaggio servibile allo stato kLoading, pianifica il carico e ritorna, altrimenti completa il caricamento prima di tornare.

RICHIEDE: Questo gestore avrebbe dovuto gestire già questo servable, perché fosse caricato, altrimenti chiamiamo done_callback con uno stato di errore. Non chiamare più volte sullo stesso servable. Solo uno di questi avrà successo e il resto fallirà con uno stato di errore.

ManageServable

Status ManageServable(
  ServableData< std::unique_ptr< Loader >> servable
)

Inizia a gestire il servibile.

Restituisce un errore se viene fornito un servable già gestito.

Se servable è in uno stato di errore, questo metodo non restituisce un errore. Invece, il manager accetta il servable, lo mette nello stato kError (con una notifica inviata al bus degli eventi), e poi smette immediatamente di gestirlo. Questo comportamento facilita la gestione uniforme degli errori che si verificano nelle sorgenti (ad es. Percorso file non valido per dati servibili) e quelli che si verificano nel gestore (ad es. Risorse insufficienti per caricare servibili).

ManageServableWithAdditionalState

Status ManageServableWithAdditionalState(
  ServableData< std::unique_ptr< Loader >> servable,
  std::unique_ptr< T > additional_state
)

Simile al metodo precedente, ma i chiamanti, di solito altri gestori costruiti sopra questo, possono associare uno stato aggiuntivo al servable.

Lo stato aggiuntivo può essere ACL o metadati a vita per quel servizio. La proprietà dello Stato viene trasferita a questa classe.

StopManagingServable

Status StopManagingServable(
  const ServableId & id
)

Dice al manager di interrompere la gestione di questo servibile.

Richiede che il servable sia attualmente gestito e che il suo stato sia uno tra {kNew, kError, kDisabled}.

UnloadServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Scarica il servable con questo ID e aggiorna anche la mappa di servizio.

Chiama done_callback con ok se e solo se il servable è stato scaricato con successo, altrimenti restituisce uno stato di errore.

Se si utilizza un pool di thread, questo metodo fa passare il cablaggio servibile allo stato kQuiescing, pianifica lo scaricamento e ritorna, altrimenti completa lo scaricamento prima di tornare.

RICHIEDE: Questo gestore dovrebbe aver caricato e reso disponibile questo servable, affinché venga scaricato, altrimenti chiama done_callback con uno stato di errore. Non chiamare più volte sullo stesso servable. Solo uno di questi avrà successo e il resto fallirà con uno stato di errore.

~ BasicManager

 ~BasicManager() override

Se configurato per utilizzare un pool di thread di caricamento / scaricamento, attende che tutti i caricamenti e gli scaricamenti pianificati siano terminati e quindi distrugge il set di thread.