Mensajes

¿Entonces?, algo para recomendarme (todavía no se reinicio)

Antes de cambiar directamente la placa madre, podría intentar algo más, pero el tema SÍ parece estar muy relacionado con la placa madre, porque cuando conecto el Ethernet a la placa madre tarda en bootear se congela todo más rapido, es muy raro lo que pasa ...

En un principio yo no iba a comentar nada en este tema, basicamente por qué no sé como podría ayudarte a que solucionases el problema, pero déjame decirte una cosa...

Uno de mis hermanos, el cual ha sido técnico profesional durante más de 20 años, cuando se fundó la marca ASRock él hizo amistad con ciertos "jefecillos" de la compañia, y hablaban entre ellos de ciertas cosas sobre sus placas base, pues bien, te cuento esto para que comprendas que lo que voy a recomendarte no es una simple opinión personal, está basada en la experiencia profesional, aunque yo no puedo hablar mucho más de la cuenta por que no quiero dar motivo a que nadie me pueda demandar por calumnias o algo parecido (que nunca se sabe quien nos puede estar leyendo por estos lares), pero creeme si te digo que lo mejor que puedes hacer para tu PC es quitarte esa placa base, no importa si eso es lo que realmente te puede estar causando un problema o no... simplemente no uses placas base de ASRock, hazme caso, por el bienestar de tu PC.

Yo en tu lugar lo primero que haría sin duda alguna es cambiar de (marca de) placa base (y directamente tirarla a la basura o mejor todavía tirarla en un volcán, que no queden ni los restos de sus cenizas), y luego comprobar si el problema se ha solucioando o no, y si no se ha solucioando pues... a seguir buscando otra solución diferente.

Saludos!

No sabía que tenían tan mala reputación las ASRock pero lo del Ethernet si que fue un problema de *****, y ni siquiera entiendo porque usando un USB Ethernet funcionó.
Bueno, de todos modos voy a seguir buscando la solución al problema.

1º La placa, que no me gusta, ¿una N68? Pos no me gusta, definitivamente, prefiero un dolor de testículos antes que tenerla.

2º La gráfica, una PCI Express 3.0 en una placa PCI Expres 2.0 (y sin mirar características que es para un AMD FX y esos PCI Expres 3.0 no usan).

3º La fuente, "pos pocos W son esos" verifica amperajes de canales, atrévete, con esa gráfica lo mínimo para que el PC encienda son 650 W y me quedo corto, se ponen de más.


He dicho.

1º. Te doy 100% la razón en lo que respeta a la placa madre, me dió unos terribles problemas con el Ethernet, si conecto el Ethernet a la placa mi computadora se congela MUCHO más rápido,
o sea es prácticamente como que no puedo usarla, entonces mi solución fue comprar un USB Ethernet y de ahí el problema dejó de pasar.
Pasó como más de un año y ahora volvió el problema, pero no es el mismo para mí.

2º. La gráfica, una PCI Express 3.0 en una placa PCI Expres 2.0 -> FUCK

3º Es algo raro que pasa, te juro, conecto el Ethernet a la placa y se traba todo hasta a veces cuesta que boote al sistema operativo (cuando lo reinicio), pero si lo pongo con USB Ethernet si funciona WTFFF!? Así que no creo que sea un problema de la fuente.

[no es es un problema de software]

¡Buenas! Vaaamooos al tema:

Para empezar, no es es un problema de software porque probé con varios sistemas operativos (Windows como varias distros de GNU/Linux) y en todos pasa exactamente lo mismo, la PC se congela/traba automáticamente sin que yo pueda dar instrucciones/comandos, no puedo hacer nada sólo reiniciar y ahí sí vuelve a funcionar.

Mi computadora después de un tiempo aleatorio (no más de 2 días), simplemente se queda congelada y el teclado ya no prende más, la luz del "Blog Num" no se activa, la placa de video queda con una luz roja, que también significa que no tiene más alimentación.

¿Puede ser un problema de compatibilidad mi placa madre con respecto a la placa de video?, la verdad es que no sé. Este problema apareció de la nada, mi computadora funcionaba perfectamente hasta este mes.

