Publi

  • ¡ Siempre olvido la alineación de las variables ! GRR

    7 abril, 2011 Author: Gaspar Fernández
    5 Comments

    1GB DDR3 Memory Module

    Algo que pocas veces tenemos en cuenta es la alineación de las variables en la memoria RAM. Muchas veces, ni nos va, ni nos viene, aunque en ciertas ocasiones suele causar calentamientos de cabeza.

    Tiene que ver con la forma que tiene la CPU para dialogar con la RAM y la arquitectura de éstas. Partimos del hecho de que pedir un dato a la memoria es algo lento, sí se hace muchos millones de veces por segundo, pero mientras viene o no viene el dato, la CPU simplemente espera. … Leer artículo completo

  • Compilando y linkando a mano con GCC

    11 septiembre, 2010 Author: Gaspar Fernández
    2 Comments

    GCC compila y linka automáticamente, nos devuelve un ejecutable directamente:

    $ gcc -o ejecutable fuente.c

    pero en realidad, aparte de pre-procesar y compilar, enlaza algunas bibliotecas del sistema para que nuestro ejecutable funcione bien. Sólo por jugar un poco, veamos, más o menos (depende del sistema) cómo obtener el ejecutable a mano, es decir, compilamos por un lado, y linkamos por otro.

    Primero, creamos un programa sencillo, un hello.c que contenga lo siguiente:

    1
    2
    3
    4
    5
    6
    7
    8
    #include <stdio.h>

    int main(int argc, char *argv[])
    {
       printf("Hola mundo!!
    … Leer artículo completo

  • REISUB, ¿qué es? ¿para qué sirve? ¿cómo hacerlo de forma remota o en script? y más llamadas a Alt+Sysrq

    29 agosto, 2010 Author: Gaspar Fernández
    10 Comments

    yJl7OB3sSpOdEIpHhZhd_DSC_1929_1_rEn muchos sitios, podemos ver esta palabra clave, para muchos RESUIB para otros RESIUB y normalmente REISUB. Y sirve para reiniciar el sistema Linux de forma segura después de que el sistema se congele; de la siguiente forma: Alt+Imprimir Pantalla + R,E,I,S,U,B (no hace falta soltar las teclas Alt + Imprimir pantalla). La tecla Imprimir pantalla podemos encontrarla como SysReq (System Request) o PetSis (Petición al sistema). Cada letra representa una acción del kernel:

    • R (Devuelve el control al teclado unRaw)
    • E (Termina todos los procesos tErm)
    • I (Mata los procesos que queden vivos full kIll)
    • S (Sincroniza los discos Sync)
    • U (Monta todos los sistemas de archivos como sólo lectura Umount)
    • B (Reinicia el ordenador Boot)

    Es muy recomendable dejar un poco de tiempo entre pulsación y pulsación, uno o dos segundos, ya que cada acción no es inmediata, puede que haya muchos procesos, muchos dispositivos, que haya información que volcar en ellos, etc; y todo no sea inmediato.… Leer artículo completo

  • GPGPU: Exprimiendo el potencial de tu GPU para propósito general (I)

    25 julio, 2010 Author: Gaspar Fernández
    2 Comments

    Hace unas semanas estuve en el Curso Avanzado de GPU impartido por el Dr. Manuel Ujaldón en la Universidad de Málaga; y me parece interesante compartir algunas conclusiones y un poco de investigación sobre el tema con todos ustedes.

    Una arquitectura diferente

    Disponemos de un chip con gran capacidad de procesamiento, pero a su estilo. Aunque originalmente está diseñado para su uso en juegos, recientemente (no tan recientemente porque el primer uso de GPU (Graphics Processing Unit, o Unidad de Procesamiento Gráfico) para propósito general fue en el 1997, lo que sí es más reciente es la implicación de empresas en este tipo de sistemas) muchas personas están concienciadas en aprovechar sus capacidades, y es muy interesante ya que con poco dinero podemos compararnos en capacidad de procesamiento a algunos superordenadores, y es que en ciertas tareas de cálculo muy pesado que en procesadores CPU actuales tardan varios días, con procesamiento GPU y con un coste mucho menor podemos completarlas en pocos minutos.… Leer artículo completo

  • Bailando con bits: Ver y modificar los bits de un número

    10 junio, 2010 Author: Gaspar Fernández
    5 Comments

    Hay muchas formas para hacer esto, pero quizás la más visual (tal vez también útil algunas veces) es la siguiente (se explica más abajo):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    #include <stdio.h>

    typedef struct {
        unsigned int b1:1;
        unsigned int b2:1;
        unsigned int b3:1;
        unsigned int b4:1;
        unsigned int b5:1;
        unsigned int b6:1;
        unsigned int b7:1;
        unsigned int b8:1;
        unsigned int b9:1;
        unsigned int b10:1;
        unsigned int b11:1;
        unsigned int b12:1;
        unsigned int b13:1;
        unsigned int b14:1;
        unsigned int b15:1;
        unsigned int b16:1;
        unsigned int b17:1;
        unsigned int b18:1;
        unsigned int b19:1;
        unsigned int b20:1;
        unsigned int b21:1;
        unsigned int b22:1;
        unsigned int b23:1;
        unsigned int b24:1;
        unsigned int b25:1;
        unsigned int b26:1;
        unsigned int b27:1;
        unsigned int b28:1;
        unsigned int b29:1;
        unsigned int b30:1;
        unsigned int b31:1;
        unsigned int b32:1;

    } Tint_bits;

    int main()
    {
      int numero;
      Tint_bits *bitpack;

      bitpack=(Tint_bits*)&numero;
      numero=63;
      printf ("Dir cos: %X\nDir paq: %X\n", &numero, bitpack);  // Vemos que las direcciones de memoria son idénticas.
    … Leer artículo completo

  • Cuando un proceso «se come» la memoria de nuestro sistema

    20 abril, 2010 Author: Gaspar Fernández
    16 Comments

    Hoy en día no se le suele ver la cara, dado que la memoria de nuestro sistema suele ser grande, pero cuando por ejemplo, a un proceso se le va la mano y reserva más memoria de la que tiene nuestro sistema, entra en marcha un proceso especial del núcleo de Linux; el OOM Killer (Out Of Memory Killer), que se encarga de detectar qué proceso es el peor del sistema y matarlo.… Leer artículo completo

  • Por qué no debemos utilizar gets()

    19 abril, 2010 Author: Gaspar Fernández
    14 Comments

    getsA veces me sorprendo (como profesor de programación) de que en muchos sitios siguen enseñando la función gets() para la entrada de datos desde teclado sin explicar lo que puede pasar.

    gets() es una función peligrosa. Imaginemos que escribimos el siguiente programa:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <stdio.h>

    int main()
    {
      char cadena2[10];
      char cadena1[10];

      printf("c1: %x\nc2: %x\n", cadena1, cadena2);
      gets(cadena1);

      printf("Cadena 2: %s\n", cadena2);
    }

    Ahora la compilamos, ejecutamos e introducimos un texto de prueba:

    $ gcc -o test3 test3.c
    /tmp/ccK2P2ON.o: In function `main’:
    test3.c:(.text+0x32): warning: the `gets’ function is dangerous and should not be used.

    … Leer artículo completo

  • Separar palabras de una cadena en C [ método dinámico con puntero triple ]

    4 enero, 2010 Author: Gaspar Fernández
    No comment yet

    photo-1444228250525-3d441b642d12
    Hace un mes o así publiqué un método para extraer las palabras de una cadena en un Array, ahora traigo un nuevo fragmento de código cuya misión es no estar tan limitado, y no tener que decir con antelación y con ello no tener que reservar memoria precipitadamente.

    Dejo dos códigos fuente, en el primero, la reserva de memoria para almacenaje de información es palabra por palabra, es decir, me llega una palabra reservo memoria, me llega otra, amplio en 1 elemento la memoria reservada y así hasta recibir todas (incluyo el código para probar la función):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    /**
    ******************************************************************
    * @brief Extrae palabras de una cadena y las coloca en un puntero
    *        doble E/S (triple, por tanto).
    … Leer artículo completo
Página anterior