tensorflow :: portion:: Gestionnaire de base

Il s'agit d'une classe abstraite.

#include <basic_manager.h>

Aide à gérer le cycle de vie des servables, y compris leur chargement, leur service et leur déchargement.

Résumé

Le gestionnaire accepte les servables sous forme de Loaders.

Nous commençons à gérer un servable via l'une des méthodes ManageServable*. Vous pouvez aller à charger le diffusable après en appelant LoadServable () . Le chargement rendra également le serveur disponible pour le service. Une fois que vous décidez de le décharger, vous pouvez appeler UnloadServable () sur elle, qui le rendre indisponible pour servir, puis décharger le diffusable.

Servables sont conservés jusqu'à ce que StopManagingServable () est appelée. Cela permet à un responsable de niveau supérieur disposant de plus d'informations de décider quand il est sûr d'oublier une servable.

BasicManager suit les ressources (RAM) utilisés par servables chargés, et ne permet de charger de nouvelles servables qui correspondent à la piscine d' ensemble des ressources.

BasicManager peut être configuré pour utiliser un fil piscine pour faire charge et décharge de lui. Cela rend le LoadServable () et UnloadServable () méthodes de planifier la charge / déchargements plutôt que de les exécuter de manière synchrone. S'il y a plus de chargements/déchargements en attente que de threads dans le pool de threads, ils sont traités dans l'ordre FIFO.

En présence de chargeurs qui surestiment les besoins en ressources de leurs servables et/ou ne lient les ressources de leurs servables qu'aux instances de périphérique, la simultanéité de chargement/déchargement peut être réduite en dessous de la taille du pool de threads. C'est parce que nous devrons peut-être attendre la fin du chargement/déchargement d'un serveur pour déterminer la disponibilité des ressources pour le chargement d'un autre serveur.

A BESOIN:

  1. Ordre des appels de méthode - ManageServable () (et variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. Ne planifiez pas le chargement et le déchargement simultanés du même serveur.
  3. N'appelez pas load ou unload plusieurs fois sur le même serveur.

Cette classe est thread-safe.

Exemple d' utilisation: 

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

Héritage

Hérite de: tensorflow :: :: service Responsable

Constructeurs et destructeurs

~BasicManager ()
S'il est configuré pour utiliser un pool de threads de chargement/déchargement, attend la fin de tous les chargements et déchargements planifiés, puis détruit l'ensemble de threads.

Types publics

DoneCallback utilisant
std::function< void(const Status &status)>
Rappel appelé à la fin de {Load,Unload}Servable().
PreLoadHook utilisant
std::function< void(const ServableId &)>

Cours d'amis

test_util::BasicManagerTestAccess
friend class

Fonctions statiques publiques

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

Fonctions publiques

CancelLoadServableRetry (const ServableId & id)
void
Annule une nouvelle tentative de la charge pouvant être diffusés au cours de 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 >
Obtient une liste de tous les identifiants utilisables disponibles, c'est-à-dire
LoadServable (const ServableId & id, DoneCallback done_callback)
void
Charge le serveur avec cet identifiant et met également à jour la carte de service.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)
Status
Commence à gérer le servable.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)
Status
Similaire à la méthode ci-dessus, mais les appelants, généralement d'autres gestionnaires construits sur celui-ci, peuvent associer un état supplémentaire au servable.
StopManagingServable (const ServableId & id)
Status
Indique au gestionnaire d'arrêter de gérer ce serveur.
UnloadServable (const ServableId & id, DoneCallback done_callback)
void
Décharge le serveur avec cet identifiant et met également à jour la carte de service.

Structures

tensorflow :: :: service BasicManager :: options

Les options de configuration et les objets connectables qui seront utilisés par le BasicManager .

Types publics

TerminéRappel

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

Rappel appelé à la fin de {Load,Unload}Servable().

On passe le statut de l'opération au callback.

Crochet de précharge

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

Cours d'amis

test_util::BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

Fonctions statiques publiques

Créer

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

Fonctions publiques

AnnulerChargerServableRéessayer

void CancelLoadServableRetry(
  const ServableId & id
)

Annule une nouvelle tentative de la charge pouvant être diffusés au cours de LoadServable () .

Ne fait rien si le serveur n'est pas géré.

