Publi

  • Cómo obtener información de salud de tu sistema Linux o tu servidor en C y C++ (I. Memoria)

    Es algo necesario para el buen funcionamiento de nuestras aplicaciones. Para añadir robustez a nuestros sistemas, haciendo que éstos se comporten de manera adecuada en situaciones imprevistas. Por ejemplo, si necesitamos crear un archivo y añadir cierta información, podemos, a priori, comprobar que el dispositivo en el que vamos a escribir tiene suficiente espacio libre, lo que nos puede ahorrar suplicios si los ficheros son demasiado grandes. También deberíamos ser capaces de comprobar que un disco de red está conectado antes de trabajar con él y, en muchos casos, anticiparnos a largas esperas y bloqueos por parte del sistema operativo.… Leer artículo completo

  • Monitorizar nuestro sistema desde una aplicación en C++11

    14255861975_42cb043745_k

    Nuestros programas, muchas veces necesitan conocer información sobre el ordenador donde se están ejecutando. Una característica muy interasante y útil (para mi gusto) es que los sistemas Unix nos proporcionan una interfaz para conocer muchas cosas a través del sistema de archivos, de esta forma podemos conocer la información estemos donde estemos y usemos en lenguaje que usemos (no tenemos que tener una API en nuestro lenguaje que pida al sistema la información ni nada).… Leer artículo completo

  • Intercambiar valores

    Cuando queremos hacer que una variable a sea igual a una variable b y viceversa (intercambiar los valores), lo primero que se viene a la mente, es utilizar una variable auxiliar, como en este ejemplo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include <stdio.h>
    void intercambia(int *x, int *y);
    int main()
    {
        int a=50;
        int b=90;
        printf("a=%d t b=%dn", a, b);
        intercambia(&a, &b);
        printf("a=%d t b=%dn", a, b);
    }
    void intercambia(int *x, int *y)
    {
        int tmp;
        tmp=*x;
        *x=*y;
        *y=tmp;
    }

    Aunque puede que queramos (o que nos pidan) hacerlo sin variable temporal, podemos hacer un intercambiador con sumas y restas:

    1
    2
    3
    4
    5
    6
    void intercambia2(int *x, int *y)
    {
        *x=*x+*y;           /* x=x+y */
        *y=*x-*y;           /* y=x-y */
        *x=*x-*y;           /* x=x-y */
    }

    Y con las propiedades de la operación XOR también podemos jugar:

    1
    2
    3
    4
    5
    6
    void intercambia3(int *x, int *y)
    {
        *x ^= *y;           /* x = x xor y */
        *y ^= *x;           /* y = y xor x */
        *x ^= *y;           /* x = x xor y */
    }

    Pero lo bueno de estos dos últimos métodos es que los podemos utilizar desde macros de preprocesador, y con eso nuestro código se ejecutará mucho más rápido:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    #define interc(x,y) x=x+y; y=x-y; x=x-y;
    int main()
    {
        int a=-50;
        int b=40;
        printf("a=%d t b=%dn", a, b); /* a=-50 b=40 */
        interc(a, b);
        printf("a=%d t b=%dn", a, b); /* a=40 b=-50 */
    }

    Para ver lo rápido que se ejecuta, he hecho el programa intercambiando continuamente en un bucle for de unos 300000000 (trescientos millones) de iteraciones lo siguiente:

    Para la macro de preprocesador interc(a,b),

    gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./interc
    a=-50 b=40
    a=-50 b=40

    real 0m8.027s
    user 0m7.461s
    sys 0m0.022s

    Para intercambia(a,b) (con variable auxiliar):

    gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intvaux
    a=-50 b=40
    a=-50 b=40

    real 0m8.691s
    user 0m7.058s
    sys 0m0.022s

    Para intercambia2(a,b), con sumas y restas:

    gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intsyr
    a=-50 b=40
    a=-50 b=40

    real 0m12.331s
    user 0m10.508s
    sys 0m0.024s

    Para intercambia3(a,b) con xor:

    gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intxor
    a=-50 b=40
    a=-50 b=40

    real 0m11.882s
    user 0m10.516s
    sys 0m0.031s

    Por lo tanto vemos, que el método de la variable auxiliar es bastante rápido, mucho más que haciendo sumas y restas y xor (por lo tanto estos métodos no sirven de mucho, sobre todo ahora, que la memoria es barata), aunque, con las sumas y restas nos acercamos en tiempo al método de la variable auxiliar cuando lo hacemos desde una macro.… Leer artículo completo