GLib avanzado

Hilos en Glib.

Los hilos permiten que un programa realice varias tareas simultáneamente. Tradicionalmente, los sistemas operativos tipo UNIX/linux han usado los procesos para este propósito. No obstante, éstos son mucho más pesados (requieren más recursos) que los hilos.

Sin embargo, cada sistema operativo ha implementado de una forma diferente el concepto de hilo y, como resultado, las implementaciones no son compatibles, aunque sean muy parecidas. Ésto implica que si, se desea usar hilos en el programa será necesario proveer de una implementación diferente para cada sistemas operativo tipo UNIX.

GLib solventa este problema ocultando las implementaciones especificas de cada plataforma y proveyendo de un API que puede ser accedido de la misma forma desde cualquier sistema operativo. No obstante, internamente se usará las llamadas nativas disponibles en la plataforma donde se encuentre la aplicación. Es decir, GLib abstrae la implementación de los hilos.

Antes de entrar en materia, es necesario hacer una observación: todos los hilos que un programa crea, comparten el mismo espacio de direcciones; esto es, se podrá acceder a las variables globales de nuestro programa (para lectura y escritura) desde cualquier hilo. Inicialización y Creación de Hilos.

Antes de poder usar cualquier función de manejo de hilos, hay que preparar el sistema para ejecutar estas operaciones, es decir, es necesario inicializar el sistema de hilos, nada más sencillo.

Void g_thread_init (GThreadFunctions *vtable );

En la mayoría de las ocasiones bastará con que el parámetro pasado al sistema de hilos sea nulo, de esta forma GLib se encargará de buscar los parámetros más apropiados.

Es importante no llamar a esta función más de una vez pues, si esto sucediese, la ejecución de nuestro programa sería abortada. Para evitar esto la forma más sencilla es hacer:

   1           if (!g_thread_supported ())
   2           g_thread_init (NULL);

Después, el sistema estará listo para realizar cualquier operación que requiera el uso de hilos. Para empezar, se creará un hilo:

   1 GThread *hilo:
   2 
   3           hilo = g_thread_create (funcion_hilo, NULL, FALSE, NULL);

A partir de este punto, el procedimiento funcion_hilo se ejecutará en un hilo diferente, el programa continuará su ejecución normal y, en paralelo a él, se ejecutará esta función. Sincronización entre hilos.

Como ya se ha dicho, las variables globales del programa van a poder ser accedidas desde cualquier hilo. Esto es una gran ventaja, pues compartir información entre todas las hilos será muy sencillo; no obstante, todo tiene su parte negativa: habrá que tener cuidado a la hora de acceder a estos valores, porque puede que un hilo intente modificar alguna variable cuando otro hilo está leyendo esa misma variable, en cuyo caso, el resultado sería impredecible. Es necesario que los hilos se sincronicen para acceder a estas variables.

Existen varios métodos los sincronización disponibles:

Cerrojos: son llaves mutuamente exclusivas, que permiten conocer si se puede o no acceder a una determinada variable. Si una variable está protegida por un cerrojo, se podrá consultar el estado de la llave para conocer si está siendo accedida por otro hilo en ese instante. Si no lo estuviese, será posible obtener la llave, hacer las operaciones precisas sobre esa variable, y después abrir la llave de nuevo para que otro hilo pueda acceder a la variable.

          g_mutex_new
          g_mutex_lock
          g_mutex_trylock
          g_mutex_unlock
          g_mutex_free

Los cerrojos estáticos (Static Mutex) son iguales que las anteriores, pero no necesitan ser creadas en tiempo de ejecución; son creadas cuando el programa es compilado.

          g_static_mutex_init
          g_static_mutex_lock
          g_static_mutex_trylock
          g_static_mutex_unlock
          g_static_mutex_get_mutex
          g_static_mutex_free

Condiciones: son estructuras de datos que representan condiciones, Los hilos pueden ser bloqueados si encuentran una determinada condición como false. Si otro hilo cambia el estado de la condición, este envia una señal lo cual provoca que el hilo inicial despierte.

          g_cond_new
          g_cond_signal
          g_cond_broadcast
          g_cond_wait
          g_cond_timed_wait
          g_cond_free

