Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Tensorflow :: Portion:: BasicManager

Dies ist eine abstrakte Klasse.

#include <basic_manager.h>

Hilft bei der Verwaltung des Lebenszyklus von Servables, einschließlich Laden, Servieren und Entladen.

Zusammenfassung

Der Manager akzeptiert Serviceleistungen in Form von Ladern.

Wir beginnen mit der Verwaltung eines Servables über eine der ManageServable * -Methoden. Anschließend können Sie das Servable laden, indem Sie LoadServable () aufrufen. Durch das Laden wird der Servable auch zum Servieren verfügbar. Sobald Sie sich zum Entladen entschieden haben, können Sie UnloadServable () aufrufen, wodurch die Bereitstellung nicht mehr möglich ist, und dann das Servable entladen.

Servables bleiben erhalten, bis StopManagingServable () aufgerufen wird. Auf diese Weise kann ein übergeordneter Manager mit mehr Informationen entscheiden, wann ein Servable sicher vergessen werden kann.

BasicManager verfolgt die Ressourcen (z. B. RAM), die von geladenen Servables verwendet werden, und ermöglicht nur das Laden neuer Servables, die in den gesamten Ressourcenpool passen.

BasicManager kann so konfiguriert werden, dass ein Thread-Pool zum Laden und Entladen verwendet wird. Dadurch planen die Methoden LoadServable () und UnloadServable () das Laden / Entladen, anstatt sie synchron auszuführen. Wenn im Thread-Pool mehr ausstehende Lade- / Entladevorgänge als Threads vorhanden sind, werden diese in FIFO-Reihenfolge verarbeitet.

Bei Loadern, die den Ressourcenbedarf ihrer Servables überschätzen und / oder nur die Ressourcen ihrer Servables an Geräteinstanzen binden, kann die Parallelität beim Laden / Entladen unter die Thread-Pool-Größe reduziert werden. Dies liegt daran, dass wir möglicherweise warten müssen, bis das Laden / Entladen eines Servables abgeschlossen ist, um die Ressourcenverfügbarkeit für das Laden eines anderen Servables festzulegen.

ERFORDERLICH:

  1. Reihenfolge der Methodenrufe - ManageServable () (und Varianten) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. Planen Sie nicht das gleichzeitige Laden und Entladen desselben Serviergeräts.
  3. Rufen Sie nicht mehrmals das Laden oder Entladen auf demselben Servable auf.

Diese Klasse ist threadsicher.

Anwendungsbeispiel:

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

Erbe

Erbt von: tensorflow :: Serving :: Manager

Konstruktoren und Destruktoren

~BasicManager ()
Wenn die Konfiguration für die Verwendung eines Thread-Pools zum Laden / Entladen konfiguriert ist, wird gewartet, bis alle geplanten Lade- und Entladevorgänge abgeschlossen sind, und anschließend der Thread-Satz zerstört.

Öffentliche Typen

DoneCallback mit
std::function< void(const Status &status)>
Rückruf am Ende von {Load, Unload} Servable ().
PreLoadHook mit
std::function< void(const ServableId &)>

Freund Klassen

test_util::BasicManagerTestAccess
friend class

Öffentliche statische Funktionen

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

Öffentliche Funktionen

CancelLoadServableRetry (const ServableId & id)
void
Bricht den erneuten Versuch der wartbaren Last während LoadServable () ab .
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 >
Ruft eine Liste aller verfügbaren wartbaren IDs ab, d. H.
LoadServable (const ServableId & id, DoneCallback done_callback)
void
Lädt das Servable mit dieser ID und aktualisiert auch die Serving Map.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)
Status
Startet die Verwaltung des Servables.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)
Status
Ähnlich wie bei der obigen Methode, aber Anrufer, normalerweise andere Manager, die auf dieser Methode aufbauen, können dem Servable einen zusätzlichen Status zuordnen.
StopManagingServable (const ServableId & id)
Status
Weist den Manager an, die Verwaltung dieses Servables zu beenden.
UnloadServable (const ServableId & id, DoneCallback done_callback)
void
Entlädt das Servable mit dieser ID und aktualisiert auch die Serving Map.

Strukturen

Tensorflow :: Serving :: BasicManager :: Optionen

Konfigurationsoptionen und steckbare Objekte, die vom BasicManager verwendet werden .

Öffentliche Typen

DoneCallback

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

Rückruf am Ende von {Load, Unload} Servable ().

Wir übergeben den Status der Operation an den Rückruf.

PreLoadHook

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

Freund Klassen

test_util :: BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

Öffentliche statische Funktionen

Erstellen

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

Öffentliche Funktionen

CancelLoadServableRetry

void CancelLoadServableRetry(
  const ServableId & id
)

Bricht den erneuten Versuch der wartbaren Last während LoadServable () ab .

Tut nichts, wenn das Servable nicht verwaltet wird.

Wenn die Wiederholungsversuche abgebrochen werden, wechselt der Servable in einen Zustand, der von der zuletzt aufgerufenen Load () abhängt. Wenn das letzte Load () erfolgreich war, befindet es sich im Status kReady, andernfalls in kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

