La clase Ev

(PECL ev >= 0.2.0)

Introducción

Ev es una clase estática que proporciona acceso al bucle por omsión y 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 disponibles para crear un bucle:

Ev::FLAG_AUTO

El valor del flag por defecto

Ev::FLAG_NOENV

Si este flag es utilizado (o el programa corre setuid o setgid), libev no tendrá en cuenta la variable de entorno LIBEV_FLAGS . De otro modo (por defecto), LIBEV_FLAGS reemplazará los flags completamente si es definido. Útil para evaluación de performance y para encontrar errores.

Ev::FLAG_FORKCHECK

Permite que libev verifique un fork en cada iteración, en lugar de llamar a EvLoop::fork() manualmente. Esto funciona al llamar a getpid() en cada iteración del bucle, y como tal podrá alentizar el bucle de eventos con numerosas iteraciones, aunque esto no es usualmente notorio. Este flag no puede ser reemplazado o especificado mediante la variable de entorno LIBEV_FLAGS.

Ev::FLAG_NOINOTIFY

Cuando este flag es especificado, libev no intentará utilizar la API inotify para sus watchers » ev_stat. El flag puede ser útil para conservar los descriptores de archivo inotify, ya que de otro modo cada bucle que utilice watchers ev_stat consumen un handle inotify.

Ev::FLAG_SIGNALFD

Cuando este flag es especificado, libev intentará utilizar la API signalfd para sus watchers » ev_signal (y » ev_child ). Esta API entrega las señales sincrónicamente, lo que la hace más rápida y puede permitir obtener los datos de señal encolados. También puede simplificar el manejo de señales mediante hilos, siempre y cuando las señales sean bloqueadas apropiadamente en los hilos. Signalfd no será utilizado por defecto.

Ev::FLAG_NOSIGMASK

Cuando este flag es especificado, libev hará imposible la modificación de la máscara de señal. Esto significa que será necesario asegurarse que las señales están desbloqueadas antes de recibirlas.

Este comportamiento es útil para el manejo de señales personalizado, o para manipular señales solamente en hilos específicos.

Flags disponibles para Ev::run() , o EvLoop::run()

Ev::RUN_NOWAIT: Significa que el bucle de eventos buscará nuevos eventos, y manejará aquellos eventos y cualquier otro evento pendiente, pero no esperará ni bloqueará el proceso en caso de que no haya eventos, retornando luego de una iteración del bucle. Esto es útil para obtener nuevos eventos mientras se realizan cálculos costosos, manteniendo el programa funcionando.
Ev::RUN_ONCE: Significa que el bucle de eventos buscará nuevos eventos (esperando si es necesario) y manejará aquellos eventos, y cualquier otro evento pendiente. Bloqueará el proceso hasta que al menos un evento esté disponible (que podría ser un evento interno a libev, por lo que no hay garantía de que un callback registrado por el usuario sea llamado), y retornará luego de una iteración del bucle.

Flags disponibles para Ev::stop() , o EvLoop::stop()

Ev::BREAK_CANCEL: Cancelar la operación break.
Ev::BREAK_ONE: Hace que la llamada interior Ev::run() (o EvLoop::run() ) retorne.
Ev::BREAK_ALL: Hace que todas las llamadas Ev::run() (o EvLoop::run() ) retornen.

Prioridades Watcher:

Ev::MINPRI: Prioridad mínima disponible.
Ev::MAXPRI: Prioridad máxima disponible.

Máscaras de Bit de los eventos (recibidos):

