A classe Ev

(PECL ev >= 0.2.0)

Introdução

Ev é uma classe estática que fornece acesso ao loop 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 loop:

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á os sinalizadores 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 loop e, portanto, isso pode desacelerar o loop de eventos com muitas iterações de loop, 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 este sinalizador é especificado, libev não tentará usar a API inotify para seu » ev_stat observadores. O sinalizador pode ser útil para conservar descritores de arquivo inotify, caso contrário, cada loop usando observadores ev_stat consome um identificador inotify.

Ev::FLAG_SIGNALFD

Quando esta flag 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 loop 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 loop. À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 loop 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 loop.

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 loop 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 loop de eventos.
Ev::EMBED: O loop 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 loop (com backend kqueue) em outro. Por exemplo, pode-se tentar criar um loop de eventos com backend kqueue e usá-lo apenas para sockets.
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 loop 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 loop de eventos padrão na classe Ev (por exemplo, Ev::iteration() , Ev::depth() etc.) Para loops 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 loop de eventos padrão em si pode ser obtida por meio do método EvLoop::defaultLoop().

Índice

Ev::backend — Returns an integer describing the backend used by libev
Ev::depth — Returns recursion depth
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)

Melhore Esta Página

Aprenda Como Melhorar Esta Página • Envie uma Solicitação de Modificação • Reporte um Problema

＋adicione uma nota

Notas Enviadas por Usuários (em inglês)

Não há notas de usuários para esta página.