UTF-8: las letras del mundo.

Antes de explicar el uso de las funciones que proporciona GLib para el uso de cadenas UTF-8, sería conveniente repasar una serie de conceptos que serán útiles para una mejor conmprensión.

Unicode: Una forma de representación (UCS).

ISO establece un estándar en el que define el conjunto de caracteres universal conocido como UCS. Este conjunto de caracteres asegura la compatibilidad con otros conjuntos de caracteres, de forma que se puedan usar distintas funciones para pasar de un determinado lenguaje a UCS y de este al lenguaje original sin perder contenido.

Gracias al Unicode se pueden representar la enorme mayoría de lenguajes conocidos, tales como latín, griego, cirílico, hebreo y así un largo etcétera. Unicode es un conjunto de caracteres de 16 bits, es decir, posee 65536 posibles combinaciones, representando cada una de estas combinaciones un carácter.

Un valor o carácter UCS o Unicode, indistintamente llamado de una forma u otro, englobará todos estos lenguajes, partiendo en otras codificaciones más pequeñas como BMP (Basic Multilingual Plane) o Plane 0, subconjunto de 16 bits, al igual que otros como UTF-16, de 16 bits, o UTF-8, de 8 bits, ambos utilizados posteriormente por la GLib tanto para comprobaciones de tipos de caracteres como para conversiones entre distintos subconjuntos Unicode, tales como UTF-8 y UTF-16. Qué es Unicode.

Al principio, se intentaron dar dos intentos de conseguir un conjunto de caracteres: el proyecto de estandarización ISO 10646 antes comentado y el proyecto Unicode, pero pronto se comprobó que no era bueno tener dos proyectos en marcha y los dos conjuntos de caracteres diferentes se unieron formando una única tabla de caracteres que fue la de Unicode con las extensiones dadas por la ISO 10646 pasando a ser llamado indistintamente Unicode o ISO 10646. Con el paso del tiempo ha habido modificaciones de Unicode adiciones de caracteres y clasificaciones en subconjuntos como pueden ser el ampliamente usado ASCII, UTF-8, UTF-16 y BMP entre otros.

Qué es UTF-8.

En GLib existe soporte para UTF-8 debido a sus compatibilidades con el resto de códigos, ya que su codificación engloba en sus primeros 7 bits el tan conocido ASCII.

La codificación UTF-8 está definida en el ISO 10646.

Conversiones del juego de caracteres.

En determinadas ocasiones, los programas necesitan el uso de más de un juego de caracteres para un correcto tratamiento de los datos que maneja. Para que esto sea posible sin conflictos ni confusiones, GLib proporciona un útil conjunto de funciones para la conversión entre juegos de caracteres.

Nombres de archivos y UTF-8.

Con todo lo explicado anteriormente, es evidente que el juego de caracteres usado para representar nombres de archivos y el juego de caracteres UTF-8 que podamos usar en nuestros programas puede diferir bastante. Para solventar esto existen las funciones g_filename_to_utf8 y g_filename_from_utf8, que realizan la conversión de nombre de archivo a UTF-8 y de UTF-8 a nombre de archivo, respectivamente.

gchar * g_filename_to_utf8 (const gchar * cadena_a_convertir,
                            gssize longitud_de_cadena,
                            gsize * bytes_leidos,
                            gsize * bytes_escritos,
                            GError ** error);

gchar * g_filename_from_utf8 (const gchar * cadena_a_convertir,
                              gssize longitud_de_cadena,
                              gsize * bytes_leidos,
                              gsize * bytes_escritos,
                              GError ** error);

Como se puede observar, el uso de las dos funciones es idéntica porque devuelven la cadena convertida al nuevo juego de caracteres o NULL en caso de que ocurra un error. Los parámetros bytes_leidos, bytes_escritos y error son parámetros de salida, devolviendo respectivamente los bytes convertidos con éxito, los bytes que ocupa la cadena tras la transformación y el posible error que se pueda producir.