ANFORDERUNGEN: Dieser Manager sollte dieses Servable bereits verwaltet haben, andernfalls geben wir nullptr zurück.

Einzelheiten
Kehrt zurück
der zusätzliche Zustand für den Servable. Gibt nullptr zurück, wenn kein zusätzliches Status-Setup vorhanden ist oder wenn eine Typinkongruenz zwischen dem Setup und dem angeforderten Status besteht.

GetAvailableUntypedServableHandles

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

GetManagedServableNames

std::vector< string > GetManagedServableNames() const 

Einzelheiten
Kehrt zurück
die Namen aller von diesem Manager verwalteten Servables. Die Namen sind duplikationsfrei und nicht in einer bestimmten Reihenfolge.

GetManagedServableStateSnapshot

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

ANFORDERUNGEN: Dieser Manager sollte dieses Servable bereits verwaltet haben, andernfalls geben wir nullopt zurück.

Einzelheiten
Kehrt zurück
Der Status-Snapshot einer bestimmten Servable-ID, die von diesem Manager verwaltet wird, falls verfügbar.

GetManagedServableStateSnapshots

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

T ist der Typ für zusätzliche Zustände, falls vorhanden.

Einzelheiten
Kehrt zurück
Die Status-Snapshots aller Servables eines bestimmten Streams, die von diesem Manager verwaltet werden.

GetUntypedServableHandle

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

ListAvailableServableIds

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

Ruft eine Liste aller verfügbaren wartbaren IDs ab, d. H.

Jedes dieser Elemente kann mit GetServableHandle abgerufen werden.

LoadServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Lädt das Servable mit dieser ID und aktualisiert auch die Serving Map.

Ruft done_callback mit ok auf, wenn das Servable erfolgreich geladen wurde, andernfalls wird ein Fehlerstatus zurückgegeben.

Wenn Sie einen Thread-Pool verwenden, versetzt diese Methode den wartbaren Kabelbaum in den kLoading-Status, plant das Laden und kehrt zurück, andernfalls wird das Laden vor dem Zurückkehren abgeschlossen.

ANFORDERUNGEN: Dieser Manager sollte dieses Servable bereits verwaltet haben, damit es geladen werden kann. Andernfalls rufen wir done_callback mit einem Fehlerstatus auf. Rufen Sie dies nicht mehrmals auf demselben Servable auf. Nur einer davon wird erfolgreich sein und der Rest wird mit einem Fehlerstatus fehlschlagen.

ManageServable

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

Startet die Verwaltung des Servables.

Gibt einen Fehler zurück, wenn ein Servable angegeben wird, das bereits verwaltet wird.

Wenn servierbaren in einem Fehlerzustand befindet, funktioniert diese Methode keinen Fehler zurück. Stattdessen akzeptiert der Manager das Servable, versetzt es in den Status kError (mit einer an den Ereignisbus gesendeten Benachrichtigung) und beendet die Verwaltung sofort. Dieses Verhalten erleichtert die einheitliche Behandlung von Fehlern, die in Quellen auftreten (z. B. ungültiger Dateipfad zu verwertbaren Daten) und im Manager auftreten (z. B. unzureichende Ressourcen zum Laden von bedienbaren Daten).

ManageServableWithAdditionalState

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

Ähnlich wie bei der obigen Methode, aber Anrufer, normalerweise andere Manager, die auf dieser Methode aufbauen, können dem Servable einen zusätzlichen Status zuordnen.

Zusätzlicher Status können ACL- oder lebenslange Metadaten für diesen Dienst sein. Das Eigentum des Staates geht auf diese Klasse über.

StopManagingServable

Status StopManagingServable(
  const ServableId & id
)

Weist den Manager an, die Verwaltung dieses Servables zu beenden.

Erfordert, dass das Servable derzeit verwaltet wird und dass sein Status {kNew, kError, kDisabled} lautet.

UnloadServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Entlädt das Servable mit dieser ID und aktualisiert auch die Serving Map.

Ruft done_callback mit ok auf, wenn das Servable erfolgreich entladen wurde, andernfalls wird ein Fehlerstatus zurückgegeben.

Wenn Sie einen Thread-Pool verwenden, versetzt diese Methode den wartbaren Kabelbaum in den Status kQuiescing, plant das Entladen und kehrt zurück, andernfalls wird das Entladen vor der Rückkehr abgeschlossen.

ANFORDERUNGEN: Dieser Manager sollte diesen Dienst geladen und verfügbar gemacht haben, damit er entladen werden kann. Andernfalls wird done_callback mit einem Fehlerstatus aufgerufen . Rufen Sie dies nicht mehrmals auf demselben Servable auf. Nur einer davon wird erfolgreich sein und der Rest wird mit einem Fehlerstatus fehlschlagen.

~ BasicManager

 ~BasicManager() override

Wenn die Konfiguration für die Verwendung eines Thread-Pools zum Laden / Entladen konfiguriert ist, wird gewartet, bis alle geplanten Lade- und Entladevorgänge abgeschlossen sind, und anschließend der Thread-Satz zerstört.