tensorflow :: portion:: ServableStateMonitor

#include <servable_state_monitor.h>

Un utilitaire qui écoute un EventBus<ServableState> et garde une trace de l'état de chaque servable mentionné sur le bus.

Résumé

Le cas d'utilisation prévue est de suivre les états de servables dans un directeur .

Offre une interface pour interroger les états pouvant être servis. Il peut être utile comme base de tableaux de bord, ainsi que pour tester un manager.

IMPORTANT: Vous devez créer ce moniteur avant d' organiser des événements à publier sur le bus d'événements, par exemple , donner le bus d'événement à un directeur .

Constructeurs et destructeurs

ServableStateMonitor (EventBus< ServableState > *bus, const Options & options)
~ServableStateMonitor ()

Types publics

BoundedLog utilisant
std::deque< ServableStateAndTime >
NotifyFn utilisant
std::function< void(const ServableState &)>
ServableMap utilisant
std::map< ServableName, VersionMap >
ServableName utilisant
string
ServableSet utilisant
std::set< ServableName >
ServableStateNotifierFn utilisant
std::function< void(bool reached_goal_state, const std::map< ServableId, ServableState::ManagerState > &states_reached)>
Avertit lorsque tous les servables ont atteint le 'goal_state'.
Version utilisant
int64
VersionMap utilisant
std::map< Version, ServableStateAndTime, std::greater< Version >>

Fonctions publiques

ForgetUnloadedServableStates ()
void
Supprime toutes les versions utilisables du ServableMap dont les états sont passés à kEnd.
GetAllServableStates ()
ServableMap
Renvoie les états actuels de toutes les versions suivies de tous les servables.
GetAvailableServableStates ()
ServableSet
GetBoundedLog ()
BoundedLog
Renvoie le journal limité actuel des événements d'état pouvant être traités.
GetLiveServableStates ()
ServableMap
Renvoie les états actuels de toutes les versions de tous les servables qui ne sont pas passés à l'état ServableState::ManagerState::kEnd.
GetState (const ServableId & servable_id)
optional< ServableState >
Renvoie l'état actuel d'une servable, ou nullopt si cette servable n'est pas suivie.
GetStateAndTime (const ServableId & servable_id)
optional< ServableStateAndTime >
Renvoie l'état et l'heure actuels d'un serveur, ou nullopt si ce serveur n'est pas suivi.
GetVersionStates (const string & servable_name)
VersionMap
Renvoie les états actuels de toutes les versions suivies du serveur donné, le cas échéant.
Notify (const NotifyFn & notify_fn)
void
NotifyWhenServablesReachState (const std::vector< ServableRequest > & servables, ServableState::ManagerState goal_state, const ServableStateNotifierFn & notifier_fn)
void
WaitUntilServablesReachState (const std::vector< ServableRequest > & servables, ServableState::ManagerState goal_state, std::map< ServableId, ServableState::ManagerState > *states_reached) TF_MUST_USE_RESULT
bool
Similaire à NotifyWhenServablesReachState(...), mais au lieu de notifier, nous attendons jusqu'à ce que 'goal_state' ou kEnd soit atteint.

Structures

tensorflow :: :: service ServableStateMonitor :: options
tensorflow :: :: service ServableStateMonitor :: ServableStateAndTime

Types publics

Journal limité

std::deque< ServableStateAndTime > BoundedLog

NotifierFn

std::function< void(const ServableState &)> NotifyFn

ServableMap

std::map< ServableName, VersionMap > ServableMap

Nom Serviable

string ServableName

ServableSet

std::set< ServableName > ServableSet

ServableStateNotifierFn

std::function< void(bool reached_goal_state, const std::map< ServableId, ServableState::ManagerState > &states_reached)> ServableStateNotifierFn

Avertit lorsque tous les servables ont atteint le 'goal_state'.

Les servables peuvent être spécifiés de deux manières :

  1. En tant que versions spécifiques d'un nom de flux utilisable. Dans ce cas, nous vérifions si la version spécifique a atteint le 'goal_state' ou kEnd.
  2. En tant que dernières versions, auquel cas toute version d'un nom de flux utilisable sera comparée à 'goal_state' ou kEnd.

Nous appelons le 'notifier_fn' lorsque les deux conditions sont vraies -

  1. Toutes les requêtes spécifiques pouvant être servies ont atteint le 'goal_state' ou kEnd.
  2. Toutes les dernières requêtes utilisables ont atteint 'goal_state' ou kEnd. Le 'notifier_fn' ne sera appelé qu'une seule fois, et non à plusieurs reprises.

L'argument 'reached_goal_state' est défini comme vrai si tous les serveurs spécifiques ont atteint 'goal_state'. Les appelants doivent donc vérifier que 'reached_goal_state' est vrai dans 'notifier_fn'.

L'argument 'states_reached' est renseigné avec l'ID du serveur et l'état qu'il a atteint. L'état serait 'goal_state' si 'reached_goal_state' est vrai, sinon il contiendra un ou plusieurs servables dans l'état kEnd. Pour les dernières requêtes servables, l'identifiant servable sera l'identifiant du servable dans le flux qui a atteint l'état.

Version

int64 Version

Carte des versions

std::map< Version, ServableStateAndTime, std::greater< Version >> VersionMap

Fonctions publiques

ForgetUnloadedServableStates

void ForgetUnloadedServableStates()

Supprime toutes les versions utilisables du ServableMap dont les états sont passés à kEnd.

GetAllServableStates

ServableMap GetAllServableStates()

Renvoie les états actuels de toutes les versions suivies de tous les servables.

GetAvailableServableStates

ServableSet GetAvailableServableStates()

GetBoundedLog

BoundedLog GetBoundedLog()

Renvoie le journal limité actuel des événements d'état pouvant être traités.

GetLiveServableStates

ServableMap GetLiveServableStates()

Renvoie les états actuels de toutes les versions de tous les servables qui ne sont pas passés à l'état ServableState::ManagerState::kEnd.

Obtenir l'état

optional< ServableState > GetState(
  const ServableId & servable_id
)

Renvoie l'état actuel d'une servable, ou nullopt si cette servable n'est pas suivie.

ObtenirÉtatEtHeure

optional< ServableStateAndTime > GetStateAndTime(
  const ServableId & servable_id
)

Renvoie l'état et l'heure actuels d'un serveur, ou nullopt si ce serveur n'est pas suivi.

Obtenir les états de la version

VersionMap GetVersionStates(
  const string & servable_name
)

Renvoie les états actuels de toutes les versions suivies du serveur donné, le cas échéant.

Notifier

void Notify(
  const NotifyFn & notify_fn
)

NotifyWhenServablesReachState

void NotifyWhenServablesReachState(
  const std::vector< ServableRequest > & servables,
  ServableState::ManagerState goal_state,
  const ServableStateNotifierFn & notifier_fn
)

ServableStateMonitor

 ServableStateMonitor(
  EventBus< ServableState > *bus,
  const Options & options
)

WaitUntilServablesReachState

bool WaitUntilServablesReachState(
  const std::vector< ServableRequest > & servables,
  ServableState::ManagerState goal_state,
  std::map< ServableId, ServableState::ManagerState > *states_reached
) TF_MUST_USE_RESULT

Similaire à NotifyWhenServablesReachState(...), mais au lieu de notifier, nous attendons jusqu'à ce que 'goal_state' ou kEnd soit atteint.

Pour comprendre la valeur de retour et le paramètre de retour 'states_reached', veuillez lire la documentation sur NotifyWhenServablesReachState(...).

~ServableStateMonitor

virtual  ~ServableStateMonitor()