Configuración local de caracteres y UTF-8.

De forma parecida al tratamiento de nombres de archivo, las funciones g_locale_to_utf8 y g_locale_from_utf8 convierten cadenas en el juego de caracteres usado internamente por el sistema a cadenas en UTF-8 y viceversa.

gchar * g_locale_to_utf8 (const gchar * cadena_a_convertir,
                          gssize longitud_de_cadena,
                          gsize * bytes_leidos,
                          gsize * bytes_escritos,
                          GError ** error);

gchar * g_locale_from_utf8 (const gchar * cadena_a_convertir,
                            gssize longitud_de_cadena,
                            gsize * bytes_leidos,
                            gsize * bytes_escritos,
                            GError ** error);

El uso de las funciones es idéntico al descrito con g_filename_to_utf8 y g_filename_from_utf8.

Otras funciones relacionadas con conversión de cadenas.

Además de las funciones de conversión de cadenas, GLib provee además de un conjunto de funciones destinadas a servir de ayuda y apoyo al tratamiento de cadenas en UTF-8.

La función g_get_charset es útil para conocer el juego de caracteres que esta usando el sistema sobre el que se ejecuta el programa, pudiendo evitar transformaciones redundantes.

gboolean g_get_charset (G_CONST_RETURN gchar ** juego_de_caracteres );

La función devuelve TRUE si el juego de caracteres que usa el sistema es el UTF-8 y FALSE en cualquier otro caso. juego_de_caracteres es un parámetro de salida que devulve el juego de caracteres usado por el sistema en formato cadena.

La función g_utf8_validate sirve determinar si una cadena de caracteres está ya en formato UTF-8 o no.

gboolean g_utf8_validate (gchar * cadena_a_validar, gssize longitud,
                          const gchar ** final);

El parámetro cadena_a_validar es la cadena que se quiere validar. longitud es el número máximo de caracteres que queremos que valide, puede ser NULL si queremos validar la cadena entera; por último, en el último parámetro, la función devuelve un puntero al último carácter que ha podido validar. La función devuelve TRUE o FALSE dependiendo de si la cadena pasada cumple el formato UTF-8 o no.

Como hacer plugins.

Una de las cosas que pueden interesar a la hora de hacer una aplicación es crear un método por el cual se pueda aplicar extensiones. Ésto se conoce por el nombre de plugin. Para los desarrolladores habituales, el término "plugin" no debería resultar desconocido, ya que existen aplicaciones en GNOME, como por ejemplo gedit, gnumeric o algunos reproductores multimedia que aprovechan este método para extender la funcionalidad de la aplicación.

Para entender cómo funcionan los plugins, hay que tener claro el concepto de "símbolo". En una biblioteca, a cada función o variable se le da un nombre único (símbolo). Los símbolos que interesan ahora, son los que se exportan, que serán los que se utilicen para enlazarla. Por ejemplo, cuando en un código se llama a una función, lo que se hace es especificar el símbolo de la biblioteca y, en consecuencia, a la función que se desea. Ésto se hace automáticamente a la hora de programar. Pero también se puede hacer manualmente. O sea, se puede especificar una biblioteca en concreto (el plugin) y llamar a una función en concreto. De este modo se podría crear muchas bibliotecas (plugins), que además implementen una función común en todas ellas y se podría cargar manualmente esa función de cualquiera de los plugins. Para luego ejecutarla dentro de el programa. Ésto se verá mucho más claro más adelante, con el ejemplo de esta sección.

Para realizar este tipo de acciones se dispone de GModule. Éste es un sistema que permitirá la carga dinámica de símbolos. Además, siguiendo con una de las máximas de GLib, este sistema es portable. Lo que nos permitirá cargar símbolos en sistemas como Linux, SolarisTM, WindowsTM, HP-UXTM.

Para la utilización de GModule es necesario tener presente dos cosas. La primera es que, en el momento de la compilación, se debe indicar que se va a usar GModule, y para ello se indicará en el pkg-config que incluya la biblioteca gmodule-2.0. Y por supuesto incluir la linea:

