La classe Ev

(PECL ev >= 0.2.0)

Introduction

La classe Ev est une classe statique fournissant l'accès à la boucle par défaut ainsi qu'à quelques opérations communes.

Synopsis de la 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éthodes */

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 pré-définies

Drapeaux passés pour créer une boucle :

Ev::FLAG_AUTO: La valeur par défaut des drapeaux
Ev::FLAG_NOENV: Si ce drapeau est utilisé (ou que le programme exécute setuid ou setgid), libev ne va pas regarder la variable d'environnement LIBEV_FLAGS. Sinon (comportement par défaut), LIBEV_FLAGS va écraser complètement le drapeau s'il est trouvé. Utile pour des tests de performance et pour la recherche de bogues.
Ev::FLAG_FORKCHECK: Fait que libev va vérifier si un fork existe à chaque itération, au lieu d'appeler manuellement la méthode EvLoop::fork(). Ce mécanisme fonctionne en appelant getpid() à chaque itération de la boucle, et ainsi, va ralentir la boucle d'événements qui possèdent beaucoup d'itérations, mais habituellement, ce ralentissement n'est pas notable. La configuration de ce drapeau ne peut pas être écrasée ou spécifiée dans la variable d'environnement LIBEV_FLAGS.
Ev::FLAG_NOINOTIFY: Lorsque ce drapeau est spécifié, libev ne va pas tenter d'utiliser l'API inotify pour ces watchers » ev_stat. Ce drapeau peut être utile pour conserver les descripteurs de fichiers inotify, sachant que sinon, chaque boucle utilisant les watchers ev_stat va consommer un gestionnaire inotify.
Ev::FLAG_SIGNALFD: Lorsque ce drapeau est spécifié, libev va tenter d'utiliser l'API signalfd pour ces watchers » ev_signal (et » ev_child). Cette API délivre les signaux de façon asynchrone, ce qui la rend plus rapide, et peut permettre la récupération des données des signaux en attente. Elle peut également simplifier la gestion des signaux avec les threads, sachant que les signaux sont des propriétés bloquées dans les threads. Signalfd ne sera pas utilisé par défaut.
Ev::FLAG_NOSIGMASK: Lorsque ce drapeau est spécifié, libev ne va pas modifier le masque du signal. Ceci signifie qu'il faut s'assurer que les signaux sont déverrouillés avant de les recevoir. Ce comportement est utile pour la gestion personnalisée des signaux, ou la gestion des signaux uniquement dans des threads spécifiques.

Drapeaux à passer à Ev::run(), ou à EvLoop::run()

