flusso tensoriale:: servendo:: Monitoraggio dello stato dei servizi

#include <servable_state_monitor.h>

Un'utilità che ascolta un EventBus<ServableState> e tiene traccia dello stato di ogni servable menzionato sul bus.

Riepilogo

Il caso d'uso previsto è di monitorare gli stati di servables in un manager .

Offre un'interfaccia per interrogare gli stati utilizzabili. Può essere utile come base per dashboard, nonché per testare un manager.

IMPORTANTE: È necessario creare questo monitor prima di organizzare per gli eventi da pubblicare sul bus evento, ad esempio dando il bus evento a un manager .

Costruttori e Distruttori

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

tipi pubblici

BoundedLog usando
std::deque< ServableStateAndTime >
NotifyFn usando
std::function< void(const ServableState &)>
ServableMap usando
std::map< ServableName, VersionMap >
ServableName usando
string
ServableSet usando
std::set< ServableName >
ServableStateNotifierFn usando
std::function< void(bool reached_goal_state, const std::map< ServableId, ServableState::ManagerState > &states_reached)>
Notifica quando tutti i servable hanno raggiunto lo 'goal_state'.
Version usando
int64
VersionMap usando
std::map< Version, ServableStateAndTime, std::greater< Version >>

Funzioni pubbliche

ForgetUnloadedServableStates ()
void
Rimuove tutte le versioni utilizzabili da ServableMap i cui stati sono passati a kEnd.
GetAllServableStates ()
ServableMap
Restituisce gli stati correnti di tutte le versioni tracciate di tutti i servibili.
GetAvailableServableStates ()
ServableSet
GetBoundedLog ()
BoundedLog
Restituisce il registro limitato corrente degli eventi di stato gestibili gestiti.
GetLiveServableStates ()
ServableMap
Restituisce gli stati correnti di tutte le versioni di tutti i servable che non sono passati allo stato ServableState::ManagerState::kEnd.
GetState (const ServableId & servable_id)
optional< ServableState >
Restituisce lo stato corrente di un'istanza pubblicabile o nullopt se non viene rilevata tale unità pubblicabile.
GetStateAndTime (const ServableId & servable_id)
optional< ServableStateAndTime >
Restituisce lo stato e l'ora correnti di un server pubblicabile o nullopt se tale server non viene tracciato.
GetVersionStates (const string & servable_name)
VersionMap
Restituisce gli stati correnti di tutte le versioni tracciate del dato servibile, se presente.
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
Simile a NotifyWhenServablesReachState(...), ma invece di notificare, aspettiamo che venga raggiunto 'goal_state' o kEnd.

Strutture

tensorflow :: :: servire ServableStateMonitor :: Opzioni
tensorflow :: servire :: :: ServableStateMonitor ServableStateAndTime

tipi pubblici

BoundedLog

std::deque< ServableStateAndTime > BoundedLog

NotificaFn

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

ServibleMap

std::map< ServableName, VersionMap > ServableMap

NomeUtilizzabile

string ServableName

ServibleSet

std::set< ServableName > ServableSet

ServableStateNotifierFn

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

Notifica quando tutti i servable hanno raggiunto lo 'goal_state'.

I server possono essere specificati in due modi:

  1. Come versioni specifiche di un nome di flusso pubblicabile. In questo caso, controlliamo se la versione specifica ha raggiunto il 'goal_state' o kEnd.
  2. Come le ultime versioni, nel qual caso qualsiasi versione per un nome di stream pubblicabile verrà confrontata con 'goal_state' o kEnd.

Chiamiamo 'notifier_fn' quando entrambe le condizioni sono vere -

  1. Tutte le richieste pubblicabili specifiche hanno raggiunto 'goal_state' o kEnd.
  2. Tutte le ultime richieste pubblicabili hanno raggiunto 'goal_state' o kEnd. Il 'notifier_fn' verrà chiamato solo una volta e non ripetutamente.

L'argomento 'reached_goal_state' è impostato come vero se tutti i servable specifici hanno raggiunto 'goal_state'. Quindi i chiamanti dovrebbero verificare che 'reached_goal_state' sia vero in 'notifier_fn'.

L'argomento 'states_reached' viene popolato con l'id del servable e lo stato raggiunto. Lo stato sarebbe 'goal_state' se 'reached_goal_state' è vero, altrimenti conterrà uno o più servable nello stato kEnd. Per le ultime richieste pubblicabili, l'id pubblicabile sarà l'id del pubblicabile nel flusso che ha raggiunto lo stato.

Versione

int64 Version

Mappa versione

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

Funzioni pubbliche

Dimentica gli stati di servizio non caricati

void ForgetUnloadedServableStates()

Rimuove tutte le versioni utilizzabili da ServableMap i cui stati sono passati a kEnd.

Ottieni tutti gli stati di pubblicazione

ServableMap GetAllServableStates()

Restituisce gli stati correnti di tutte le versioni tracciate di tutti i servibili.

Ottieni StatiDisponibileServibile

ServableSet GetAvailableServableStates()

GetBoundedLog

BoundedLog GetBoundedLog()

Restituisce il registro limitato corrente degli eventi di stato gestibili gestiti.

Ottieni Stati di Servizio Live

ServableMap GetLiveServableStates()

Restituisce gli stati correnti di tutte le versioni di tutti i servable che non sono passati allo stato ServableState::ManagerState::kEnd.

Ottieni stato

optional< ServableState > GetState(
  const ServableId & servable_id
)

Restituisce lo stato corrente di un'istanza pubblicabile o nullopt se non viene rilevata tale unità pubblicabile.

GetStateAndTime

optional< ServableStateAndTime > GetStateAndTime(
  const ServableId & servable_id
)

Restituisce lo stato e l'ora correnti di un server pubblicabile o nullopt se tale server non viene tracciato.

Ottieni StatiVersione

VersionMap GetVersionStates(
  const string & servable_name
)

Restituisce gli stati correnti di tutte le versioni tracciate del dato servibile, se presente.

Notificare

void Notify(
  const NotifyFn & notify_fn
)

Notifica quandoservibiliReachState

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

Monitoraggio dello stato dei servizi

 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

Simile a NotifyWhenServablesReachState(...), ma invece di notificare, aspettiamo che venga raggiunto 'goal_state' o kEnd.

Per comprendere il valore restituito e il parametro restituito 'states_reached', leggere la documentazione su NotifyWhenServablesReachState(...).

~ServibileStateMonitor

virtual  ~ServableStateMonitor()