Ev::READ: El descriptor de archivo en el watcher EvIo se ha vuelto disponible.
Ev::WRITE: El descriptor de archivo en el watcher EvIo se ha vuelto modificable.
Ev::TIMER: El watcher EvTimer ha agotado su tiempo.
Ev::PERIODIC: El watcher EvPeriodic ha agotado su tiempo.
Ev::SIGNAL: Una señal especificada en EvSignal::__construct() ha sido recibida.
Ev::CHILD: El pid especificado en EvChild::__construct() ha recibido una alteración de estado.
Ev::STAT: El path especificado en el watcher EvStat ha modificado sus atributos.
Ev::IDLE: El watcher EvIdle trabaja cuando no hay nada que hacer con otros watchers.
Ev::PREPARE: Todos los watchers EvPrepare son invocados justo antes de que Ev::run() comience. Así, los watchers EvPrepare son los últimos en ser invocados antes de que el bucle de eventos duerma, o busque nuevos eventos.
Ev::CHECK: Todos los watchers EvCheck son encolados justo luego de que Ev::run() haya obtenido los nuevos eventos, pero antes de que encole cualquier callback para los eventos recibidos. Así, los watchers EvCheck serán invocados antes que cualquier otro watcher de la misma o menor prioridad dentro de la iteración del bucle de eventos.
Ev::EMBED: El bucle embebido especificado en el watcher EvEmbed necesita atención.
Ev::CUSTOM: Nunca enviado (o utilizado) por libev, pero puede ser libremente utilizado por los usuarios de libev para enviar señales a watchers (por ejemplo a través de EvWatcher::feed() ).
Ev::ERROR: Un error no especificado ha ocurrido, y el watcher se ha detenido. Esto puede ocurrir ya sea porque el watcher no haya sido inicializado apropiadamente debido a que libev ha agotado la memoria disponible, porque un descriptor de archivo se encontraba ya cerrado, o por cualquier otro problema. Libev considera estos errores como errores de aplicación. Véase también » ANATOMY OF A WATCHER

Flags de Backend:

Ev::BACKEND_SELECT: Backend select(2)
Ev::BACKEND_POLL: Backend poll(2)
Ev::BACKEND_EPOLL: Backend específico a Linux epoll(7) tanto para kernels anteriores o posteriores a la versión 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 e backend kqueue ) dentro de otro. Por ejemplo, uno puede intentar crear un bucle de eventos con el backend kqueue y utilizarlo solamente por sus sockets.
Ev::BACKEND_DEVPOLL: Backend Solaris 8. Aún no implementado.
Ev::BACKEND_PORT: Mecanismo de puerto Solaris 10 con buena escalabilidad.
Ev::BACKEND_ALL: Intentar todos los backends (incluso los corrompidos). No es recomendado utilizar este flag explícitamente. En su lugar deberían utilizarse operaciones Bitwise (por ejemplo Ev::BACKEND_ALL & ~ Ev::BACKEND_KQUEUE ). Utiliza Ev::recommendedBackends() , o no especifiques ningún backend en especial.
Ev::BACKEND_MASK: No es un backend, sino una máscara que permite seleccionar todos los bits de backends desde el valor flags para sacar de la máscara cualquier backend (por ejemplo cuando se modifica la variable de entorno LIBEV_FLAGS ).

Nota:
Durante la fase de inicialización del módulo, Ev registtra para el bucle por defecto una llamada a » ev_loop_fork a través de pthread_atfork (si se encuentra disponible).

Nota:
Existen métodos que ofrecen acceso al bucle de eventos por defecto en la clase Ev (por ejemplo Ev::iteration() , Ev::depth() etc.) Para bucles personalizados (creados con EvLoop::__construct() ) estos valores pueden ser accedidos a través de propiedades y métodos correspondientes de la clase EvLoop .

La instancia del bucle de eventos por defecto puede ser obtenida a través del método EvLoop::defaultLoop() .

Tabla de contenidos

Ev::backend — Devuelve un entero que describe el back-end utilizado por libev
Ev::depth — Devuelve la profundidad de la recursividad
Ev::embeddableBackends — Returns the set of backends that are embeddable in other event loops
Ev::feedSignal — Feed a signal event info Ev
Ev::feedSignalEvent — Feed signal event into the default loop
Ev::iteration — Return the number of times the default event loop has polled for new events
Ev::now — Returns the time when the last iteration of the default event loop has started
Ev::nowUpdate — Establishes the current time by querying the kernel, updating the time returned by Ev::now in the progress
Ev::recommendedBackends — Returns a bit mask of recommended backends for current platform
Ev::resume — Resume previously suspended default event loop
Ev::run — Begin checking for events and calling callbacks for the default loop
Ev::sleep — Block the process for the given number of seconds
Ev::stop — Stops the default event loop
Ev::supportedBackends — Returns the set of backends supported by current libev configuration
Ev::suspend — Suspend the default event loop
Ev::time — Returns the current time in fractional seconds since the epoch
Ev::verify — Performs internal consistency checks(for debugging)

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes

There are no user contributed notes for this page.