A classe Ev

(PECL ev >= 0.2.0)

Introdução

Ev é uma classe estática que fornece acesso ao laço padrão e a algumas operações comuns.

Resumo da classe

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

Opções passadas para criar um laço:

Ev::FLAG_AUTO: O valor das opções padrão
Ev::FLAG_NOENV: Se esta opção for usada (ou o programa executar setuid ou setgid), libev não irá olhar para a variável de ambiente LIBEV_FLAGS. Caso contrário (por padrão), LIBEV_FLAGS substituirá as opções completamente se for encontrado. Útil para testes de desempenho e busca de bugs.
Ev::FLAG_FORKCHECK: Faz com que a libev verifique se há uma bifurcação em cada iteração, em vez de chamar EvLoop::fork() manualmente. Isso funciona chamando getpid() em cada iteração do laço e, portanto, isso pode desacelerar o laço de eventos com muitas iterações de laço, mas geralmente não é perceptível. Esta configuração de opção não pode ser substituída ou especificada na variável de ambiente LIBEV_FLAGS.
Ev::FLAG_NOINOTIFY: Quando esta opção é especificada, libev não tentará usar a API inotify para seus observadores » ev_stat. A opção pode ser útil para conservar descritores de arquivo inotify, caso contrário, cada laço usando observadores ev_stat consome um identificador inotify.
Ev::FLAG_SIGNALFD: Quando esta opção for especificada, libev tentará usar a API signalfd para seus observadores » ev_signal (e » ev_child). Essa API fornece sinais de forma síncrona, o que a torna mais rápida e pode possibilitar a obtenção dos dados do sinal enfileirados. Também pode simplificar o tratamento de sinais com threads, desde que os sinais sejam bloqueados adequadamente nos threads. Signalfd não será usado por padrão.
Ev::FLAG_NOSIGMASK: Quando esta opção for especificada, libev evitará modificar a máscara do sinal. Especificamente, isso significa ter certeza de que os sinais estão desbloqueados antes de recebê-los. Esse comportamento é útil para manipulação de sinal personalizado ou manipulação de sinais apenas em threads específicos.

Opções passadas para Ev::run() ou EvLoop::run()

Ev::RUN_NOWAIT: Significa que o laço de eventos irá procurar novos eventos, irá tratar esses eventos e quaisquer outros já pendentes, mas não irá esperar e bloquear o processo caso não haja eventos e retornará após uma iteração do laço. Às vezes, isso é útil para pesquisar e lidar com novos eventos ao fazer cálculos demorados, para manter o programa responsivo.
Ev::RUN_ONCE: Significa que o laço de eventos procurará novos eventos (aguardando se necessário) e tratará desses e de quaisquer outros já pendentes. Ele bloqueará o processo até que pelo menos um novo evento chegue (que pode ser um evento interno ao próprio libev, portanto não há garantia de que um retorno de chamada registrado pelo usuário será chamado) e retornará após uma iteração do laço.

Opção passada para Ev::stop() , ou EvLoop::stop()

Ev::BREAK_CANCEL: Cancele a operação de interrupção.
Ev::BREAK_ONE: Faz com que a chamada Ev::run() (ou EvLoop::run()) mais interna retorne.
Ev::BREAK_ALL: Faz com que todas as chamadas Ev::run() (ou EvLoop::run()) aninhadas retornem.

Prioridades do observador:

Ev::MINPRI: Prioridade mínima permitida do observador.
Ev::MAXPRI: Prioridade máxima permitida do observador.

Máscaras de bits de eventos (recebidos):

