Para utilizar el paquete Pthreads se necesitan los siguientes recursos :
El paquete crea un script especial para compilación
de código fuente multihilo en lenguaje C llamado pgcc,
y un script especial para compilación de código
fuente multihilo en lenguaje C++ llamado pg++
(la librería solo ofrece soporte de rutinas en C, aunque
se pueden entremezclar con código en C++) de tal forma
que estos serán los nombres que el programador deberá
emplear como identificadores del compilador. Normalmente estos
scripts y la librería se encontrarán en los PATHs
correspondientes del programador.
A continuación se van a describir las estructuras de datos, tipos y constantes que se emplean en el paquete de hilos Pthreads en su versión 1.60 Beta5, para la gestión de todo el sistema de hilos en tiempo de ejecución en el nivel de usuario.
Los tipos de estado en los que puede encontrarse un hilo se definen mediante la siguiente enumeración que se encuentra en el archivo STATE.DEF :
enum pthread_state { PS_RUNNING, PS_MUTEX_WAIT, PS_COND_WAIT, PS_FDLR_WAIT, PS_FDLW_WAIT, PS_FDR_WAIT, PS_FDW_WAIT, PS_SELECT_WAIT, PS_SLEEP_WAIT, PS_WAIT_WAIT, PS_SIGWAIT, PS_JOIN, PS_DEAD, PS_UNALLOCED, PS_STATE_MAX };
A continuación se describe el significado de cada estado. La estructura de la notación es ESTADO, data. En el futuro se espera que el campo data apunte al objeto por el cual el hilo está esperando.
El resto de estados ocurren cuando el hilo se encuentra esperando por algún evento :
Descriptores de fichero :
Los descriptores de ficheros tienen un bloqueo especial. Si es un descriptor del tipo FULL_DUPLEX como ocurre en el caso de un socket o un archivo fifo, entonces tiene dos mutex asociados, uno para lectura y otro para escritura. Algunas rutinas tratarán de obtener ambos mutex. Siempre intentarán obtener el mútex de lectura primero antes de intentar adquirir el de escritura. El resto de descriptores de ficheros sólo tienen un mútex asociado.
Otros estados :
Estos datos se encuentran en el archivo MUTEX.H.
enum pthread_mutextype
Los tipos de mutex que se pueden crear se definen mediante la siguiente enumeración :
enum pthread_mutextype { MUTEX_TYPE_STATIC_FAST = 0, MUTEX_TYPE_FAST = 1, MUTEX_TYPE_COUNTING_FAST = 2, /* Recursivo */ MUTEX_TYPE_METERED = 3, MUTEX_TYPE_DEBUG = 4, /* Con muchas opciones */ MUTEX_TYPE_MAX }; #define PTHREAD_MUTEXTYPE_FAST 1 #define PTHREAD_MUTEXTYPE_DEBUG 4 #define PTHREAD_MUTEXTYPE_RECURSIVE 2
union pthread_mutex_data
Definición de los datos sobre un mútex :
union pthread_mutex_data { void *m_ptr; /* Puntero a datos */ int m_count; /* Contador */ };
pthread_mutex_t
Este tipo define la estructura de datos que implementa un mútex :
typedef struct pthread_mutex { enum pthread_mutextype m_type; struct pthread_queue m_queue; struct pthread *m_owner; semaphore m_lock; union pthread_mutex_data m_data; long m_flags; } pthread_mutex_t;
pthread_mutexattr_t
Este tipo define la estructura de los atributos de un mútex :
typedef struct pthread_mutexattr { enum pthread_mutextype m_type; long m_flags; } pthread_mutexattr_t;
FLAGS DE MUTEX :
Definición de flags para un mutex :
#define MUTEX_FLAGS_PRIVATE 0x01 /* Mútex privado */ #define MUTEX_FLAGS_INITED 0x02 /* Mútex inicializado */ #define MUTEX_FLAGS_BUSY 0x04 /* Mútex ocupado */
PTHREAD_MUTEX_INITIALIZER :
Definición de los valores de inicialización de mútex estático :
#define PTHREAD_MUTEX_INITIALIZER \ { MUTEX_TYPE_STATIC_FAST, PTHREAD_QUEUE_INITIALIZER, \ NULL, SEMAPHORE_CLEAR, { NULL }, MUTEX_FLAGS_INITED }
Estos datos se encuentran en el archivo COND.H.
enum pthread_condtype
Los tipos de variable de condición que se pueden crear se definen mediante la siguiente enumeración :
enum pthread_condtype { COND_TYPE_FAST, COND_TYPE_STATIC_FAST, COND_TYPE_COUNTING_FAST,/* Usado con MUTEX_TYPE_COUNTING_FAST */ COND_TYPE_METERED, COND_TYPE_DEBUG, /* Muchas opciones */ COND_TYPE_MAX }; #define PTHREAD_CONDTYPE_FAST 1 #define PTHREAD_CONDTYPE_DEBUG 4 #define PTHREAD_CONDTYPE_RECURSIVE 2
pthread_cond_t
Este tipo establece la estructura de datos que implementa una variable de condición.
typedef struct pthread_cond { enum pthread_condtype c_type; struct pthread_queue c_queue; semaphore c_lock; void *c_data; long c_flags; } pthread_cond_t;
pthread_condattr_t
Definición de los atributos de una variable de condición :
typedef struct pthread_condattr { enum pthread_condtype c_type; long c_flags; } pthread_condattr_t;
FLAGS DE VARIABLE DE CONDICION :
Flags de la variable de condición :
#define COND_FLAGS_PRIVATE 0x01 /* Var.cond. privada */ #define COND_FLAGS_INITED 0x02 /* Var.cond. inicializada */ #define COND_FLAGS_BUSY 0x04 /* Var.cond. ocupada */
PTHREAD_COND_INITIALIZER :
Valores de inicialización de una variable de condición estática :
#define PTHREAD_COND_INITIALIZER \ { COND_TYPE_STATIC_FAST, PTHREAD_QUEUE_INITIALIZER, \ SEMAPHORE_CLEAR, NULL, COND_FLAGS_INITED }
Estos datos se encuentran en el archivo PTHREAD_ONCE.H.
pthread_once_t
Definición del tipo de variable de control de ejecución una sola vez :
typedef struct pthread_once { int state; pthread_mutex_t mutex; } pthread_once_t;
Definición de valores de inicialización de una variable de control estática :
#define PTHREAD_NEEDS_INIT 0 #define PTHREAD_DONE_INIT 1 #define PTHREAD_ONCE_INIT {PTHREAD_NEEDS_INIT, \ PTHREAD_MUTEX_INITIALIZER }
Estos datos se encuentran en el archivo SPECIFIC.H.
Definición de constantes :
#define PTHREAD_DATAKEYS_MAX 256
#define _POSIX_THREAD_DESTRUTOR_ITERATIONS 4
struct pthread_key
Definición de la estructura de la clave para datos específicos del hilo :
struct pthread_key { pthread_mutex_t mutex; long count; void (*destructor)(); };
pthread_key_t
Definición de la clave de datos específicos de hilo :
typedef int pthread_key_t;
Estos datos se encuentran en el archivo CLEANUP.H.
Definición de la estructura de datos relativas a los gestores de limpieza del hilo :
struct pthread_cleanup { struct pthread_cleanup *next; void (*routine)(); void *routine_arg; };
Estos datos se encuentran en el archivo PRIO_QUEUE.H.
Algunos límites y valores de las prioridades :
#define PTHREAD_DEFAULT_PRIORITY 64
#define PTHREAD_MAX_PRIORITY 126
#define PTHREAD_MIN_PRIORITY 0
Definición de la estructura de datos de nivel de prioridad de un hilo :
struct pthread_prio_level { struct pthread * first; struct pthread * last; };
Definición de la estructura de datos de la cola de prioridades de hilos :
struct pthread_prio_queue { void *data; struct pthread *next; struct pthread_prio_level level[PTHREAD_MAX_PRIORITY + 1]; };
Estructuras de datos de una cola de hilos.
Estos datos se encuentran en el archivo QUEUE.H.
struct pthread_queue { struct pthread *q_next; struct pthread *q_last; void *q_data; };
#define PTHREAD_QUEUE_INITIALIZER { NULL, NULL, NULL }
Estos datos se encuentran en el archivo PTHREAD_ATTR.H.
Macro de comprobación del nivel de cumplimiento del estándar POSIX :
#define _POSIX_THREAD_ATTR_STACKSIZE
Definición del tamaño de pila por defecto para el hilo :
#define PTHREAD_STACK_DEFAULT 65536
Definición de flags sobre características del hilo :
#define PTHREAD_DETACHED 0x1 /* No-POSIX */ #define PTHREAD_SCOPE_SYSTEM 0x2 #define PTHREAD_INHERIT_SCHED 0x4 #define PTHREAD_NOFLOAT 0x8 /* No-POSIX */ #define PTHREAD_CREATE_DETACHED PTHREAD_DETACHED #define PTHREAD_CREATE_JOINABLE 0 #define PTHREAD_SCOPE_PROCESS 0 #define PTHREAD_EXPLICIT_SCHED 0
enum schedparam_policy
Definición de las políticas de planificación del hilo :
enum schedparam_policy { SCHED_RR, /* Política Round-Robin */ SCHED_IO, /* Política de E/S */ SCHED_FIFO, /* Política First-In Firs-Out */ SCHED_OTHER /* Otro tipo de política */ };
pthread_attr_t
Definición de la estructura de los atributos de un hilo :
struct pthread_attr { enum schedparam_policy schedparam_policy; int prio; int flags; void *arg_attr; void (*cleanup_attr)(); void *stackaddr_attr; size_t stacksize_attr; }; typedef struct pthread_attr pthread_attr_t;
struct sched_param
Definición de la estructura de los parámetros de planificación :
struct sched_param { int prio; void *no_data; };
Estos datos se encuentran en el archivo PTHREAD.H.
struct pthread_select_data
Estructura de datos sobre el jacket de una selección select().
struct pthread_select_data { int nfds; fd_set readfds; fd_set writefds; fd_set exceptfds; };
union pthread_wait_data
Unión que define distintos datos sobre la espera de un hilo.
union pthread_wait_data { pthread_mutex_t *mutex; pthread_cond_t *cond; const sigset_t *sigwait; /* Esperando una señal en sigwait */ struct { short fd; /* Espera en un descriptor de fichero */ short branch; /* No. de linea, para depuración */ } fd; struct pthread_select_data *select_data; };
pthread_t
Definición de la estructura base del tipo hilo :
struct pthread { int thread_type; /* Tipo del hilo */ struct machdep_pthread machdep_data; /* Datos dependientesde máquina */ pthread_attr_t attr; /* Atributos del hilo */ /* Interfaz de señales */ sigset_t sigmask; /* Máscara de señales */ sigset_t sigpending; /* Señales pendientes */ int sigcount; /* No. de señales pendientes */ /* Instante en el que se despertará el hilo */ struct timespec wakeup_time; /* Cola de los hilos en espera de la finalización de otros */ struct pthread_queue join_queue; /* * Las implementaciones de hilos son implementaciones de tipos * de colas múltiples. A continuación se presentan las diversas * listas enlazadas necesarias actualmente. * Es posible que un hilo se encuentre en varias o en todas las * colas a la vez, aunque se debe tener mucha precaución durante * la manipulación de una cola. * * La estructura pthread debe ser bloqueada antes de buscar en * las listas enlazadas. */ /* Todos los hilos, en cualquier estado. Se debe obtener el
* bloqueo del kernel antes de su manipulación.
*/ struct pthread * pll; /* Lista enlazada de todos los hilos */ /* * Lista enlazada estándar para hilos en ejecución, mutex, etc... * El hilo no puede estar en una lista de ejecución y en una cola * de espera. Se debe obtener el bloqueo del kernel antes * de su manipulación. */ struct pthread * next; /* Lista de hilos */ union pthread_wait_data data; /* Datos sobre la espera */ /* * Estado de la cola actual y prioridad de un hilo. * (Nota: "priority" es una palabra reservada en Concurrent C, * por favor no usarla. --KR) */ struct pthread_queue * queue; enum pthread_state state; char flags; char pthread_priority; /* * Cola de Dormidos (sleep queue), que es distinta de la lista * enlazada estándar porque es posible estar en ambas * (Ej: pthread_cond_timedwait() ) * Se debe bloquear el mutex sleep antes de su manipulación. */ struct pthread *sll; /* Hilos durmiendo */ /* * Datos que no necesitan ser bloqueados. * La mayoría sólo pueden ser manipulados por el hilo * propietario. */ void *ret; /* Valor de retorno */ int error; int *error_p; const void **specific_data; /* Datos específicos del hilo */ int specific_data_count; /* No. de datos específicos */ /* Lista enlazada de gestores de limpieza */ struct pthread_cleanup * cleanup; }; typedef struct pthread * pthread_t;
Definición de variables globales.
Las variables globales empleadas por el paquete en su sistema de tiempo de ejecución que se encuentran definidas en el archivo GLOBALS.C son :
Descripción alfabética de funciones.
pthread_attr_getinheritsched()
pthread_attr_setinheritsched()
sigwait()
A continuación se presenta una referencia
alfabética de las funciones del paquete de hilos de nivel
de usuario Pthreads 1.60 Beta5 desarrollado por Chris Provenzano.
El nombre de cada función se presenta al comienzo, y está seguido por la siguiente información :
En ocasiones el nombre de la función va seguido de una notación entre corchetes que explica cierta característica de la función :
[ No POSIX ] La función no pertenece al estándar POSIX.1c, pero puede ser de gran utilidad en nuestras aplicaciones multihilo.
[ Función interna ] La función existe
de forma interna en la librería, pero no es utilizable
por el programador. El motivo es que no está declarada
en ningún fichero de cabecera. Se espera que en versiones
futuras estas funciones sean incluidas en ficheros de cabecera.
El programador podría intentar emplearlas observando el
código del paquete fuente y realizando cabeceras para estas
funciones, aunque normalmente son funciones que no tienen un gran
interés para al programador normal, sólo para el
programador de bajo nivel.
#include <stdio.h> void flockfile( FILE *file );
Si el stream especificado por file no está bloqueado, esta función bloquea dicho stream, establece al hilo actual como propietario del bloqueo, y establece el contador de bloqueos a uno. Si el stream ya estaba bloqueado por el hilo actual entonces sólo se incrementa el contador de bloqueos. En cualquier otro caso el hilo que realiza la llamada se bloquea hasta que el stream esté disponible.
Funciones relacionadas :
funlockfile(), ftrylockfile()
#include <stdio.h> int ftrylockfile( FILE *file );
Esta función es un versión sin bloqueo de la función flockfile(). Si el stream especificado por file no está bloqueado, esta función bloquea dicho stream, establece al hilo actual como propietario del bloqueo, establece el contador de bloqueos a uno, y devuelve el valor 0. Si el stream ya estaba bloqueado por el hilo actual entonces sólo se incrementa el contador de bloqueos y también devuelve el valor 0. En otro caso la función devuelve el valor 1. En cualquier caso la función no bloqueará el hilo actual en ejecución.
Funciones relacionadas :
flockfile(), funlockfile()
#include <stdio.h> void funlockfile( FILE *file );
Si el stream especificado por file está bloqueado por el hilo actual en ejecución, la función decrementa el contador de bloqueos. Si el contador de bloqueos alcanza el valor 0, el stream es liberado, y si existen hilos bloqueados en espera del stream, el planificador decidirá qué hilo obtiene el bloqueo, en otro caso el stream queda disponible para el siguiente hilo que realice una llamada flockfile() o ftrylockfile().
Funciones relacionadas :
flockfile(), ftrylockfile()
getchar_unlocked() [ No POSIX ]
putchar_unlocked() [ No POSIX ]
#include <stdio.h> int getc_unlocked( FILE *file ); int getchar_unlocked( void ); int putc_unlocked( int c, FILE *file ); int putchar_unlocked( int c );
Estas rutinas, excepto por no ser reentrantes, son funcionalmente equivalentes a las respectivas funciones reentrantes getc(), getchar(), putc() y putchar()de la librería STDIO.
Funciones relacionadas :
flockfile(), funlockfile(), ftrylockfile()
#include <pthread.h> int pthread_attr_destroy( pthread_attr_t *attr );
Esta función destruye la variable de atributos de hilo especificada por attr.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual del paquete siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_init()
#include <pthread.h> int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *state );
Esta función obtiene el atributo de estado independiente de la variable de atributos de hilo especificada por attr, y lo almacena en state.
Si la rutina tiene éxito devuelve 0 y state contendrá el valor PTHREAD_CREATE_DETACHED o el valor PTHREAD_CREATE_JOINABLE. Sino se devuelve un número de error indicando el tipo de error.
Funciones relacionadas :
pthread_attr_setdetachstate(), pthread_attr_init(), pthread_detach(), pthread_join()
pthread_attr_getfloatstate() [ No POSIX ]
#include <pthread.h> int pthread_attr_getfloatstate(pthread_attr_t *attr, int *floatstate)
Esta función obtiene el valor del atributo contexto de estado flotante attr y lo almacena en floatstate.
Funciones relacionadas :
pthread_attr_setfloatstate()
pthread_attr_getinheritsched()
#include <pthread.h> int pthread_attr_getinheritsched(pthread_attr_t *attr, int *inheritsched)
Esta función obtiene el atributo planificación heredada de attr en inheritsched.
Funciones relacionadas :
pthread_attr_setinheritsched()
#include <pthread.h> int pthread_attr_getschedparam(pthread_attr_t *attr, struct sched_param *param)
Esta función obtiene los parámetros de planificación del objeto de atributos de hilo attr en la variable de parámetros de planificación param. Por el momento el único parámetro es la prioridad de planificación del hilo.
Funciones relacionadas :
pthread_attr_setschedparam()
#include <pthread.h> int pthread_attr_getschedpolicy(pthread_attr_t *attr, int *schedpolicy)
Esta función obtiene el atributo política de planificación de attr y lo almacena en schedpolicy.
Funciones relacionadas :
pthread_attr_setschedpolicy()
#include <pthread.h> int pthread_attr_getscope(pthread_attr_t *attr, int *contentionscope)
Esta función obtiene el valor del atributo alcance de argumentos de attr y lo almacena en contentionscope. Permite saber si el alcance de los atributos es a nivel de todo el sistema (entre todos los hilos de todos los procesos) o a nivel local del proceso (entre todos los hilos del proceso). En la implementación actual el alcance solo puede ser a nivel de proceso no de sistema.
Funciones relacionadas :
pthread_attr_setscope()
#include <pthread.h> int pthread_attr_getstackaddr( pthread_attr_t *attr, void **stackaddr);
Esta función obtiene el atributo dirección de la pila de la variable de atributos de hilo especificada por attr, y lo almacena en stackaddr.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_getstacksize(), pthread_attr_setstackaddr(), pthread_attr_init()
#include <pthread.h> int pthread_attr_getstacksize( pthread_attr_t *attr, size_t *stacksize );
Esta función obtiene el atributo tamaño de pila de la variable de atributos de hilo especificada por attr, y lo almacena en stacksize.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_setstacksize(), pthread_attr_getstackaddr(), pthread_attr_init()
#include <pthread.h> int pthread_attr_init( pthread_attr_t *attr );
Esta función crea e inicializa una variable de atributos de hilo para ser empleada con la función pthread_create().
Si la rutina tiene éxito devuelve 0 y establece el nuevo identificador de variable de atributos en attr. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_destroy(), pthread_create()
pthread_attr_setcleanup() [ No POSIX ]
#include <pthread.h> int pthread_attr_setcleanup(pthread_attr_t *attr, void (*routine)(void *), void * arg)
Esta función establece el atributo gestor de limpieza attr con los valores indicados por routine y arg, respectivamente. Permite especificar la función de gestión de limpieza con sus argumentos, que será ejecutada al finalizar el hilo que tenga estos atributos. Es útil para eliminar argumentos que se pasan a un hilo, y se encuentran en memoria dinámica.
Funciones relacionadas :
pthread_attr_getcleanup()
#include <pthread.h> int pthread_attr_setdetachstate( const pthread_attr_t *attr, int state );
Esta función establece el atributo de estado independiente con el valor especificado por attr para todas los hilos creados con atributos attr. El valor de state debe ser PTHREAD_CREATE_DETACHED o PTHREAD_CREATE_JOINABLE.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_getdetachstate(), pthread_attr_init(), pthread_detach(), pthread_join()
pthread_attr_setfloatstate() [ No POSIX ]
#include <pthread.h> int pthread_attr_setfloatstate(pthread_attr_t *attr, int floatstate)
Esta función establece el valor del atributo estado flotante de attr con el valor indicado por floatstate. Esta función permite una mejora del rendimiento, ya que si se sabe a priori, que no se emplean datos de punto flotante, no necesitamos salvar el estado de punto flotante del procesador, a la hora de realizar el cambio de contexto del hilo.
Funciones relacionadas :
pthread_attr_getfloatstate()
pthread_attr_setinheritsched()
#include <pthread.h> int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched)
Esta función establece el atributo planificación heredada de attr con el valor indicado por inheritsched.
Funciones relacionadas :
pthread_attr_getinheritsched()
#include <pthread.h> int pthread_attr_setschedparam(pthread_attr_t *attr, struct sched_param param)
Esta función establece los parámetros de planificación del objeto de atributos de hilo attr en la variable de parámetros de planificación param. Por el momento el único parámetro es la prioridad de planificación del hilo.
Funciones relacionadas :
pthread_attr_getschedparam()
#include <pthread.h> int pthread_attr_setschedpolicy(pthread_attr_t *attr, int schedpolicy)
Esta función establece el atributo política de planificación de attr con el valor especificado por schedpolicy.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_attr_getschedpolicy()
#include <pthread.h> int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);
Esta función establece el valor del atributo alcance de argumentos de attr al valor indicado por contentionscope. Actualmente sólo está implementado el alcance a nivel proceso.
Errores :
Funciones relacionadas :
pthread_attr_getscope()
#include <pthread.h> int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr );
Esta función establece el atributo dirección de pila de la variable de atributos de hilo especificada por attr con el valor especificado en stackaddr para todos los hilos creados con los atributos attr.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_attr_setstacksize(), pthread_attr_getstackaddr(), pthread_attr_init()
#include <pthread.h> int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize );
Esta función establece el atributo tamaño de pila de la variable de atributos de hilo especificada por attr con el valor especificado en stacksize para todos los hilos creados con los atributos attr.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_attr_getstacksize(), pthread_attr_setstackaddr(), pthread_attr_init()
#include <pthread.h> void pthread_cleanup_push( void (*routine)(void *), void *routine_arg );
Si la función tiene éxito introducirá la función routine con el argumento routine_arg en la pila del hilo actual de gestores de limpieza (pila de cancelación). Estos gestores serán llamados en orden inverso cuando el hilo termina normalmente con pthread_exit() (o por una llamada pthread_cancel() realizada por otro hilo en las implementaciones futuras). Si la función falla no se informa del error.
Funciones relacionadas :
pthread_cleanup_pop(), pthread_exit()
#include <pthread.h> void pthread_cleanup_pop( int execute );
Esta función extrae la rutina de gestión de limpieza de la parte superior de la pila de hilos actual de gestores de limpieza (pila de cancelación), si la pila no está vacía, y ejecuta dicha rutina del gestor de limpieza si execute es distinto de cero. Si la función falla no se informa del error.
Funciones relacionadas :
pthread_cleanup_push(), pthread_exit()
#include <pthread.h> int pthread_cond_broadcast( pthread_cond_t *cond );
Esta función desbloquea todos los hilos bloqueados a la espera de la variable de condición especificada por cond.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_cond_init(), pthread_cond_wait(), pthread_cond_timedwait(), pthread_cond_signal()
#include <pthread.h> int pthread_cond_destroy( pthread_cond_t *cond );
Esta función destruye la variable de condición especificada por cond.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_cond_init()
#include <pthread.h> pthread_cond_t cond = PTHREAD_COND_INITIALIZER; int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr );
Esta función crea una nueva variable de condición, con los atributos especificados en attr, o atributos por defecto si attr es NULL. También puede emplearse la forma de inicialización estática para variables estáticas.
Si la rutina tiene éxito devuelve 0 y coloca el identificador de la nueva variable de condición en cond. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_cond_destroy()
#include <pthread.h> int pthread_cond_timedwait( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime );
Esta función bloquea de la misma forma que pthread_cond_wait(). El hilo en espera se desbloquea por las mismas condiciones y devuelve 0, o si el tiempo del sistema alcanza o excede del tiempo especificado por abstime se devuelve ETIMEDOUT. En cualquier caso el hilo recupera el bloqueo del mútex especificado por mutex.
Errores :
Funciones relacionadas :
pthread_cond_init(), pthread_cond_wait(), pthread_cond_signal(), pthread_cond_broadcast()
#include <pthread.h> int pthread_cond_signal( pthread_cond_t *cond );
Esta función desbloquea un sólo hilo bloqueado a la espera de la variable de condición especificada por cond. El planificador determinará qué hilo será desbloqueado.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_cond_init(), pthread_cond_wait(), pthread_cond_timedwait(), pthread_cond_broadcast()
#include <pthread.h> int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex );
Esta función bloquea de una sola vez (atómicamente) el hilo actual a la espera de una variable de condición especificada por cond, y desbloquea el mútex especificado por mutex. El hilo en espera se libera sólo después de que otro hilo realiza una llamada pthread_cond_signal() o pthread_cond_broadcast() con la misma variable de condición, y de esta forma el hilo actual recupera el bloqueo sobre el mútex.
Si la rutina tiene éxito devuelve 0, y el mutex especificado por mutex es bloqueado y pertenece al hilo actual. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_cond_init(), pthread_cond_signal(), pthread_cond_timedwait(), pthread_cond_broadcast()
pthread_condattr_destroy() [Función interna]
#include <condattr.c> int pthread_condattr_destroy(pthread_condattr_t *attr);
Esta función destruye el objeto attr de atributos de variable de condición.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_condattr_init()
pthread_condattr_gettype() [Función interna - No POSIX]
#include "condattr.c" int pthread_condattr_gettype(pthread_mutexattr_t *attr, unsigned int *type)
Esta función obtiene el tipo de variable de condición en type para el objeto de atributos de variable de condición indicado por attr. Los tipos posibles son :
PTHREAD_CONDTYPE_FAST, PTHREAD_CONDTYPE_RECURSIVE y PTHREAD_CONDTYPE_DEBUG.
Funciones relacionadas :
pthread_condattr_settype()
pthread_condattr_init() [Función interna]
#include <condattr.c> int pthread_condattr_init(pthread_condattr_t *attr)
Esta función inicializa el objeto attr de atributos de variable de condición.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_condattr_destroy()
pthread_condattr_settype() [Función interna - No POSIX]
#include <condattr.c> int pthread_condattr_settype(pthread_condattr_t *attr, unsigned int type)
Esta función establece el tipo de variable de condición indicado por type para el objeto de atributos de variable de condición indicado por attr. Los tipos disponibles son :
PTHREAD_CONDTYPE_FAST, PTHREAD_CONDTYPE_RECURSIVE y PTHREAD_CONDTYPE_DEBUG.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_condattr_gettype()
#include <pthread.h> int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg );
Esta rutina crea un nuevo hilo dentro de un proceso. El nuevo hilo comienza en la rutina start_routine que tiene un argumento inicial arg. El nuevo hilo tiene atributos especificados mediante attr, o atributos por defecto si attr es NULL.
Si la rutina tiene éxito devuelve 0 y pone el nuevo identificador de hilo en thread, sino devuelve un número de error indicando el error.
Errores :
Funciones relacionadas :
pthread_exit(), pthread_join()
#include <pthread.h> int pthread_detach( pthread_t thread );
Esta función independiza (aísla) el hilo thread, lo que indica al sistema que el hilo no necesita ningún tratamiento especial a su finalización, ni necesita ser mantenido hasta que el hilo padre capture su valor de estado. La memoria asociada con el hilo puede ser recuperada una vez que finalice.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_attr_getdetachstate(), pthread_setdetachstate(), pthread_join(), pthread_exit()
#include <pthread.h> int pthread_equal( pthread_t thread_1, pthread_t thread_2 );
Esta rutina compara los identificadores de hilo thread_1 y thread_2, devolviendo un valor distinto de 0 si los identificadores representan el mismo hilo. Sino devuelve 0, indicando que son distintos hilos.
Funciones relacionadas :
pthread_create(), pthread_self()
#include <pthread.h> int pthread_exit( void *status );
Esta rutina finaliza el hilo actual en ejecución y hace disponible el estado status para un hilo que realiza la llamada pthread_join() para sincronizarse con el hilo finalizado. Además ejecuta los gestores de limpieza pendientes en orden inverso al que fueron introducidos en la pila de cancelación con pthread_cleanup_push(). También ejecuta el gestor de limpieza de atributos del hilo y después todos los destructores de datos específicos del hilo.
Se realiza una llamada implícita a pthread_exit()al finalizar el hilo, si el hilo, distinto del hilo en el que la función main() fue la primera llamada, regresa de la rutina inicial especificada en pthread_create().
El proceso finaliza como si se realizara una llamada a la función del sistema exit(), con un estado de 0 si el hilo que finaliza es el último hilo en el proceso. La rutina pthread_exit() no puede regresar.
Funciones relacionadas :
pthread_key_create(), pthread_cleanup_push(), pthread_create(), pthread_join()
pthread_getschedparam() [Función interna]
#include <schedparam.c> int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param)
Esta función obtiene la política de planificación en policy y los parámetros de planificación (actualmente sólo la prioridad) en param para el hilo indicado.
Funciones relacionadas :
pthread_setschedparam()
#include <pthread.h> void * pthread_getspecific( pthread_key_t key );
Esta función devuelve el puntero asociado con la clave especificada key.
Si la rutina tiene éxito devuelve el puntero almacenado por la llamada más reciente a pthread_setspecific() para el hilo actual. Este valor puede ser NULL lo cual lo hace indistinguible de una condición de error.
Funciones relacionadas :
pthread_key_create(), pthread_setspecific()
#include <pthread.h> void pthread_init( void );
Esta función inicializa el hilo principal de un proceso. Es llamada implícitamente al iniciarse un proceso multihilo en la función main(). En versiones anteriores del paquete esta llamada debe ser realizada por el programa al iniciarse en la función main(), pero actualmente se incluye por compatibilidad.
Funciones relacionadas :
pthread_create()
#include <pthread.h> int pthread_join( pthread_t thread, void **status );
Esta función sincroniza el hilo actual con la finalización del hilo indicado thread. Si el hilo indicado no es independiente (no se llamó a pthread_detach()) y no existen otros hilos sincronizados con el hilo especificado, entonces la función pthread_join() suspende la ejecución del hilo actual y espera a la finalización del hilo indicado. En cualquier otro caso el resultado no está definido.
Si la rutina finaliza con éxito devuelve 0, y si status es distinto de NULL apunta al estado de salida del hilo con el que se sincronizó y que resultó de la llamada pthread_exit(). Si se produce algún fallo se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_attr_getdetachstate(), pthread_attr_setdetachstate(), pthread_detach(), pthread_exit()
#include <pthread.h> int pthread_mutex_destroy( pthread_mutex_t *mutex );
Esta función destruye el mútex especificado en mutex.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_mutex_init()
#include <pthread.h> pthread_mutext_t mutex = PTHREAD_MUTEX_INITIALIZER; int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr );
Esta función crea un nuevo mútex, con los atributos especificados en attr, o atributos por defecto si attr es NULL. También puede emplearse la forma de inicialización estática para variables estáticas.
Si la rutina tiene éxito devuelve 0 y coloca el identificador del nuevo mútex en mutex. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_mutex_destroy()
#include <pthread.h> int pthread_mutex_lock( pthread_mutex_t *mutex );
Esta función bloquea el mútex especificado por mutex. Si el mútex ya está bloqueado el hilo que realiza la llamada se suspende hasta que el mútex está disponible.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_mutex_init(), pthread_mutex_unlock(), pthread_mutex_trylock()
#include <pthread.h> int pthread_mutex_trylock( pthread_mutex_t *mutex );
Esta función bloquea el mútex especificado por mutex y devuelve 0. En otro caso se devuelve un número de error indicando el tipo de error. En cualquier caso la rutina no bloqueará el hilo actual en ejecución.
Errores :
Funciones relacionadas :
pthread_mutex_init(), pthread_mutex_lock()
#include <pthread.h> int pthread_mutex_unlock( pthread_mutex_t *mutex );
Esta rutina libera (desbloquea) el mútex especificado por mutex, si el hilo actual es su propietario. Si existen otros hilos bloqueados esperando por el mútex, el planificador selecciona el hilo que obtendrá el bloqueo, sino el mútex está disponible para el siguiente hilo que realice una petición de bloqueo sobre él mediante pthread_mutex_lock() o pthread_mutex_trylock().
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_mutex_init(), pthread_mutex_lock(), pthread_cond_wait()
pthread_mutexattr_destroy() [Función interna]
#include <mutexattr.c> int pthread_mutexattr_destroy( pthread_mutexattr_t *attr );
Esta función destruye el objeto de atributos de mútex indicado por attr que fue creado para la utilización con un mútex.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_mutexattr_init()
pthread_mutexattr_gettype () [Función interna - No POSIX]
#include <mutexattr.c> int pthread_mutexattr_gettype(pthread_mutexattr_t *attr, unsigned int *type)
Esta función obtiene el tipo de mútex en type para el objeto de atributos de mútex indicado por attr. Los tipos posibles son :
PTHREAD_MUTEXTYPE_FAST, PTHREAD_MUTEXTYPE_RECURSIVE y PTHREAD_MUTEXTYPE_DEBUG.
Funciones relacionadas :
pthread_mutexattr_settype()
pthread_mutexattr_init() [Función interna]
#include <mutexattr.c> int pthread_mutexattr_init( pthread_mutexattr_t *attr );
Esta función inicializa un objeto de atributos de mútex en attr para ser empleado con un mútex.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_mutexattr_destroy()
pthread_mutexattr_settype() [Función interna - No POSIX]
#include <mutexattr.c> int pthread_mutexattr_settype(pthread_mutexattr_t *attr, unsigned int type)
Esta función establece el tipo de mútex indicado por type para el objeto de atributos de mútex indicado por attr. Los tipos disponibles son :
PTHREAD_MUTEXTYPE_FAST, PTHREAD_MUTEXTYPE_RECURSIVE y PTHREAD_MUTEXTYPE_DEBUG.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_mutexattr_gettype()
#include <pthread.h> int pthread_key_create( pthread_key_t *key, void (*dest_routine)(void *) );
Esta función crea una nueva clave en un proceso visible a todos los hilos con la cual se pueden asociar datos específicos de hilo posteriormente. Esta clave puede ser empleada con las funciones pthread_setspecific() y pthread_getspecific() para almacenar y recuperar los datos asociados con el hilo. Además la nueva clave asocia una rutina destructor dest_routine que si no es NULL, es llamada a la finalización del hilo si los datos asociados con la clave para el hilo que finaliza son también distintos de NULL.
Durante la creación de la clave el valor asociado con la clave para todos los hilos es NULL, y durante la creación del hilo el valor asociado con todas las clave para dicho hilo es NULL.
Si la rutina tiene éxito devuelve 0, y pone el nuevo identificador de la clave en key. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_setspecific(), pthread_getspecific(), pthread_key_delete(), pthread_create(), pthread_exit()
#include <pthread.h> int pthread_key_delete( pthread_key_t key );
Esta función destruye la clave de datos específicos de hilo indicada por key.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_key_create()
#include <pthread.h> int pthread_kill(struct pthread *thread, int sig)
Esta función envía la señal sig al hilo indicado por thread. En la implementación actual siempre se devuelve 0.
Funciones relacionadas :
pthread_signal()
#include <pthread.h> pthread_once_t once_init = PTHREAD_ONCE_INIT; int pthread_once( pthread_once_t *once_init, void (*init_routine)(void) );
Esta función garantizará que la rutina de inicialización init_routine()es llamada una única vez por pthread_once para todas las llamadas de pthread_once que se realicen con la variable de control once_init. La variable de control once_init debe inicializarse de forma estática con PTHREAD_ONCE_INIT.
La rutina init_routine() será ejecutada una vez. El comportamiento de la función pthread_once() es indefinido si la variable de control once_init es dinámica, no se inicializó originalmente a PTHREAD_ONCE_INIT, o es modificada después de llamar a pthread_once().
Funciones relacionadas :
pthread_mutex_init(), pthread_mutex_lock()
pthread_prio_queue_deq() [ Función interna - No POSIX ]
#include <prio_queue.c> struct pthread *pthread_prio_queue_deq( struct pthread_prio_queue *queue )
Esta función extrae un hilo de la cola de prioridades queue. Si la función tiene éxito devuelve un puntero a la estructura del hilo extraído. Si la función no tiene éxito devuelve NULL.
Funciones relacionadas :
pthread_prio_queue_init(),pthread_prio_queue_enq()
pthread_prio_queue_enq() [ Función interna - No POSIX ]
#include <prio_queue.c> void pthread_prio_queue_enq(struct pthread_prio_queue *queue, struct pthread *thread)
Esta función introduce el hilo thread en la cola de prioridades queue.
Funciones relacionadas :
pthread_prio_queue_init(),pthread_prio_queue_deq()
pthread_prio_queue_init() [ Función interna - No POSIX ]
#include <prio_queue.c> void pthread_prio_queue_init(struct pthread_prio_queue *queue)
Esta función inicializa la cola de prioridades queue.
Funciones relacionadas :
pthread_prio_queue_enq(),pthread_prio_queue_deq()
pthread_queue_deq() [ Función interna - No POSIX ]
#include <queue.c> struct pthread *pthread_queue_deq(struct pthread_queue *queue)
Esta función extrae un hilo de la cola queue, y devuelve un puntero a dicho hilo. Si la función no tiene éxito devuelve NULL.
Funciones relacionadas :
pthread_queue_init(),pthread_queue_remove(),pthread_queue_get(), pthread_queue_enq()
pthread_queue_enq() [ Función interna - No POSIX ]
#include <queue.c> void pthread_queue_enq(struct pthread_queue *queue, struct pthread *thread)
Esta función añade el hilo thread a la cola de hilos queue.
Funciones relacionadas :
pthread_queue_init(),pthread_queue_remove(),pthread_queue_get(), pthread_queue_deq()
pthread_queue_get() [ Función interna - No POSIX ]
#include <queue.c> struct pthread *pthread_queue_get(struct pthread_queue *queue)
Esta función devuelve un puntero al primer hilo de la cola queue. Si la función no tiene éxito devuelve NULL.
Funciones relacionadas :
pthread_queue_init(),pthread_queue_remove(),pthread_queue_enq(), pthread_queue_deq()
pthread_queue_init() [ Función interna - No POSIX ]
#include <queue.c> void pthread_queue_init(struct pthread_queue *queue)
Esta función inicializa la cola de hilos queue.
Funciones relacionadas :
pthread_queue_enq(),pthread_queue_remove(),pthread_queue_get(), pthread_queue_deq()
pthread_queue_remove() [ Función interna - No POSIX ]
#include <queue.c> int pthread_queue_remove(struct pthread_queue *queue, struct pthread *thread)
Esta función extrae el hilo thread de la cola de hilos queue.
Si la función tiene éxito devuelve 0, sino devuelve un valor distinto de 0.
Funciones relacionadas :
pthread_queue_init(),pthread_queue_enq(),pthread_queue_get(), pthread_queue_deq()
#include <pthread.h> pthread_t pthread_self( void );
Esta función devuelve el identificador del hilo que realiza la llamada.
Funciones relacionadas :
pthread_create(), pthread_equal()
pthread_setschedparam() [ Función interna ]
#include <schedparam.c> int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
Esta función establece la política de planificación indicada por policy y los parámetros de planificación param para el hilo indicado.
Errores :
Funciones relacionadas :
pthread_getschedparam()
#include <pthread.h> int pthread_setspecific( pthread_key_t key, const void *pointer );
Esta función asocia el puntero pointer a una serie de datos con la clave especificada key. Cada hilo puede almacenar un puntero separado para una clave dada. Se supone que un hilo tiene datos asociados a una clave si el puntero almacenado no es NULL.
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número de error indicando el tipo de error.
Errores :
Funciones relacionadas :
pthread_key_create(), pthread_getspecific()
pthread_sigmask() [ Función interna ]
#include <sig.c> int pthread_sigmask(int how, const sigset_t *set, sigset_t * oset)
Esta función realiza una operación indicada por how sobre la máscara de señales set y obtiene la máscara de señales anterior del hilo que realiza la llamada en oset.
Si la función tiene éxito devuelve 0, en caso de error devuelve un valor distinto de 0 e indica el error en la variable errno.
Funciones relacionadas :
sigwait(), pthread_kill(),pthread_signal()
#include <pthread.h> int pthread_signal(int sig, void (*dispatch)(int))
Esta función asigna el gestor de señal dispatch para la señal sig. Actualmente es equivalente en funcionalidad a la función signal().
Si la rutina tiene éxito devuelve 0. Sino se devuelve un número distinto de 0.
Funciones relacionadas :
pthread_kill()
#include <pthread.h> void pthread_yield( void );
Esta función libera el procesador de forma voluntaria y da la oportunidad de ejecución a otro hilo. Se suele utilizar cuando un hilo solo espera un evento y no tiene trabajo que realizar, con el fin de liberar el procesador, de tal forma que se puede planificar otro hilo. Sirve para optimizar la utilización de la CPU. La utilización de esta llamada da la oportunidad de ejecución a otros hilos. Esta llamada puede ser muy útil para garantizar la recepción de sus propias señales a un hilo. Los borradores anteriores del estándar POSIX.1c incluían esta función en vez de sched_yield(). Se incluye para mantener la compatibilidad con versiones anteriores del paquete.
Funciones relacionadas :
pthread_kill()
#include <pthread.h> int sigwait(const sigset_t *set, int *sig)
Esta función suspende el hilo actual a la espera la indicación de la señal set.
Funciones relacionadas :
pthread_sigmask(), pthread_kill(),pthread_signal()
Existen un gran número de funciones del sistema que el paquete PTHREADS ha modificado para hacerlas seguras frente a la programación con hilos. Otras en cambio aún están en construcción y no son hilo-seguras. Además de las funciones que se presentan aquí, también son hilo-seguras todas las funciones de las librería STDIO, y existen versiones reentrantes para la librería NETDB.
A continuación se presenta un listado de estas funciones :
void _exit(int); int access(const char *, int); int chdir(const char *); int chown(const char *, uid_t, gid_t); int close(int); int dup(int); int dup2(int, int); int execve(const char *, char * const *, char * const *); pid_t fork(void); int isatty(int)); int link(const char *, const char *); off_t lseek(int, off_t, int); int pipe(int *); ssize_t read(int, void *, size_t); u_int sleep(u_int); char *ttyname(int); int unlink(const char *); ssize_t write(int, const void *, size_t);
int acct(const char *); int async_daemon(void); char *brk(const char *); int chflags(const char *, long); int chroot(const char *); char *crypt(const char *, const char *); int des_cipher(const char *, char *, long, int); int des_setkey(const char *key); int encrypt(char *, int); void endusershell(void); int exect(const char *, char * const *, char * const *); int fchdir(int); int fchflags(int, long); int fchown(int, uid_t, gid_t); int fsync(int); int ftruncate(int, off_t); int getdtablesize(void); long gethostid(void); int gethostname(char *, int); mode_t getmode(const void *, mode_t); int getpagesize(void); char *getpass(const char *); char *getusershell(void); char *getwd(char *); /* obsoleted by getcwd() */ int initgroups(const char *, int); int mknod(const char *, mode_t, dev_t); int mkstemp(char *); char *mktemp(char *); int nfssvc(int); int nice(int); void psignal(u_int, const char *); int profil(char *, int, int, int); int rcmd(char **, int, const char *, const char *, const char *, int *); char *re_comp(const char *); int re_exec(const char *); int readlink(const char *, char *, int); int reboot(int); int revoke(const char *); int rresvport(int *); int ruserok(const char *, int, const char *, const char *); char *sbrk(int); int setegid(gid_t); int seteuid(uid_t); int setgroups(int, const int *); void sethostid(long); int sethostname(const char *, int); int setkey(const char *); int setlogin(const char *); void *setmode(const char *); int setpgrp(pid_t pid, pid_t pgrp); /* obsoleted by setpgid() */ int setregid(int, int); int setreuid(int, int); int setrgid(gid_t); int setruid(uid_t); void setusershell(void); int swapon(const char *); int symlink(const char *, const char *); void sync(void); int syscall(int, ...); int truncate(const char *, off_t); int ttyslot(void); u_int ualarm(u_int, u_int); void usleep(u_int); int vfork(void);
long fpathconf(int, int); /* not yet */ long pathconf(const char *, int); /* not yet */ long sysconf(int); /* not yet */ u_int alarm(u_int); char *cuserid(char *); int execl(const char *, const char *, ...); int execle(const char *, const char *, ...); int execlp(const char *, const char *, ...); int execv(const char *, char * const *); int execvp(const char *, char * const *); char *getcwd(char *, size_t); gid_t getegid(void); uid_t geteuid(void); gid_t getgid(void); int getgroups(int, int *); /* XXX (gid_t *) */ char *getlogin(void); pid_t getpgrp(void); pid_t getpid (void); pid_t getppid(void); uid_t getuid(void); int pause(void); int rmdir(const char *); int setgid(gid_t); int setpgid(pid_t, pid_t); pid_t setsid(void); int setuid(uid_t); pid_t tcgetpgrp(int); int tcsetpgrp(int, pid_t);
Si se van a realizar modificaciones sobre el fuente del paquete se deben tener en cuenta las siguientes reglas cuando se utilizan los bloqueos :
Existen una serie de diferencias entre la implementación del paquete de hilos Pthreads y la que especifica el estándar POSIX 1003.1c.
La implementación actual de Pthreads 1.60 beta 5 soporta :
A continuación se muestra un cuadro que resume
las funciones que están implementadas en Pthreads y las
que expone el estándar POSIX 1003.1c. Existen funciones
que se encuentran en MIT Pthreads pero no se encuentran en el
estándar, mientras que otras que se encuentran en el estándar
aún no están implementadas en el paquete Pthreads.
También existen funciones del estándar POSIX que
se encuentran implementadas en el paquete, pero son de uso interno,
es decir, el programador no dispone de ellas. El motivo de esto
no está claro, pero parece ser que la implementación
no es exactamente la indicada por el estándar.
pthread_create() |
pthread_create() |
pthread_exit() |
pthread_exit() |
pthread_join() |
pthread_join() |
pthread_yield() POSIX 1003.4 |
pthread_yield() |
pthread_self() |
pthread_self() |
pthread_kill() |
pthread_kill() |
pthread_sigmask() |
|
pthread_setschedparam() |
pthread_setschedparam() |
pthread_getschedparam() |
pthread_getschedparam() |
|
pthread_init() |
|
pthread_signal() |
pthread_key_create() |
pthread_key_create() |
pthread_key_delete() |
pthread_key_delete() |
pthread_setspecific() |
pthread_setspecific() |
pthread_getspecific() |
pthread_getspecific() |
pthread_once() |
pthread_once() |
pthread_equal() |
pthread_equal() |
pthread_cancel() |
|
pthread_testcancel() |
|
pthread_cleanup_push() |
pthread_cleanup_push() |
pthread_cleanup_pop() |
pthread_cleanup_pop() |
pthread_setcanceltype() |
|
pthread_setcancelstate() |
|
pthread_mutex_lock() |
pthread_mutex_lock() |
pthread_mutex_unlock() |
pthread_mutex_unlock() |
pthread_mutex_trylock() |
pthread_mutex_trylock() |
pthread_mutex_init() |
pthread_mutex_init() |
pthread_mutex_destroy() |
pthread_mutex_destroy() |
pthread_cond_wait() |
pthread_cond_wait() |
pthread_cond_timedwait() |
pthread_cond_timedwait() |
pthread_cond_signal() |
pthread_cond_signal() |
pthread_cond_broadcast() |
pthread_cond_broadcast() |
pthread_cond_init() |
pthread_cond_init() |
pthread_cond_destroy() |
pthread_cond_destroy() |
sem_init() POSIX 1003.4 |
|
sem_destroy() POSIX 1003.4 |
|
sem_wait() POSIX 1003.4 |
|
sem_post() POSIX 1003.4 |
|
sem_trywait() POSIX 1003.4 |
|
pthread_mutex_setprioceiling() |
|
pthread_mutex_getprioceiling() |
|
pthread_mutexattr_init() |
|
pthread_mutexattr_destroy() |
|
pthread_mutexattr_setpshared() |
|
pthread_mutexattr_getpshared() |
|
pthread_mutexattr_setprioceiling() |
|
pthread_mutexattr_getprioceiling() |
|
pthread_mutexattr_setprotocol() |
|
pthread_mutexattr_getprotocol() |
|
pthread_condattr_init() |
|
pthread_condattr_destroy() |
|
pthread_condattr_getshared() |
|
pthread_condattr_setshared() |
|
pthread_attr_init() |
pthread_attr_init() |
pthread_attr_destroy() |
pthread_attr_destroy() |
pthread_attr_getscope() |
pthread_attr_getscope() |
pthread_attr_setscope() |
pthread_attr_setscope() |
pthread_attr_getstacksize() |
pthread_attr_getstacksize() |
pthread_attr_setstacksize() |
pthread_attr_setstacksize() |
pthread_attr_getstackaddr() |
pthread_attr_getstackaddr() |
pthread_attr_setstackaddr() |
pthread_attr_setstackaddr() |
pthread_attr_getdetachstate() |
pthread_attr_getdetachstate() |
pthread_attr_setdetachstate() |
pthread_attr_setdetachstate() |
pthread_attr_getschedparam() |
pthread_attr_getschedparam() |
pthread_attr_setschedparam() |
pthread_attr_setschedparam() |
pthread_attr_getinheritsched() |
pthread_attr_getinheritsched() |
pthread_attr_setinheritsched() |
pthread_attr_setinheritsched() |
pthread_attr_getschedpolicy() |
pthread_attr_getschedpolicy() |
pthread_attr_setschedpolicy() |
pthread_attr_setschedpolicy() |
|
pthread_attr_getfloatstate() |
|
pthread_attr_setfloatstate() |
|
pthread_attr_setcleanup() |