¿Puede ser un problema de disco duro?, miré el dmesg y nunca ví ningún error de escritura ni de lectura.

Mi PC:

Código [Seleccionar] Expandir

AMD FX(tm) 6300 Six-Core Processor (6 CPUs), ~3.5GHz
Memoria: 8GB
Placa de video: ASUS R7 250X Series.
Placa Madre: ASRock N68-GS4 FX
Fuente: EVGA 500W 80 PLUS


WTFF! is happening.

Si me dicen que es un problema de hdd me compro otro, es lo único que no cambié de la computadora, pero no estoy 100% seguro de que sea eso, es más ni siquiera me llamó la atención en el primer momento, me parece que el problema es generado por otra cosa.

Ahora saqué todo limpié todos los contactos de cada uno, cambié la pasta térmica blablabla, y vamos a ver que pasa, ahora estoy corriendo Windows les aviso si me reinicia (creo que si va a pasar).

En caso de no tener respuesta a mi pregunta, ¿en qué página me recomendarías publicar este problema?

Saludos.

Lo solucioné así:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <pthread.h>

#define N 15
#define ARRLEN 1024

pthread_mutex_t MyMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t seguir = PTHREAD_COND_INITIALIZER;
pthread_cond_t seguir2 = PTHREAD_COND_INITIALIZER;

int arr[ARRLEN];

/* Cantidad de funciones "lectores" que se están ejecutando.*/
int lectores = 0;
/* Variable utilizada por si quiero escribir.*/
int wannawrite = 0;


void *escritor(void *arg)
{
 int i;
 int num = *((int *)arg);
 for (;;) {
   /*
      Escribo el mutex al principio y este está tomando toda la función porque no pueden
      haber más de 1 escritor a la vez.
   */
   pthread_mutex_lock(&MyMutex);

   /* Hey!!, quiero escribir!!, ahora todos deben dormir hasta que termine de escribir.*/
   wannawrite = 1;
   
   /* Espero hasta que todos los que estan leyendo, terminen de leer y se pogan a dormir
      De no ser así libero el mutex.

      wait(): Si tiene la señal, entonces despierta con EL MUTEX YA ADQUIRIDO.
   */
   while (lectores != 0) pthread_cond_wait(&seguir,&MyMutex);

   /* sleep(random()%3); */
   for (i=0; i<ARRLEN; i++) {
     arr[i] = num;
   }

   /* Terminé de escribir. */
   wannawrite = 0;

   /* Heeyy!!, despertá todos los lectores que tuvieron que dormir para que pueda escribir.*/
 
   pthread_cond_broadcast(&seguir2);
   pthread_mutex_unlock(&MyMutex);
 }
 return NULL;
}

void *lector(void *arg)
{
 int v, i, err;
 int num = *((int *)arg);
 for (;;) {
   /* En este caso si pueden haber más lectores a la vez entonces no voy a bloquear toda la función con un mutex,
    solo la bloquearé por partes. */

   pthread_mutex_lock(&MyMutex);
   lectores++;
   pthread_mutex_unlock(&MyMutex);
 
   /* sleep(random()%3); */
   err = 0;
   v = arr[0];
   for (i=1; i<ARRLEN; i++) {
     if (arr[i]!=v) {
       err=1;
       break;
     }
   }
   if (err) printf("Lector %d, error de lectura\n", num);
   else printf("Lector %d, dato %d\n", num, v);

   pthread_mutex_lock(&MyMutex);
   lectores--;

   /* si pondría un unlock acá, podría pasar cualquier cosa hasta que mande
      la señal de que yo terminé de leer y luego esperar. Por eso el unlock lo pongo al final.
      Si yo tengo el mutex por más que el otro tenga la señal y los lectores sean 0
      no puede tomar el mutex por lo tanto se queda bloqueado hasta que lo libero.  */

   /* Mando una señal que un thread terminó de leer. */
   pthread_cond_signal(&seguir);

   /* Si quiere escribir, entonces me bloqueo hasta que me avise que terminó de escribir.*/
   while(wannawrite == 1) pthread_cond_wait(&seguir2,&MyMutex);

   /* Ahora si suelto el mutex.*/
   pthread_mutex_unlock(&MyMutex);

 }
 return NULL;
}