Ev::RUN_NOWAIT: Signifie que la boucle d'événements va regarder si de nouveaux événements sont présents, va gérer ces nouveaux événements, et tous les événements spéciaux, mais ne va pas attendre et bloquer le processus dans le cas où il n'y a pas d'événement, et va retourner après une itération de la boucle. Il est parfois utile de placer en file et gérer les nouveaux événements pendant de longs calculs, et ce, pour garder le programme actif.
Ev::RUN_ONCE: Signifie que la boucle d'événements va regarder si de nouveaux événements sont présents (et attendre, si nécessaire), et va les gérer, eux et les spéciaux. Elle va bloquer le processus tant qu'au moins un événement arrive (qui peut être un événement interne à libev, aussi, il n'est pas garanti qu'une fonction de rappel enregistrée par l'utilisateur ne soit appelée), et va retourner après une itération de la boucle.

Drapeaux passés à Ev::stop(), ou à EvLoop::stop()

Ev::BREAK_CANCEL: Annule l'opération d'annulation.
Ev::BREAK_ONE: Retourne le plus profond appel à Ev::run() (ou EvLoop::run()).
Ev::BREAK_ALL: Retourne le plus proche appel à Ev::run() (ou EvLoop::run()).

Priorités de Watcher :

Ev::MINPRI: Priorité minimale autorisée pour un watcher.
Ev::MAXPRI: Priorité maximale autorisée pour un watcher.

Masques d'octets d'événements (reçus) :

Ev::READ: Le descripteur de fichier dans le watcher EvIo est devenu accessible en lecture.
Ev::WRITE: Le descripteur de fichier dans le watcher EvIo est devenu accessible en écriture.
Ev::TIMER: Le watcher EvTimer a atteint son délai maximal d'attente.
Ev::PERIODIC: Le watcher EvPeriodic a atteint son délai maximal d'attente.
Ev::SIGNAL: Un signal spécifié dans EvSignal::__construct() a été reçu.
Ev::CHILD: Le pid spécifié dans EvChild::__construct() a reçu une modification de statut.
Ev::STAT: Le chemin spécifié dans le watcher EvStat a modifié ses attributs.
Ev::IDLE: Le watcher EvIdle fonctionne lorsqu'il n'a aucune autre tâche à faire avec les autres watchers.
Ev::PREPARE: Tous les watchers EvPrepare sont appelés juste avant le démarrage de Ev::run(). Ainsi, les watchers EvPrepare sont les derniers watchers à être appelés avant le repos de la boucle d'événements, ou la mise en file des nouveaux événements.
Ev::CHECK: Tous les watchers EvCheck sont placés en file d'attente juste après que Ev::run() ait récupéré les nouveaux événements, mais avant, toutes les fonctions de rappel de tous les événements reçus sont placées en file d'attente. Ainsi, les watchers EvCheck seront appelés avant tout autre watcher de même priorité ou de priorité plus basse dans une itération de boucle d'événements.
Ev::EMBED: La boucle d'événements embarquée spécifiée dans le watcher EvEmbed a besoin de toute l'attention.
Ev::CUSTOM: Pas encore envoyé (ou utilisé) par libev, mais peut être librement utilisé par les utilisateurs libev pour signaler les watchers (c.-à-d. via la méthode EvWatcher::feed()).
Ev::ERROR: Une erreur inconnue est survenue, le watcher s'est arrêté. Ceci peut arriver car le watcher n'a pas pu être démarré proprement car libev a dépassé la mémoire allouée, un descripteur de fichier a été fermé, ou tout autre problème. Libev considère ceci comme des bogues de l'application. Voir aussi » l'anatomie d'un watcher

Drapeaux de Backend :

Ev::BACKEND_SELECT: select(2) backend
Ev::BACKEND_POLL: poll(2) backend
Ev::BACKEND_EPOLL: Backend epoll(7) spécifique à Linux pour, à la fois, les kernels avant et après 2.6.9.
Ev::BACKEND_KQUEUE: Backend kqueue utilisé sur la plupart des systèmes BSD. Le watcher EvEmbed peut être utilisé pour embarquer une boucle (avec le backend kqueue) dans une autre. Actuellement, une boucle peut tenter de créer une boucle d'événements avec le backend kqueue et l'utiliser uniquement pour les sockets.
Ev::BACKEND_DEVPOLL: Backend Solaris 8. Actuellement non implémenté.
Ev::BACKEND_PORT: Mécanisme de port d'événements Solaris avec un bon rendement.
Ev::BACKEND_ALL: Essai tous les backends (y compris les corrompus). Il n'est pas recommandé de l'utiliser explicitement. Les opérateurs de bits devraient être appliqués ici (c.-à-d. Ev::BACKEND_ALL & ~ Ev::BACKEND_KQUEUE). Utiliser la méthode Ev::recommendedBackends() ou ne spécifiez aucun backend.
Ev::BACKEND_MASK: Pas un backend, mais un masque pour sélectionner tous les bits d'un backend depuis la valeur de flags pour représenter dans un masque n'importe quel backend (c.-à-d. lors de la modification de la variable d'environnement LIBEV_FLAGS).

Note: Pour la boucle par défaut, pendant la phase d'initialisation du module, Ev enregistre des appels à » ev_loop_fork via pthread_atfork (si disponible).

Note: Il y a des méthodes fournissant l'accès à la boucle d'événements par défaut dans la classe Ev (c.-à-d. Ev::iteration(), Ev::depth(), etc.) Pour les boucles personnalisées (créées avec EvLoop::__construct()), ces valeurs peuvent être accessibles via les propriétés et les méthodes correspondantes de la classe EvLoop. L'instance de la boucle d'événements par défaut peut être récupérée via la méthode EvLoop::defaultLoop().

Sommaire

Ev::backend — Retourne un entier décrivant le backend utilisé par libev
Ev::depth — Retourne la profondeur de récursion
Ev::embeddableBackends — Retourne le jeu de backends qui sont encapsulés dans les autres boucles d'événements
Ev::feedSignal — Simule la réception d'un signal
Ev::feedSignalEvent — Simule un événement de signal dans la boucle par défaut
Ev::iteration — Retourne le nombre de fois que la boucle d'événement par défaut a été sollicitée pour un nouvel événement
Ev::now — Retourne le temps de démarrage de la dernière itération de la boucle d'événement par défaut
Ev::nowUpdate — Établit le temps courant en demandant au kernel ; met à jour le temps retourné par Ev::now pendant l'exécution
Ev::recommendedBackends — Retourne un masque d'octets de backends recommandés pour la plateforme courante
Ev::resume — Reprend la boucle d'événement par défaut précédemment stoppée
Ev::run — Commence la vérification des événements et appelle les fonctions de rappels pour la boucle par défaut
Ev::sleep — Bloque le processus pendant un nombre de secondes fourni
Ev::stop — Arrête la boucle d'événements par défaut
Ev::supportedBackends — Retourne le jeu de backends supportés par la configuration courante de libev
Ev::suspend — Suspend la boucle par défaut d'événements
Ev::time — Retourne le temps courant depuis l'époque Unix
Ev::verify — Effectue des vérifications internes de consistance (pour le débogage)