flusso tensoriale:: servendo:: BasicManager
Questa è una classe astratta.#include <basic_manager.h>Aiuta a gestire il ciclo di vita dei servable, inclusi il caricamento, il servizio e lo scarico.
Riepilogo
Il gestore accetta servable sotto forma di Loader.
Iniziamo a gestire un servibile tramite uno dei metodi ManageServable*. Si può andare avanti per caricare il servibile dopo questo chiamando LoadServable () . Il caricamento renderà anche il pubblicabile disponibile per il servizio. Una volta che si decide di scaricarlo, è possibile chiamare UnloadServable () su di esso, che renderà disponibile per servire, quindi scaricare il servibile.
Servables vengono mantenuti fino StopManagingServable () viene chiamato. Ciò consente a un manager di livello superiore con più informazioni di decidere quando è sicuro dimenticare un servibile.
BasicManager tiene traccia delle risorse (ad esempio RAM) utilizzati da servables caricati, e permette solo di caricare nuovi servables che si adattano all'interno del pool globale delle risorse.
BasicManager può essere configurato per utilizzare un pool di thread per farlo di carico e di singole discariche. Questo rende il LoadServable () e UnloadServable () metodi programmare il carico / singole discariche anziché eseguirli sincrono. Se sono presenti più carichi/scaricamenti 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 legano 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é potrebbe essere necessario attendere il completamento del caricamento/scaricamento di un servibile per definire la disponibilità delle risorse per il caricamento di un altro utilizzabile.
RICHIEDE:
- Ordine di chiamate di metodo - ManageServable () (e varianti) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
- Non pianificare carichi e scarichi simultanei dello stesso server.
- Non chiamare load o unload più volte sullo stesso servable.
Questa classe è thread-safe.
Esempio di utilizzo:
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 :: :: servire ResponsabileCostruttori e Distruttori | |
|---|---|
~BasicManager () Se configurato per utilizzare un pool di thread di caricamento/scaricamento, attende il completamento di tutti i caricamenti e scaricamenti pianificati, quindi elimina il set di thread. |
tipi pubblici | |
|---|---|
DoneCallback | usandostd::function< void(const Status &status)> Richiamata chiamata alla fine di {Load,Unload}Servable(). |
PreLoadHook | usandostd::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 Retrying il carico 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 utilizzabili disponibili, ad es |
LoadServable (const ServableId & id, DoneCallback done_callback) | void Carica il pubblicabile con questo ID e aggiorna anche la mappa di servizio. |
ManageServable (ServableData< std::unique_ptr< Loader >> servable) | Status Inizia a gestire il servibile. |
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 su questo, possono associare uno stato aggiuntivo al servibile. |
StopManagingServable (const ServableId & id) | Status Dice al manager di interrompere la gestione di questo servibile. |
UnloadServable (const ServableId & id, DoneCallback done_callback) | void Scarica il pubblicabile con questo ID e aggiorna anche la mappa di servizio. |
Strutture | |
|---|---|
| tensorflow :: :: servire BasicManager :: Opzioni | Opzioni di configurazione e gli oggetti inseribili che verranno utilizzati dal BasicManager . |
tipi pubblici
FattoRichiamata
std::function< void(const Status &status)> DoneCallback
Richiamata chiamata alla fine di {Load,Unload}Servable().
Passiamo lo stato dell'operazione al callback.
PreCaricamento
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
AnnullaCaricaServibileRiprova
void CancelLoadServableRetry( const ServableId & id )
Annulla Retrying il carico servibile durante LoadServable () .
Non fa nulla se il servibile non è gestito.
Se i tentativi vengono annullati, il servibile passa 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.
Ottieni stato di servizio aggiuntivo
T * GetAdditionalServableState( const ServableId & id )
RICHIEDE: questo gestore dovrebbe aver già gestito questo server, altrimenti restituiamo nullptr.
| Particolari | |
|---|---|
| ritorna | lo stato aggiuntivo per il servibile. Restituisce nullptr se non sono presenti ulteriori impostazioni dello stato o se è presente una mancata corrispondenza di 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
| Particolari | |
|---|---|
| ritorna | i nomi di tutti i servable gestiti da questo manager. I nomi saranno privi di duplicati e non in un ordine particolare. |
GetManagedServableStateSnapshot
optional< ServableStateSnapshot< T > > GetManagedServableStateSnapshot( const ServableId & id )
RICHIEDE: questo gestore avrebbe dovuto già gestire questo servibile, altrimenti restituiamo nullopt.
| Particolari | |
|---|---|
| ritorna | lo snapshot dello stato di un particolare servable-id gestito da questo gestore, se disponibile. |
OttieniIstantanee di StatoServibileGestito
std::vector< ServableStateSnapshot< T > > GetManagedServableStateSnapshots( const string & servable_name ) const
T è il tipo di stato aggiuntivo, se presente.
| Particolari | |
|---|---|
| ritorna | gli snapshot di stato di tutti i servable di un particolare 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 utilizzabili disponibili, ad es
ognuno di questi può essere recuperato utilizzando GetServableHandle.
Loadservable
void LoadServable( const ServableId & id, DoneCallback done_callback )
Carica il pubblicabile con questo ID e aggiorna anche la mappa di servizio.
Chiamate done_callback con ok se e solo se il servibile è stato caricato correttamente, altrimenti restituisce uno stato di errore.
Se si utilizza un pool di thread, questo metodo esegue la transizione del cablaggio servibile allo stato kLoading, pianifica il carico e restituisce, altrimenti completa il carico prima di tornare.
RICHIEDE: Questo manager dovrebbe avere gestisce questo servibile già, per essere caricato, altrimenti chiamiamo done_callback con uno stato di errore. Non chiamarlo più volte sullo stesso servibile. Solo uno di questi avrà esito positivo e il resto avrà esito negativo con uno stato di errore.
Gestisciservibile
Status ManageServable( ServableData< std::unique_ptr< Loader >> servable )
Inizia a gestire il servibile.
Restituisce un errore se viene fornito un server che è già gestito.
Se servibile è in stato di errore, questo metodo non restituisce un errore. Il manager, invece, accetta il servibile, 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 origini (ad es. percorso file non valido per i dati utilizzabili) e di quelli che si verificano nel gestore (ad es. risorse insufficienti per caricare i dati utilizzabili).
GestisciServableWithAdditionalState
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 su questo, possono associare uno stato aggiuntivo al servibile.
Lo stato aggiuntivo può essere ACL o metadati a vita per quel server. La proprietà dello Stato viene trasferita a questa classe.
Interrompi GestionePubblicabile
Status StopManagingServable( const ServableId & id )
Dice al manager di interrompere la gestione di questo servibile.
Richiede che il server sia attualmente gestito e che il suo stato sia {kNew, kError, kDisabled}.
ScaricaPubblicabile
void UnloadServable( const ServableId & id, DoneCallback done_callback )
Scarica il pubblicabile con questo ID e aggiorna anche la mappa di servizio.
Chiamate done_callback con ok se e solo se il servibile è stato scaricato con successo, altrimenti restituisce uno stato di errore.
Se si utilizza un pool di thread, questo metodo esegue la transizione del cablaggio servibile allo stato kQuiescing, pianifica lo scaricamento e restituisce, altrimenti completa lo scaricamento prima di tornare.
RICHIEDE: Questo manager dovrebbe avere caricato e reso questo servibile a disposizione, per essere scaricato, chiamate altro done_callback con uno stato di errore. Non chiamarlo più volte sullo stesso servibile. Solo uno di questi avrà esito positivo e il resto avrà esito negativo con uno stato di errore.
~BasicManager
~BasicManager() override
Se configurato per utilizzare un pool di thread di caricamento/scaricamento, attende il completamento di tutti i caricamenti e scaricamenti pianificati, quindi elimina il set di thread.