POSIX Thread

[zupervaca]

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.

[tamat]

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?

[zupervaca]

lo tengo asi:

Código [Seleccionar] Expand


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:

Código [Seleccionar] Expand

// 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


Código [Seleccionar] Expand

// 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.

[ZeruGiran]

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.