Si les nouvelles tentatives sont annulées, le servable passe dans un état dépendant du dernier Load() appelé. Si le dernier Load() a réussi, il sera dans l'état kReady, sinon dans kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

REQUIS : ce gestionnaire aurait déjà dû gérer ce serveur, sinon nous renvoyons nullptr.

Des détails
Retour
l'état supplémentaire pour le servable. Renvoie nullptr s'il n'y a pas de configuration d'état supplémentaire ou s'il y a une incompatibilité de type entre ce qui a été configuré et ce qui est demandé.

GetAvailableUntypedServableHandles

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

GetManagedServableNames

std::vector< string > GetManagedServableNames() const

Des détails
Retour
les noms de tous les serveurs gérés par ce gestionnaire. Les noms seront sans doublons et non dans un ordre particulier.

GetManagedServableStateSnapshot

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

REQUIS : ce gestionnaire aurait déjà dû gérer ce serveur, sinon nous renvoyons nullopt.

Des détails
Retour
l'instantané d'état d'un servable-id particulier géré par ce gestionnaire, s'il est disponible.

GetManagedServableStateSnapshots

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

T est le type d'état supplémentaire, le cas échéant.

Des détails
Retour
les instantanés d'état de tous les servables d'un flux particulier, gérés par ce gestionnaire.

GetUntypedServableHandle

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

ListAvailableServableIds

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

Obtient une liste de tous les identifiants utilisables disponibles, c'est-à-dire

chacun d'eux peut être récupéré à l'aide de GetServableHandle.

ChargeServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Charge le serveur avec cet identifiant et met également à jour la carte de service.

Appels done_callback ok avec ssi le diffusable a été chargé avec succès, sinon retourne un état d'erreur.

Si vous utilisez un pool de threads, cette méthode fait passer le faisceau utilisable à l'état kLoading, planifie le chargement et renvoie, sinon elle termine le chargement avant de revenir.

EXIGE: Ce gestionnaire aurait dû gérer cette diffusable déjà, pour qu'il soit chargé, sinon nous appelons done_callback avec un statut d'erreur. N'appelez pas cela plusieurs fois sur le même serveur. Un seul d'entre eux réussira et le reste échouera avec un état d'erreur.

GérerServable

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

Commence à gérer le servable.

Renvoie une erreur si un serveur est déjà géré.

Si diffusable est dans un état d'erreur, cette méthode ne renvoie pas d'erreur. Au lieu de cela, le gestionnaire accepte le servable, le met dans l'état kError (avec une notification envoyée au bus d'événements), puis arrête immédiatement de le gérer. Ce comportement facilite la gestion uniforme des erreurs qui se produisent dans les sources (par exemple, chemin de fichier invalide vers les données pouvant être servies) et celles qui se produisent dans le gestionnaire (par exemple, ressources insuffisantes pour charger le serveur).

GérerServableWithAdditionalState

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

Similaire à la méthode ci-dessus, mais les appelants, généralement d'autres gestionnaires construits sur celui-ci, peuvent associer un état supplémentaire au servable.

Un état supplémentaire peut être une ACL ou des métadonnées de durée de vie pour ce serveur. La propriété de l'État est transférée à cette classe.

ArrêterGérerServable

Status StopManagingServable(
  const ServableId & id
)

Indique au gestionnaire d'arrêter de gérer ce serveur.

Nécessite que le serveur soit actuellement géré et que son état soit {kNew, kError, kDisabled}.

UnloadServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Décharge le serveur avec cet identifiant et met également à jour la carte de service.

Appels done_callback ok avec ssi le diffusable a été déchargé avec succès, sinon retourne un état d'erreur.

Si vous utilisez un pool de threads, cette méthode fait passer le faisceau utilisable à l'état kQuiescing, planifie le déchargement et renvoie, sinon elle termine le déchargement avant de revenir.

EXIGE: Ce gestionnaire aurait chargé et fait de cette disposition diffusable, pour être déchargé, les autres appellent done_callback avec un état d'erreur. N'appelez pas cela plusieurs fois sur le même serveur. Un seul d'entre eux réussira et le reste échouera avec un état d'erreur.

~BasicManager

 ~BasicManager() override

S'il est configuré pour utiliser un pool de threads de chargement/déchargement, attend la fin de tous les chargements et déchargements planifiés, puis détruit l'ensemble de threads.