No sé que hacer ya con este código...

[lomasdelicioso]

Hola foreros del web, estoy programando en 'c' y tengo un problema porque lo que quiero que me haga este código no me lo hace, he usado el ddd y no veo el problema, es un poco engorroso ver que hace mi código pero se lo agradecería mucho al que fuera capaz.

Se trata de un programa concurrente en el que uso un cerrojo donde una hebra saca recursos de una estructura enlazada y el main mete recursos en la misma estructura, para que no lo hagan a la vez uso el cerrojo.

Código C:

/*
 * miPrograma.c
 * Esta version usa una única hebra servidora, que extrae el primer elemento de la
 * lista de peticiones. main inserta nuevas peticiones en la lista, en el orden de menor
 * tiempo de aviso La lista está protegida por mutex, y la hebra servidora se suspende al  
 * menos  1 segundo, en cada iteración, para asegurar que la hebra main tenga oportunidad
 * de bloquear el mutex e insertar una nueva petición a la lista.
 */
 
#include <pthread.h>
#include <time.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
typedef struct paquete_control {
  struct paquete_control       *enlace;
  int                          segundos;
  time_t                       tiempo;                              // segundos desde EPOCH
  char                         mensaje[64];
} paquete_control_t;
 
pthread_mutex_t lista_mutex = PTHREAD_MUTEX_INITIALIZER;        // Creación del cerrojo
paquete_control_t *lista_pet = NULL;
 
FILE  *fp;  // para guardar la impresion de los avisos, asi la salida del
                  // programa no interfiere con la entrada de peticiones.
 
/*
 * funcion que ejecuta la hebra servidora de avisos.
 */
void *servidora (void *lista_pet)
{
    paquete_control_t *pcontrol;        // Esto es un puntero a un paquete de control
   
    
int sleep_time;
int estado;
    time_t ahora;    
 
  /*
   * La hebra cicla siempre, procesando peticiones del usuario. 
   * La hebra sera "desintegrada" cuando el proceso termine.
   */
    while (1) {
    
        estado= pthread_mutex_lock(&lista_mutex);       // bloquear el cerrojo lista_mutex
     
                if (estado !=0) fprintf(stderr, "Error al bloquear lista_mutex\n"),exit(0);
 
     // asignar el puntero a la direccion de comienzo de "lista_pet"
        pcontrol = (paquete_control_t*)lista_pet; 
 
     
    /* Si "lista_pet" esta vacia, asigno a "sleep_time" 1 segundo. La
     * suspension durante 1 s. le permitirá a "main" ejecutarse, e intentar 
     * obtener otra peticion del usuario; si no (la lista de peticiones 
     * no esta vacia), extraer su primer elemento */
        if (pcontrol == NULL){
            sleep_time = 1;
        }
 
        else{
            lista_pet = pcontrol->enlace;
            ahora = time(NULL);
            if (pcontrol->tiempo <= ahora) sleep_time = 0;
        
            else sleep_time = pcontrol->tiempo - ahora;
        }
 
 
    /* Ahora, desbloquear "lista_mutex", antes de que la hebra "servidora" 
     * se suspenda, para que "main" pueda bloquearlo para insertar una nueva 
     * peticion del usuario, 
     */
        estado= pthread_mutex_unlock(&lista_mutex);
        if (estado !=0) fprintf(stderr, "Error al desbloquear lista_mutex\n"),exit(0);
 
     
 
    /* Si "sleep_time" > 0, entonces suspender la hebra durante
     * ese tiempo; si no, llamar a sched_yield(), y de
     * esta forma darle una oportunidad a "main" de ejecutarse,
     * si tiene una entrada pendiente del usuario, sin retrasar la
     * impresion del aviso si no existiera tal entrada.
     */
        if (sleep_time >0) sleep (sleep_time);
    
        else sched_yield();
     
        if (pcontrol != NULL){
            fprintf(fp, "(%d) %s {%ld} \n", pcontrol->segundos, pcontrol->mensaje, 
pcontrol->tiempo); 
            free(pcontrol);
        }
     
    }
}
 
 
 
