La clase Ev

(PECL ev >= 0.2.0)

Introducción

La clase Ev es una clase estática que proporciona acceso al bucle por defecto así como a algunas operaciones comunes.

Sinopsis de la Clase

final class Ev {

/* Constantes */

const int FLAG_AUTO = 0;

const int FLAG_NOENV = 16777216;

const int FLAG_FORKCHECK = 33554432;

const int FLAG_NOINOTIFY = 1048576;

const int FLAG_SIGNALFD = 2097152;

const int FLAG_NOSIGMASK = 4194304;

const int RUN_NOWAIT = 1;

const int RUN_ONCE = 2;

const int BREAK_CANCEL = 0;

const int BREAK_ONE = 1;

const int BREAK_ALL = 2;

const int MINPRI = -2;

const int MAXPRI = 2;

const int READ = 1;

const int WRITE = 2;

const int TIMER = 256;

const int PERIODIC = 512;

const int SIGNAL = 1024;

const int CHILD = 2048;

const int STAT = 4096;

const int IDLE = 8192;

const int PREPARE = 16384;

const int CHECK = 32768;

const int EMBED = 65536;

const int CUSTOM = 16777216;

const int ERROR = 2147483648;

const int BACKEND_SELECT = 1;

const int BACKEND_POLL = 2;

const int BACKEND_EPOLL = 4;

const int BACKEND_KQUEUE = 8;

const int BACKEND_DEVPOLL = 16;

const int BACKEND_PORT = 32;

const int BACKEND_ALL = 63;

const int BACKEND_MASK = 65535;

/* Métodos */

final public static backend(): int

final public static depth(): int

final public static embeddableBackends(): int

final public static feedSignal( int $signum ): void

final public static feedSignalEvent( int $signum ): void

final public static iteration(): int

final public static now(): float

final public static nowUpdate(): void

final public static recommendedBackends(): int

final public static resume(): void

final public static run( int $flags = ?): void

final public static sleep( float $seconds ): void

final public static stop( int $how = ?): void

final public static supportedBackends(): int

final public static suspend(): void

final public static time(): float

final public static verify(): void

}

Constantes predefinidas

Flags pasados para crear un bucle:

Ev::FLAG_AUTO: El valor por defecto de los flags.
Ev::FLAG_NOENV: Si este flag se utiliza (o si el programa ejecuta setuid o setgid), libev no va a mirar la variable de entorno LIBEV_FLAGS. De lo contrario (comportamiento por defecto), LIBEV_FLAGS va a sobrescribir completamente el flag si se encuentra. Útil para pruebas de rendimiento y para la búsqueda de bugs.
Ev::FLAG_FORKCHECK: Hace que libev verifique si existe un fork en cada iteración, en lugar de llamar manualmente al método EvLoop::fork(). Este mecanismo funciona llamando a getpid() en cada iteración de la bucle, y así, va a ralentizar el bucle de eventos que poseen muchas iteraciones, pero habitualmente, este ralentizamiento no es notable. La configuración de este flag no puede ser sobrescrita o especificada en la variable de entorno LIBEV_FLAGS.
Ev::FLAG_NOINOTIFY: Cuando este flag está especificado, libev no va a intentar utilizar la API inotify para estos watchers » ev_stat. Este flag puede ser útil para conservar los descriptores de ficheros inotify, sabiendo que de lo contrario, cada bucle utilizando los watchers ev_stat va a consumir un manejador inotify.
Ev::FLAG_SIGNALFD: Cuando este flag está especificado, libev va a intentar utilizar la API signalfd para estos watchers » ev_signal (y » ev_child). Esta API entrega las señales de forma asíncrona, lo que la hace más rápida, y puede permitir la recuperación de datos de señales en espera. También puede simplificar la gestión de señales con hilos, sabiendo que las señales son propiedades bloqueadas en los hilos. Signalfd no será utilizado por defecto.
Ev::FLAG_NOSIGMASK: Cuando este flag está especificado, libev no va a modificar la máscara de señal. Esto significa que se debe asegurar que las señales están desbloqueadas antes de recibirlas. Este comportamiento es útil para la gestión personalizada de señales, o la gestión de señales únicamente en hilos específicos.

Flags a pasar a Ev::run(), o a EvLoop::run()

Ev::RUN_NOWAIT: Significa que el bucle de eventos va a mirar si hay nuevos eventos presentes, va a gestionar estos nuevos eventos, y todos los eventos especiales, pero no va a esperar y bloquear el proceso en el caso de que no haya eventos, y va a retornar después de una iteración del bucle. A veces es útil poner en cola y gestionar los nuevos eventos durante cálculos largos, y esto, para mantener el programa activo.
Ev::RUN_ONCE: Significa que el bucle de eventos va a mirar si hay nuevos eventos presentes (y esperar, si es necesario), y va a gestionarlos, ellos y los especiales. Va a bloquear el proceso hasta que al menos un evento llegue (que puede ser un evento interno de libev, también, no está garantizado que una función de callback registrada por el usuario sea llamada), y va a retornar después de una iteración del bucle.

Flags pasados a Ev::stop(), o a EvLoop::stop()

Ev::BREAK_CANCEL: Cancela la operación de cancelación.
Ev::BREAK_ONE: Retorna la llamada más profunda a Ev::run() (o EvLoop::run()).
Ev::BREAK_ALL: Retorna la llamada más cercana a Ev::run() (o EvLoop::run()).

Prioridades de Watcher:

Ev::MINPRI: Prioridad mínima permitida para un watcher.
Ev::MAXPRI: Prioridad máxima permitida para un watcher.

Máscaras de bytes de eventos (recibidos):