#include <gmodule.h>

La otra tiene que ver con detectar si el sistema operativo en el que se trabaja, soporta este tipo de acciones. Y para ello se usará la función g_module_supported que detectará si se puede hacer uso de las siguientes funciones y devolverá TRUE si es así.

gboolean g_module_support ( void );

Abrir una biblioteca.

Si el sistema en el que se trabaja soporta el uso de GModule, el siguiente paso será abrir la biblioteca de la cual posteriormente se extraerá el símbolo deseado. Para ello se debe indicar de alguna manera la posición en nuestro sistema de la biblioteca (plugin) que se desea abrir. Y con este fin, se usara la función g_module_build_path, con la que podremos construir la ruta exacta donde se encuentra la misma. Esta función devolverá una cadena con la ruta anteriormente nombrada.

gchar * g_module_build_path (const gchar * directorio,
                             const gchar * nombre_del_modulo );

En el primer parámetro de esta función se debe especificar el directorio donde se encuentra la biblioteca que se desea abrir. Y en el segundo, el nombre de la misma. Pero hay que tener claro que sólo el nombre, ya que la función se encargará de poner la extensión de la biblioteca según el sistema operativo en el que este corriendo GLib. Por ejemplo, en Linux colocará la extensión ".so" y en WindowsTM ".dll".

Una vez que se obtiene la ruta devuelta por g_module_build_path, lo siguiente será cargar la biblioteca. Y para ello está la siguiente función.

GModule * g_module_open (const gchar * ruta_de_la_libreria,
                         GModuleFlags bandera );

El parámetro bandera puede contener dos valores, un cero o la macro G_MODULE_BIND_LAZY. El primer valor, el cero, significa que, cuando se ejecuta esta función, se cargan todos los símbolos de la biblioteca. Mientras que con el segundo valor, sólo lo hará cuando sea necesario.

Otra cosa a tener en cuenta es el resultado de esta función. Como se puede observar, devuelve un puntero a una estructura GModule. Esta estructura es opaca a la visión del desarrollador, pero servirá en posteriores funciones como referencia a la biblioteca que hemos abierto. En el caso de que GModule sea igual a NULL, ésto significará que la función no lo ha conseguido.

Obtener un símbolo determinado.

Ahora ha llegado el momento de obtener el símbolo que se desee de la biblioteca. Como se dijo antes, estos símbolos pueden ser funciones, estructuras o variables que hayan sido exportadas en la biblioteca (plugin), así que, de momento, se dará por hecho que existe el símbolo al que se va a llamar con la siguiente función.

gboolean g_module_symbol (GModule * modulo, const gchar * símbolo,
                          gpointer * puntero_al_simbolo );

Esta función recibirá como parámetros el puntero a la estructura GModule, que hace referencia a la biblioteca que anteriormente se ha abierto. Después se introduce el nombre del símbolo que se desea obtener y, para terminar, la función devolverá en su tercer parámetro un puntero al símbolo que se haya solicitado. En el caso que se haya solicitado una función, devolverá un puntero a esa función. Y si lo que se ha solicitado es una variable devolverá un puntero a la misma. Para terminar sólo queda decir que el valor boolean que devuelve, verifica si la función se ha cumplido con éxito o no.

Preparar el plugin.

Con las funciones anteriores se ha clarificado el trabajo que se ha de realizar para llamar al símbolo de la biblioteca (plugin). Ahora queda tratar la parte contraria, la del plugin. Se ha de tener en cuenta que para que la función g_module_symbol encuentre el símbolo que se reclame, este ha de estar declarado de alguna manera. Y para este acto se usa la macro G_MODULE_EXPORT. Esta macro, escrita delante de una variable o función, realiza la función que se desea, la de exportar el símbolo. De este modo, ya será posible referenciar el símbolo deseado desde la función g_module_symbol.

Dentro de la preparación de plugin con GModule existe una manera de inicializar el plugin. Para ello se deberá declarar una función llamada g_module_check_init. Dentro de esa función, es posible declarar acciones para la inicialización del plugin. Pero esta función deberá seguir estrictamente este prototipo.

