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:
- Orden de las llamadas de método - ManageServable () (y variantes) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
- No programe cargas y descargas simultáneas del mismo servidor.
- 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 | utilizandostd::function< void(const Status &status)> Devolución de llamada llamada al final de {Load, Unload} Servable (). |
PreLoadHook | utilizandostd::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.