Ev::READ: El descriptor de fichero en el watcher EvIo se ha vuelto accesible en lectura.
Ev::WRITE: El descriptor de fichero en el watcher EvIo se ha vuelto accesible en escritura.
Ev::TIMER: El watcher EvTimer ha alcanzado su tiempo máximo de espera.
Ev::PERIODIC: El watcher EvPeriodic ha alcanzado su tiempo máximo de espera.
Ev::SIGNAL: Una señal especificada en EvSignal::__construct() ha sido recibida.
Ev::CHILD: El pid especificado en EvChild::__construct() ha recibido una modificación de estado.
Ev::STAT: La ruta especificada en el watcher EvStat ha modificado sus atributos.
Ev::IDLE: El watcher EvIdle funciona cuando no tiene ninguna otra tarea que hacer con los otros watchers.
Ev::PREPARE: Todos los watchers EvPrepare son llamados justo antes del inicio de Ev::run(). Así, los watchers EvPrepare son los últimos watchers en ser llamados antes del reposo del bucle de eventos, o la puesta en cola de los nuevos eventos.
Ev::CHECK: Todos los watchers EvCheck son puestos en cola justo después de que Ev::run() haya recuperado los nuevos eventos, pero antes, todas las funciones de callback de todos los eventos recibidos son puestas en cola. Así, los watchers EvCheck serán llamados antes que cualquier otro watcher de misma prioridad o de prioridad más baja en una iteración del bucle de eventos.
Ev::EMBED: El bucle de eventos embebido especificado en el watcher EvEmbed necesita toda la atención.
Ev::CUSTOM: Aún no enviado (o utilizado) por libev, pero puede ser libremente utilizado por los usuarios libev para señalar los watchers (i.e. vía el método EvWatcher::feed()).
Ev::ERROR: Ha ocurrido un error desconocido, el watcher se ha detenido. Esto puede ocurrir porque el watcher no ha podido ser iniciado correctamente porque libev ha excedido la memoria asignada, un descriptor de fichero ha sido cerrado, u otro problema. Libev considera esto como bugs de la aplicación. Ver también » la anatomía de un watcher

Flags de Backend:

Ev::BACKEND_SELECT: select(2) backend
Ev::BACKEND_POLL: poll(2) backend
Ev::BACKEND_EPOLL: Backend epoll(7) específico de Linux para, a la vez, los kernels antes y después de 2.6.9.
Ev::BACKEND_KQUEUE: Backend kqueue utilizado en la mayoría de los sistemas BSD. El watcher EvEmbed puede ser utilizado para embeber un bucle (con el backend kqueue) en otro. Actualmente, un bucle puede intentar crear un bucle de eventos con el backend kqueue y utilizarlo únicamente para los sockets.
Ev::BACKEND_DEVPOLL: Backend Solaris 8. Actualmente no implementado.
Ev::BACKEND_PORT: Mecanismo de puerto de eventos Solaris con buen rendimiento.
Ev::BACKEND_ALL: Prueba todos los backends (incluyendo los corruptos). No se recomienda utilizarlo explícitamente. Los operadores de bits deberían ser aplicados aquí (i.e. Ev::BACKEND_ALL & ~ Ev::BACKEND_KQUEUE). Utilice el método Ev::recommendedBackends() o no especifique ningún backend.
Ev::BACKEND_MASK: No es un backend, sino una máscara para seleccionar todos los bits de un backend desde el valor de flags para representar en una máscara cualquier backend (i.e. al modificar la variable de entorno LIBEV_FLAGS).

Nota: Para el bucle por defecto, durante la fase de inicialización del módulo, Ev registra llamadas a » ev_loop_fork vía pthread_atfork (si está disponible).

Nota: Hay métodos que proporcionan acceso a la bucle de eventos por defecto en la clase Ev (i.e. Ev::iteration(), Ev::depth(), etc.) Para los bucles personalizados (creados con EvLoop::__construct()), estos valores pueden ser accesibles vía las propiedades y los métodos correspondientes de la clase EvLoop. La instancia del bucle de eventos por defecto puede ser recuperada vía el método EvLoop::defaultLoop().

Tabla de contenidos

Ev::backend — Devuelve un integer que describe el backend utilizado por libev
Ev::depth — Retorna la profundidad de recursión
Ev::embeddableBackends — Devuelve el conjunto de backends que pueden ser encapsulados en otros bucles de eventos
Ev::feedSignal — Simula la recepción de una señal
Ev::feedSignalEvent — Simula un evento de señal en el bucle por omisión
Ev::iteration — Devuelve el número de veces que el bucle de eventos por omisión ha sido solicitado para un nuevo evento
Ev::now — Devuelve el tiempo de inicio de la última iteración del bucle de eventos por omisión
Ev::nowUpdate — Establece el tiempo actual solicitándolo al kernel; actualiza el tiempo devuelto por Ev::now durante la ejecución
Ev::recommendedBackends — Devuelve una máscara de octetos de backends recomendados para la plataforma actual
Ev::resume — Reanuda el bucle de eventos por defecto previamente detenido
Ev::run — Inicia la verificación de eventos y llama a las funciones de retrollamada para el bucle por defecto
Ev::sleep — Bloquea el proceso durante un número de segundos proporcionado
Ev::stop — Detiene el bucle de eventos predeterminado
Ev::supportedBackends — Devuelve el conjunto de backends soportados por la configuración actual de libev
Ev::suspend — Suspende el bucle de eventos predeterminado
Ev::time — Devuelve el tiempo actual desde la época Unix
Ev::verify — Efectúa verificaciones internas de consistencia (para la depuración)