const gchar* (*GModuleCheckInit) (GModule * modulo );

En el momento en el que se abra la biblioteca (plugin) con la función g_module_open, ésta buscará esta función y la ejecutará. En el caso que esta función no esté declarada, simplemente habrá abierto la biblioteca. En el caso de que exista la función, podrá retornar NULL si ha sido exitosa la inicialización o un cadena de caracteres con la información del error contenida en ella.

Y al igual que se puede especificar una manera de inicializar el plugin, también se puede especificar la manera en la que finalizará. Para ello se deberá especificar una función llamada g_module_unload. Y, al igual que la anterior, deberá seguir el siguiente prototipo.

void (*GModuleUnload) (GModule * modulo );

Ejemplo de uso de GModule.

Llegados a este punto, es hora demostrar prácticamente todo lo anteriormente explicado. Para ello se usará el siguiente ejemplo, que consta de cuatro archivos. Uno de ellos es un Makefile, que nos ayudará a compilar dicho ejemplo y hará más familiar el uso de la herramienta make.

El siguiente ejemplo explicará cómo funciona un plugin. Para ello se cuenta, por un lado, con una aplicación, correspondiente a los ficheros modulo.c y modulo.h. Esta aplicación llamará al plugin generado por el fichero plugin.c, que cuando lo compilemos se llamará libplugin.so. La aplicación exportará una estructura llamada info_plugin y una función llamada escribe. Dentro de la aplicación, se llamará a los símbolos anteriormente citados y se modificará el contenido de la estructura. Una vez ese contenido ha sido modificado, se llamará al puntero a función correspondiente al símbolo de la función escribe. Cuando esta función se ejecuta dentro de la aplicación, lo que realmente se esta ejecutando es la función escribe, que imprime por pantalla el contenido de la estructura.

Ejemplo 6-11.1. Ejemplo de Makefile para usar GModule

# Este es un ejemplo del archivo Makefile.
#
# Para proyectos de mayor complejidad es 
# recomendable la utilizacion de autotools.

CC = gcc
CFLAGS = -ggdb -O0
ERROR_CFLAGS = -Wall -Werror
GLIB_CFLAGS = `pkg-config --cflags --libs glib-2.0 gmodule-2.0`

all:
        $(CC) $(CFLAGS) $(ERROR_CFLAGS) $(GLIB_CFLAGS) -o modulo modulo.c
        $(CC) -shared $(CFLAGS) $(ERROR_CFLAGS) $(GLIB_CFLAGS) -o libplugin.so plugin.c

clean:
        rm -rf libplugin.so modulo

Ejemplo 6-11.2. Cabecera del Módulo

   1 /* ejemplo de cabecera llamada modulo.h */
   2 #ifndef __MODULO_H__
   3 #define __MODULO_H__
   4 
   5 #include <glib.h>
   6 #include <gmodule.h>
   7 
   8 typedef struct _datos_plugin datos_plugin;
   9 
  10 struct _datos_plugin {
  11            gchar *nombre;
  12            gchar *correo;
  13 };
  14 
  15 
  16 #endif /* __MODULO_H__ */
  17 