Ev::READ: O descritor de arquivo no observador EvIo tornou-se legível.
Ev::WRITE: O descritor de arquivo no observador EvIo tornou-se gravável.
Ev::TIMER: O tempo do observador EvTimer expirou.
Ev::PERIODIC: O tempo do observador EvPeriodic expirou.
Ev::SIGNAL: Um sinal especificado em EvSignal::__construct() foi recebido.
Ev::CHILD: O pid especificado em EvChild::__construct() recebeu uma alteração de status.
Ev::STAT: O caminho especificado no observador EvStat alterou seus atributos.
Ev::IDLE: O observador EvIdle funciona quando não há nada a fazer com outros observadores.
Ev::PREPARE: Todos os observadores EvPrepare são invocados logo antes do início de Ev::run(). Assim, os observadores EvPrepare são os últimos observadores invocados antes do laço de eventos dormir ou pesquisar novos eventos.
Ev::CHECK: Todos os observadores EvCheck são enfileirados logo após Ev::run() reunir os novos eventos, mas antes de enfileirar quaisquer retornos de chamada para quaisquer eventos recebidos. Assim, os observadores EvCheck serão invocados antes de quaisquer outros observadores de prioridade igual ou inferior dentro de uma iteração do laço de eventos.
Ev::EMBED: O laço de eventos incorporado especificado no observador EvEmbed precisa de atenção.
Ev::CUSTOM: Nunca enviado (ou usado de outra forma) pela própria libev, mas pode ser usado livremente por usuários da libev para sinalizar observadores (por exemplo, via EvWatcher::feed()).
Ev::ERROR: Ocorreu um erro não especificado, o observador foi interrompido. Isto pode acontecer porque o observador não pôde ser iniciado corretamente porque libev ficou sem memória, um descritor de arquivo foi fechado ou qualquer outro problema. Libev considera esses bugs de aplicação. Veja também » ANATOMIA DE UM OBSERVADOR

Opções de backend:

Ev::BACKEND_SELECT: select(2) backend
Ev::BACKEND_POLL: poll(2) backend
Ev::BACKEND_EPOLL: Backend epoll(7) específico do Linux para kernels pré e pós-2.6.9
Ev::BACKEND_KQUEUE: Backend kqueue usado na maioria dos sistemas BSD. O observador EvEmbed pode ser usado para incorporar um laço (com backend kqueue) em outro. Por exemplo, pode-se tentar criar um laço de eventos com backend kqueue e usá-lo apenas para soquetes.
Ev::BACKEND_DEVPOLL: Back-end do Solaris 8. Isso ainda não foi implementado.
Ev::BACKEND_PORT: Mecanismo de porta de eventos Solaris 10 com bom dimensionamento.
Ev::BACKEND_ALL: Experimente todos os back-ends (mesmo os corrompidos). Não é recomendado usá-lo explicitamente. Operadores bit a bit devem ser aplicados aqui (por exemplo, Ev::BACKEND_ALL & ~ Ev::BACKEND_KQUEUE). Use Ev::recommendedBackends() ou não não especifique nenhum back-end.
Ev::BACKEND_MASK: Não é um backend, mas uma máscara para selecionar todos os bits de backend do valor flags para mascarar quaisquer backends (por exemplo, ao modificar a variável de ambiente LIBEV_FLAGS).

Nota: Para o laço padrão durante a fase de inicialização do módulo, Ev registra » ev_loop_fork chamada por meio de pthread_atfork (se disponível).

Nota: Existem métodos que fornecem acesso ao laço de eventos padrão na classe Ev (por exemplo, Ev::iteration(), Ev::depth() etc.) Para laços personalizados (criados com EvLoop::__construct()) esses valores podem ser acessados através de propriedades e métodos correspondentes da classe EvLoop. A instância do laço de eventos padrão em si pode ser obtida por meio do método EvLoop::defaultLoop().

Índice

Ev::backend — Retorna um inteiro descrevendo o backend usado por libev
Ev::depth — Retorna profundidade de recursão
Ev::embeddableBackends — Retorna o conjunto de backends que podem ser incorporados em outros laços de eventos
Ev::feedSignal — Alimenta um evento de sinal info Ev
Ev::feedSignalEvent — Alimenta o evento de sinal no laço padrão
Ev::iteration — Retorna o número de vezes que o laço de eventos padrão pesquisou novos eventos
Ev::now — Retorna o horário em que a última iteração do laço de eventos padrão foi iniciada
Ev::nowUpdate — Estabelece a hora atual consultando o kernel, atualizando o horário retornado por Ev::now no progresso
Ev::recommendedBackends — Retorna uma máscara de bits de backends recomendados para a plataforma atual
Ev::resume — Retoma o laço de eventos padrão suspenso anteriormente
Ev::run — Começa a verificar eventos e chamar funções de retorno para o laço padrão
Ev::sleep — Bloqueia o processo pelo número de segundos fornecido
Ev::stop — Interrompe o laço de eventos padrão
Ev::supportedBackends — Retorna o conjunto de backends suportados pela configuração atual do libev
Ev::suspend — Suspende o laço de eventos padrão
Ev::time — Retorna o horário atual em segundos fracionários desde a época
Ev::verify — Executa verificações de consistência interna (para depuração)