int main()
{
 int i;
 pthread_t lectores[N], escritores[N];
 int arg[N];

 for (i=0; i<ARRLEN; i++) {
   arr[i] = -1;
 }
 for (i=0; i<N; i++) {
   arg[i] = i;
   pthread_create(&lectores[i], NULL, lector, (void *)&arg[i]);
   pthread_create(&escritores[i], NULL, escritor, (void *)&arg[i]);
 }
 pthread_join(lectores[0], NULL); /* Espera para siempre */
 return 0;
}


De todos modos esta solución le da demasiada prioridad a los escritores que a los lectores, no sé por qué se debe eso.

¿Alguna idea?

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t MyMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t seguir2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t seguir = PTHREAD_COND_INITIALIZER;

#define N 5

int aloja = 0;
int sigo = 0;



/*
Cuando un thread -que debe tener el mutex ya tomado- llama a wait(), suelta el mutex y
entra en espera bloqueante.

DEBE TENER EL MUTEX YA TOMADO!



Cuando un thread llama a signal(), otro thread en espera, de haberlo, se despierta de su wait()
CON EL MUTEX YA ADQUIRIDO

CON EL MUTEX YA ADQUIRIDO!

*/

void *freno (void *a)
{
for (;;){

// Tomo el mutex.
pthread_mutex_lock(&MyMutex);

// Hey!, quiero entrar, terminá lo que estás haciendo, te espero.
aloja = 1;

// Espero hasta que se "apague" la función avanzar.
// Cuando se apaga, AUTOMATICAMENTE TOMO YO EL MUTEX!!
while (sigo != 0){printf ("me llego la señal.\n"); pthread_cond_wait(&seguir,&MyMutex);}

// Si llegué hasta acá es porque yo tengo el mutex nadie mas lo puede tomar.
printf ("Estoy en freno\n");

// Terminé de hacer todo lo que quería hacer.
aloja = 0; // Por más que lo ponga el 0, "avanzar" no puede entrar todavía, porque
// yo tengo el mutex!


/* Libero el mutex, es decir, ahora la función avanzar sí puede tomar el mutex, PERO
a la vez no ya que está dentro de un wait esperando un SIGNAL no que libere un mutex.
Aunque no está demás recordar que solo 1 puede tomar el mutex a la vez. */
pthread_mutex_unlock(&MyMutex);

/*
Cuando un thread llama a signal(), otro thread en espera, de haberlo, se despierta de su wait
CON EL MUTEX YA TOMADO!

pthread_cond_signal(&seguir2);

*/

/*
Cuando un thread llama a broadcast(), todos los threads en espera, de haberlo, se despiertan de su
wait CON EL MUTEX YA TOMADO, es decir en este caso, se pelean por quien toma el mutex.
*/

pthread_cond_broadcast(&seguir2);
}
}