Ejemplo 6-11.3. Código del Módulo

   1 /* ejemplo de programa modulo.c */
   2 #include <stdlib.h>
   3 #include "modulo.h"
   4 
   5 /*
   6 *       Se define un tipo, puntero a función nula, para
   7 *       después declarar una variable (escribe), a la que
   8 *       se asignará un símbolo(en este caso una función) del plugin.
   9 *
  10 */
  11 typedef void (*funcion_escritura) (void);
  12 
  13 int
  14 main (int argc, char **argv)
  15 {
  16         gchar *dir;
  17         GModule *modulo;
  18         gchar *plugin;
  19         datos_plugin **info;
  20         funcion_escritura escribe; /*  Variable que apuntará al símbolo */
  21 
  22         /*  Se comprueba que el sistema soporta los plugins */
  23         if (!g_module_supported ())
  24                 return 0;
  25 
  26         dir = g_get_current_dir ();
  27 
  28         /*  Se obtiene el path del plugin que se usará */
  29         plugin = g_module_build_path (dir, "libplugin");
  30 
  31         g_free (dir);
  32 
  33         /*  Se carga el plugin  */
  34         modulo = g_module_open (plugin, G_MODULE_BIND_LAZY);
  35         if (!modulo)
  36                 g_error ("error: %s", g_module_error ());
  37 
  38         /* Se obtiene el símbolo info_plugin, una estructura de datos */
  39         if (!g_module_symbol (modulo, "info_plugin", (gpointer *) & info))
  40                 g_error ("error: %s", g_module_error ());
  41 
  42         (*info)->nombre = "Pepe Lopez";         /*   Aquí se usa el símbolo  */
  43         (*info)->correo = "pepe@gnome.org";     /*   info_plugin             */
  44 
  45         /* Se obtiene el símbolo plugin_escribe, una función */
  46         if (!g_module_symbol
  47             (modulo, "plugin_escribe", (gpointer *) & escribe))
  48                 g_error ("error: %s", g_module_error ());
  49 
  50         escribe ();             /*      Aquí se usa el símbolo plugin_escribe */
  51 
  52         /*      Se descarga el plugin   */
  53         if (!g_module_close (modulo))
  54                 g_error ("error: %s", g_module_error ());
  55 
  56         return EXIT_SUCCESS;
  57 }

Ejemplo 6-11.4. Ejemplo de plugin

   1 /* ejemplo de plugin.c */
   2 #include "modulo.h"
   3 
   4 /*
   5 *       Se declara un puntero a una estructura de datos
   6 *       y se exporta como símbolo, para poder ser
   7 *       utilizado por las aplicaciones que carguen
   8 *       este plugin
   9 *
  10 */
  11 G_MODULE_EXPORT datos_plugin *info_plugin;
  12 
  13 
  14 /*
  15 *       Esta función inicializa el plugin. Se exporta como simbolo.
  16 *
  17 *       Se ejecuta al ser cargado el plugin -> g_module_open()
  18 *
  19 */
  20 G_MODULE_EXPORT const gchar *
  21 g_module_check_init (GModule * module)
  22 {
  23         g_print ("--- Inicializacion del plugin ---\n\n");
  24         info_plugin = g_malloc (sizeof (datos_plugin));
  25         return NULL;
  26 }
  27 
  28 
  29 /*
  30 *       Esta función finaliza el plugin. Se exporta como simbolo.
  31 *
  32 *       Se ejecuta al ser descargado el plugin -> g_module_close()
  33 *
  34 */
  35 G_MODULE_EXPORT void
  36 g_module_unload (GModule * module)
  37 {
  38         g_print ("\n--- Finalizacion del plugin ---\n");
  39         g_free (info_plugin);
  40 }
  41 
  42 
  43 /*
  44 *       Esta función será un símbolo del plugin
  45 *       que se podrá llamar a voluntad en cualquier
  46 *       momento, una vez se haya cargado el plugin.
  47 *
  48 */
  49 G_MODULE_EXPORT void
  50 plugin_escribe (void)
  51 {
  52         g_return_if_fail (info_plugin != NULL && info_plugin->nombre != NULL &&
  53                 info_plugin->correo != NULL);
  54 
  55         g_print ("Nombre : %s \ncorreo-e : %s\n",
  56                  info_plugin->nombre, info_plugin->correo);
  57 }

Y el resultado de ejecutar el programa obtenido de compilar, tanto el plugin, como el modulo con make, sería el siguiente:

          bash$:/var/svn/librognome/book/code/GModule$
          
          ./modulo
          --- Inicializacion del plugin ---

              Nombre : Pepe Lopez
              correo-e : pepe@gnome.org

          --- Finalizacion del plugin ---


Volver a: GLib

Documentacion/Desarrollo/Glib/GlibAvanzado (última edición 2008-12-04 08:49:09 efectuada por localhost)