Foros - Stratos

Buenas, tengo implementado el sistema de hilos en win32 de forma nativa y en linux con posix thread (pthread), los dos sistemas me funcionan a la perfeccion, pero tengo un pequeño problema, hice dos hilos para ver si tiraba bien el asunto, uno pintaba en la consola la letra A y el otro la letra B, el resultado en windows fue muy bueno mostrando esto mas o menos en pantalla:
"ABBBABABABABABABABABAABAAAAABBABABAAABBBBB"
pero en linux me paso algo muy raro ya que me sale esto:
"AAAAAAAAAAAAAAAAAABBBBBBBBBBBBBAAAAAAAAAAA"
es decir mientras que con windows los dos hilos se procesan mas o menos con la misma prioridad, en linux cuando un hilo comienza a procesarse el otro se muere durante un tiempo, ¿alguien sabe a que puede ser debido? tengo dual core asi que por temas de emulacion no puede ser.

exactamente como organizas los threads? es decir, tienes un while(true) std::cout << "A";  en cada uno? o printas una letra y luego "liberas la ejecución?

lo tengo asi:


while(1)
{
cs.Start();
fprintf(stderr, "A\n");
cs.End();
}

cs es una clase para indicar secciones criticas, en el otro hilo es lo mismo pero en vez de pintar A pinto B, la clase cs es comun para A y B, si quito la seccion critica pasa exactamente lo mismo, la clase cs no esta hecha por mi, uso el sistema nativo de win32 y el de pthread, es decir, encapsula lo que son las llamadas a un api u otro (funciones inline)

El codigo que uso para posix es este, no es gran cosa ya que lo dan todo hecho:
// procedure.h

#ifndef _dib_Platform_PThread_System_Thread_Procedure
#define _dib_Platform_PThread_System_Thread_Procedure

#include "../../../../system/thread/iprocedure.h"
#include <pthread.h>

namespace dib
{
namespace Platform
{
namespace PThread
{
namespace System
{
namespace Thread
{
/// <summary>Clase para controlar un hilo con POSIX thead (pthread)</summary>
class Procedure : public dib::System::Thread::IProcedure
{
// Virtuales
protected:
/// <summary>Funcion que se ejecutara para el hilo</summary>
virtual void Thread() = 0;

// Metodos
public:
/// <summary>Constructor</summary>
Procedure()
{
this->handle = 0;
}

/// <summary>Destructor</summary>
virtual ~Procedure()
{
// Finalizar este hilo
this->Exit();
}

/// <summary>Crear el hilo</summary>
/// <returns>True se ha creado con exito, false no se puedo</returns>
bool Create()
{
return pthread_create(&this->handle, NULL, ThreadProc, (void*)this) == 0 ? true : false;
}

/// <summary>Finalizar el hilo</summary>
void Exit()
{
if( this->handle != 0 )
{
pthread_cancel( this->handle );
this->handle = 0;
}
}

// Metodos privados
private:
/// <summary>Funcion del hilo</summary>
static void *ThreadProc( void *ptr )
{
((Procedure*)ptr)->Thread();
return NULL;
}

// Miembros privados
private:
/// <summary>Handle del hilo</summary>
pthread_t handle;
};
}
}
}
}
}

#endif

// criticalsection.h

#ifndef _dib_Platform_PThread_System_Thread_CriticalSection
#define _dib_Platform_PThread_System_Thread_CriticalSection

#include "../../../../system/thread/icriticalsection.h"

namespace dib
{
namespace Platform
{
namespace PThread
{
namespace System
{
namespace Thread
{
/// <summary>Clase para coordinar hilos o procesos mediante POSIX thread (PThread)</summary>
class CriticalSection : public dib::System::Thread::ICriticalSection
{
// Metodos
public:
/// <summary>Constructor</summary>
CriticalSection()
{
::pthread_mutex_init( &this->mutex, NULL );
}

/// <summary>Destructor</summary>
virtual ~CriticalSection()
{
::pthread_mutex_destroy( &this->mutex );
}

/// <summary>Comenzar un proceso critico</summary>
void Start()
{
::pthread_mutex_lock( &this->mutex );
}

/// <summary>Finalizar un proceso critico</summary>
void End()
{
::pthread_mutex_unlock( &this->mutex );
}

// Miembros privados
private:
/// <summary>Objeto para controlar las secciones criticas</summary>
pthread_mutex_t mutex;
};
}
}
}
}
}

#endif


Editado: Aprovecho para preguntar si alguien sabe como pausar y resumir un hilo con posix, en win32 tenemos el suspendthread y el resumethread pero para posix no encuentro unas funciones parecidas.

Es porque en linux los tiempos de Latencia son mas largos que en windows.

Es decir en Windows el switcheo entre una tarea y otra se hace en tiempos mas cortos que en linux.

Lo cual no es necesariamente malo.

Tambien puede ser simplemente que en Windows la aplicacion se este ejecutando mas lentamente. Y por lo tanto hay mas switcheos a lo largo de la ejecucion del programa.

Algo interesante es que los tiempos de Latencia se pueden modificar en Linux para hacerlos mas cortos o mas largos. En Windows no se puede cambiar.