int main (int argc, char *argv[])
{
    int estado;  
    char linea[128];
 
     // declaro punteros para recorrer "lista_pet"
    paquete_control_t  *pcontrol,*aux,*aux2; 
 
 
    pthread_t hebraServidora;
 
 
    if ((fp = fopen("Salidas", "w")) == NULL)
        fprintf(stderr, "Error en la apertura del fichero de salida\n"),exit(0);
     
    if (pthread_create(&hebraServidora,NULL,servidora,(void *)lista_pet))
        fprintf(stderr, "Error al crear la hebra servidora\n"),exit(0);
        
    while (1) {
        printf ("Peticion de aviso> ");
        if (fgets (linea, sizeof (linea), stdin) == NULL) exit (0);
        if (strlen (linea) <= 1) continue;
 
    pcontrol= (paquete_control_t*) malloc(sizeof(paquete_control_t));
 
        if ( sscanf(linea, "%d %64[^\n]", &pcontrol->segundos, pcontrol->mensaje) < 2 ){
            if (pcontrol->segundos==-1) break;  
            
            else{
                fprintf(stderr, "Entrada erronea\n");
                free(pcontrol);
            }
        }
        else {
                fprintf(fp, "(%d) %s\n", pcontrol->segundos,pcontrol->mensaje);
            estado= pthread_mutex_lock(&lista_mutex);
 
            if (estado !=0) fprintf(stderr, "Error al bloquear lista_mutex\n"),exit(0);
 
            pcontrol->tiempo=time(NULL);
     
         /*
         * Insertar delante del primer  elemento de  "lista_pet" que tenga 
         * un tiempo de aviso >= que el de la nueva peticion que vamos a insertar.
         */
 
            if (lista_pet != NULL){
                for (aux=lista_pet ; aux->enlace != NULL ; aux=aux->enlace){
                    if (pcontrol->tiempo < aux->tiempo){
                        pcontrol->enlace=aux;
                        aux2->enlace=pcontrol;
                    }
                    aux2=aux;
                        }
                if (aux->enlace == NULL){
                    aux->enlace = pcontrol;
                    pcontrol->enlace = NULL;
                }
            }
            else
                lista_pet=pcontrol;
 
            estado= pthread_mutex_unlock(&lista_mutex); 
            if (estado !=0) fprintf(stderr, "Error al desbloquear lista_mutex\n"),exit(0);
        }
 
    }
 
    if (fclose(fp)) fprintf(stderr, "Error al cerrar el fichero\n");
}
 

Gracias a todos los forer@s del web.

[lomasdelicioso]

Hago reflotar esta hebra para ver si algún alma generosa me puede ayudar, 4 días después no sé porque no me funciona esta ****** de código...

[lomasdelicioso]

¿Qué ocurre que veis el código demasiado largo?
¿No entienden C?
¿No saben programar con threads?
Necesito ayuda gente, por favor.

[CalgaryCorpus]

Sugiero agregar ejecuciones de tu programa, las salidas esperadas y como te das cuenta que no está funcionando. Como se trata de concurrencia, varias ejecuciones, varias salidas.

Dejar un programa que "no funciona" y hacer adivinar que es lo que ves que está mal o como te das cuenta de ello te hará obtener lo que has obtenido: Ninguna respuesta y 1 sugerencia. Dicho de otra forma, ayudanos a ayudarte.

[lomasdelicioso]

Pues yo lo que intentaba era hacer como una agenda, ejecuto mi programa y debería salir esto:

Código:

Insertar aviso> (cursor aqui)

Entonces yo escribo un numero que indica el tiempo y un mensaje a dejar, entonces pasado esos segundos me escribirá en un fichero el mensaje que puse. Se pueden insertar tantos avisos como se quiera y el programa finalizará cuando el programa dé un error o se pulse el 'ctrl-c'

Y lo único que me hace es crear el fichero pero no sale nada en el fichero. Gracias por responder Calgary.

[CalgaryCorpus]

Parece estar bien, compile tu programa, lo ejecute y esto me dio a mi: (termine la ejecucion con -1, no con Control-C)


ubuntu:/tmp/dev$ ./t
Peticion de aviso> 3 hola
Peticion de aviso> 1 mensaje
Peticion de aviso> 0 0
Peticion de aviso> -1
ubuntu:/tmp/dev$ cat Salidas
(3) hola
(1) mensaje
(0) 0

[lomasdelicioso]

Entiendo, el ctrl-c no deja imprimir en el fichero, pero aún así, ¿te salio hola tres segundos despues de que presionaras enter? ¿te salio mensaje un segundo despues? si pusiste 0 0 antes de un segundo después de presionar enter con 1 mensaje en el fichero se te tenía que colocar antes...
Gracias por tu ayuda.

[CalgaryCorpus]

No escribe inmediatamente en el archivo, ni escribe los segundos indicados despues, sino que lo hace al final.
Esto es debido a que al thread le estas pasando la una direccion de memoria que no se modifica mas

[CalgaryCorpus]

Sugiero que crees una estructura que sea la cabeza de la lista, que contenga la direccion de memoria del primer nodo.
Es la direccion de esta cabeza de lista la que pasas a la funcion servidora y es a esa la que lees y actualizas.
Haciendo esto, tu programa escribira correctamente al archivo, respetando el sleep que estableciste. No escribas en el main hacia el archivo.

e.g.


struct lista {
paquete_control_t * first;
} lista_pet;


en main

lista_pet.first = NULL;

inicias el thread pasando la direccion de memoria de lista_pet
y luego desreferencias a este puntero, llegando o actualizado el puntero a "first".