tensorflow :: servicio:: BasicManager

Esto es una clase abstracta.

#include <basic_manager.h>

Ayuda a administrar el ciclo de vida de los servicios, incluida la carga, el servicio y la descarga.

Resumen

El administrador acepta servicios en forma de cargadores.

Comenzamos a administrar un servidor a través de uno de los métodos ManageServable *. Usted puede ir a cargar el servable después de esta llamando LoadServable () . La carga también hará que el servidor esté disponible para servir. Una vez que decida descargarlo, puede llamar UnloadServable () en él, lo que hará que no esté disponible para servir, a continuación, descargar la servable.

Servables se conservan hasta StopManagingServable () se llama. Esto permite que un administrador de nivel superior con más información decida cuándo es seguro olvidarse de un servidor.

BasicManager un seguimiento de los recursos (por ejemplo, RAM) utilizados por servables cargado, y sólo permite cargar nuevos servables que caben dentro de la piscina general de recursos.

BasicManager puede ser configurado para usar una rosca de la piscina para hacerlo de carga y se descarga el. Esto hace que el LoadServable () y UnloadServable () métodos programar de carga / se descargue en lugar de la ejecución de ellos de forma sincrónica. Si hay más cargas / descargas pendientes que subprocesos en el grupo de subprocesos, se procesan en orden FIFO.

En presencia de cargadores que sobrestiman las necesidades de recursos de sus servidores y / o solo enlazan los recursos de sus servidores a instancias de dispositivos, la simultaneidad de carga / descarga se puede reducir por debajo del tamaño del grupo de subprocesos. Esto se debe a que es posible que tengamos que esperar a que finalice la carga / descarga de un servidor para determinar la disponibilidad de recursos para cargar otro servidor.

REQUIERE:

1. Orden de las llamadas de método - ManageServable () (y variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
2. No programe cargas y descargas simultáneas del mismo servidor.
3. No llame a cargar o descargar varias veces en el mismo servidor.

Esta clase es segura para subprocesos.

Ejemplo de uso:

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

Herencia

Hereda de: tensorflow :: servir Gestor ::

Constructores y Destructores
~BasicManager () Si está configurado para usar un grupo de subprocesos de carga / descarga, espera hasta que todas las cargas y descargas programadas hayan finalizado y luego destruye el conjunto de subprocesos.

Tipos públicos
DoneCallback	utilizando std::function< void(const Status &status)> Devolución de llamada llamada al final de {Load, Unload} Servable ().
PreLoadHook	utilizando std::function< void(const ServableId &)>

Clases de amigos
test_util::BasicManagerTestAccess	friend class

Funciones estáticas públicas
Create ( Options options, std::unique_ptr< BasicManager > *manager)	Status

Funciones publicas
CancelLoadServableRetry (const ServableId & id)	void Cancela de volver a intentar la carga servable 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 > Obtiene una lista de todos los identificadores de servicio disponibles, es decir
LoadServable (const ServableId & id, DoneCallback done_callback)	void Carga el servidor con esta identificación y también actualiza el mapa de servicio.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)	Status Empieza a gestionar los servibles.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)	Status Similar al método anterior, pero las personas que llaman, generalmente otros administradores construidos sobre este, pueden asociar un estado adicional con el servidor.
StopManagingServable (const ServableId & id)	Status Le dice al administrador que deje de administrar este servicio.
UnloadServable (const ServableId & id, DoneCallback done_callback)	void Descarga el servidor con esta identificación y también actualiza el mapa de servicio.

Estructuras
tensorflow :: :: servir BasicManager :: Opciones	Opciones de configuración y objetos conectables que serán utilizados por el BasicManager .

Tipos públicos

DoneCallback

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

Devolución de llamada llamada al final de {Load, Unload} Servable ().

Pasamos el estado de la operación a la devolución de llamada.

Gancho de precarga

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

Clases de amigos

test_util :: BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

Funciones estáticas públicas

Crear

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

Funciones publicas

CancelLoadServableRetry

void CancelLoadServableRetry(
  const ServableId & id
)

Cancela de volver a intentar la carga servable durante LoadServable () .

No hace nada si no se administra el servidor.