void *avanzar (void *b)
{
for (;;){
// Tomo yo el mutex, nadie más lo puede tomar.
pthread_mutex_lock(&MyMutex);
sigo++;
// Libero, ahora si puede tomar el mutex la función "freno".
pthread_mutex_unlock(&MyMutex);

//sleep(3);
printf ("estoy en sigo.\n");

// No puedo tomar el mutex hasta que la función freno recién llegue a la linea donde entra en espera!
pthread_mutex_lock(&MyMutex);
sigo--;
// Libero el mutex, recien ahora pueden ejecutarse más funciones "freno", antes no porque yo tenía el
// mutex tomado.
pthread_mutex_unlock(&MyMutex);

printf("Avanzar: %d\n",sigo);

/* Esta señal está esperando "freno" para poder continuar, pero además de esperar la señal espera
también que la cantidad de "sigo" sea igual a 0 */

/*
Si sigo es un número mayor a 0, entonces de todos modos va a seguir esperando.
*/
pthread_cond_signal(&seguir);

/*PERO! a la vez yo me bloqueo. Esperando ahora que "freno" me desbloque. */
/* Y a su vez freno está esperando que yo lo desbloquee. */
while (aloja != 0)pthread_cond_wait(&seguir2,&MyMutex);

/*
¿Qué pasaría si avanzar toma el mutex e incrementa en 1 la variable "sigo" y al toque "freno" pone
en 1 la variable aloja?

Lo que pasaría es que la variable sigo se incrementa luego suelta el mutex, lo toma la función"freno"
pone en 1 aloja pero como sigo es mayor que cero entonces SUELTA el mutex automáticamente y deja
que siga funcionando "avanzar", entonces pueden pasar cosas!:

Primero de todo, no se pueden ejecutar dos "frenos" a a la vez pero si se pueden ejecutar "avanzar"
muchas veces.

Entonces, avanzar toma el mutex y decrementa en 1 la variable
sigo y al momento lo suelta, PERO "freno" todavía no puede hacer nada porque está esperando un
signal,  no está esperando que suelte el mutex (explicado anteriormente)

Entonces yo le doy el signal y suponiendo que el numero de sigo es igual a 0, se ejecuta freno y yo
entro en espera hasta que freno termine.


*/
}

}

int main (void)
{
int i;
pthread_t prueba1[N],prueba2[N];

for (i=0; i<N; i++){
pthread_create(&prueba1[i],0,freno,"aloja");
pthread_create(&prueba2[i],0,avanzar,"chau");
}

pthread_join(prueba1[0],0);
return 0;
}


El programa sigue está logica aunque las funciones no se llamen lector y escritor.

1. No puede haber un lector accediendo al arreglo al mismo tiempo que un escritor.
2. Varios lectores pueden acceder al arreglo simult´aneamente.
3. S´olo puede haber un escritor a la vez.

Y además cuando los lectores que están leyendo terminen su lectura pero no se puedan empezar nuevas lecturas hasta que el escritor escriba.

freno = escritor.
avanzar = lector.

Aunque en este caso no escriben ni leen nada solo muestran texto.

El problema es que no funciona y no sé que es lo que estoy pensando mal, el programa se congela es decir en algún momento queda esperando algo que nunca llega.

[WhatsApp]

Lo que pasa es que se utiliza para programación concurrente, y si se usa, los servidores de WhatsApp están en Erlang. @Randomize, ja ja @simorg C es más viejo aún.

"WhatsApp server is almost completely implemented in Erlang as it was suitable for accommodating huge communication system with high sustainability."

Con respecto a lo del avatar, lo haré luego ahora estoy ocupado con otras cosas.

[[MOD] Revisa tu avatar, mide 477 x 819. Las Reglas del Foro indican maximo 300 x 400, de lo contrario será retirado.]

Hola.

¿Acá nadie programa en Erlang?, lo busqué creo que no existe ningún subforo.

Saludos.




[MOD] Revisa tu avatar, mide 477 x 819. Las Reglas del Foro indican maximo 300 x 400, de lo contrario será retirado.

Estaba distraído mientras lo programaba, cómo se me pasó eso?, hubiera estado horas buscando el problema en otra parte.

Gracias.

Quiero escribir esto:

Código (c) [Seleccionar] Expandir

int fib (int n){
       if (n <= 1)
               return n;
       return fib(n-1) + fib(n-2);
}


En programación dinámica es decir sin que se recalculen tantas veces los mismos resultados y usando TOP-DOWN.

Intenté esto:

Código (c) [Seleccionar] Expandir


#define MAX 1000
char mem[MAX];

void start(){
       int i;
       for (i=0; i<MAX; i++)
               mem[i] = -1;
}

int td (int n){

       // Si es igual a -1 significa que todavía no lo resolvimos.
       if (mem[n] == -1){

               if (n <= 1)
                       mem[n] = n;
               else
                       mem[n] = td(n-1) + td(n-2);
       }

       return mem[n];
}


Pero no funciona funciona en los primeros a partir del número 20 tira mal el resultado, ¿alguna pista de por qué no funciona?

Saludos.