Si se cancelan los reintentos, el servidor pasa a un estado que depende de la última carga () invocada. Si la última carga () fue exitosa, estará en el estado kReady, de lo contrario en kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

REQUIERE: Este administrador debería haber estado administrando este servidor ya, de lo contrario, devolvemos nullptr.

Detalles
Devoluciones	el estado adicional para el servible. Devuelve nullptr si no hay una configuración de estado adicional o si hay una falta de coincidencia de tipos entre lo que se configuró y lo que se solicita.

GetAvailableUntypedServableHandles

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

GetManagedServableNames

std::vector< string > GetManagedServableNames() const 

Detalles
Devoluciones	los nombres de todos los servicios administrados por este administrador. Los nombres estarán libres de duplicados y no estarán en ningún orden en particular.

GetManagedServableStateSnapshot

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

REQUIERE: Este administrador debería haber estado administrando este servidor ya, de lo contrario, devolvemos nullopt.

Detalles
Devoluciones	la instantánea del estado de un ID de servicio particular administrado por este administrador, si está disponible.

GetManagedServableStateSnapshots

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

T es el tipo de estado adicional, si lo hay.

Detalles
Devoluciones	las instantáneas de estado de todos los servidores de una secuencia en particular, administradas por este administrador.

GetUntypedServableHandle

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

ListAvailableServableIds

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

Obtiene una lista de todos los identificadores de servicio disponibles, es decir

cada uno de estos se puede recuperar mediante GetServableHandle.

LoadServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Carga el servidor con esta identificación y también actualiza el mapa de servicio.

Llamadas con done_callback bien si y sólo si el servable se cargó correctamente, vuelve bien un estado de error.

Si usa un grupo de subprocesos, este método hace la transición del arnés servible al estado kLoading, programa la carga y regresa; de lo contrario, completa la carga antes de regresar.

REQUIERE: Este entrenador debería haber sido la gestión de este servable ya, para que pueda ser cargado, de lo que llamamos done_callback con un estado de error. No llame a esto varias veces en el mismo servidor. Solo uno de ellos tendrá éxito y el resto fallará con un estado de error.

AdministrarServable

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

Empieza a gestionar los servibles.

Devuelve un error si se le da un servidor que ya se está administrando.

Si servable está en un estado de error, este método no devuelve un error. En cambio, el administrador acepta el servidor, lo pone en estado kError (con una notificación enviada al bus de eventos) y luego deja de administrarlo inmediatamente. Este comportamiento facilita el manejo uniforme de los errores que ocurren en las fuentes (por ejemplo, una ruta de archivo no válida a datos servibles) y los que ocurren en el administrador (por ejemplo, recursos insuficientes para cargar servidores).

ManageServableWithAdditionalState

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

Similar al método anterior, pero las personas que llaman, generalmente otros administradores construidos sobre este, pueden asociar un estado adicional con el servidor.

El estado adicional puede ser ACL o metadatos de por vida para ese servidor. La propiedad del estado se transfiere a esta clase.

StopManagingServable

Status StopManagingServable(
  const ServableId & id
)

Le dice al administrador que deje de administrar este servicio.

Requiere que el servidor se esté administrando actualmente y que su estado sea uno de {kNew, kError, kDisabled}.

DescargarServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

Descarga el servidor con esta identificación y también actualiza el mapa de servicio.

Llamadas con done_callback bien si y sólo si el servable fue descargado con éxito, vuelve bien un estado de error.

Si usa un grupo de subprocesos, este método hace la transición del arnés servible al estado kQuiescing, programa la descarga y regresa; de lo contrario, completa la descarga antes de regresar.

REQUIERE: Este entrenador debería haber cargado y hecho de este servable disponibles, para que pueda ser descargada, llamadas demás done_callback con un estado de error. No llame a esto varias veces en el mismo servidor. Solo uno de ellos tendrá éxito y el resto fallará con un estado de error.

~ BasicManager

 ~BasicManager() override

Si está configurado para usar un grupo de subprocesos de carga / descarga, espera hasta que todas las cargas y descargas programadas hayan finalizado y luego destruye el conjunto de subprocesos.