Crossplatforn Multithreading?

sothis_ schrieb:

zum glück hast du das nicht ins c++ subforum gepostet, da wär gleich wieder einer mit boost gekommen

ist das schlecht?

lagalopex schrieb:

OpenMP ist ja eher eine Erweiterung für den Compiler, damit der einzelne z.B. Schleifen teilweise parallel abarbeitet. Geht also auch nicht von selbst, sondern der Compiler wird per Makros angewiesen, dies oder jenes zu parallelisieren, also schon recht abstrakt.
Schau mal auf openmp.org - Compilers nach.

Wenn du quasi selber Threads managen willst (was meiner Definition von Multithreading näher kommt) fällt mir spontan nur die glib ein.

jup, soweit wusste ich das durch openmp schon, finde nur schade das es keine lib ist, fände ich besser als das es compiler abhängig ist (vorallem hätte man jetzt schon dadurch ne größere compiler auswahl).

sothis_ schrieb:

threading ist keine zauberei, die konzepte sind fast überall gleich, da reichen ein paar wrapperfunktionen mit #if-#else-#endif die du überall wiederverwenden kannst
zum glück hast du das nicht ins c++ subforum gepostet, da wär gleich wieder einer mit boost gekommen

kannste mir bitte beispiele nennen, also z.b. ne fertige lib wie lagalopex schon angesprochen hat?

Ganz klar POSIX.

Filberto schrieb:

jup, soweit wusste ich das durch openmp schon, finde nur schade das es keine lib ist, fände ich besser als das es compiler abhängig ist (vorallem hätte man jetzt schon dadurch ne größere compiler auswahl).

Du könntest die SDL Library dafür mißbrauchen.

Die ist zwar in der Regel für grafische 2d Anwendungen wie Spiele gedacht,
aber sie bietet auch ausgezeichnete Threadfähigkeiten und du kannst sie auf so gut wie jeder Plattform compilieren, selbst auf Exoten.
Außerdem ist sie klein, schlank und schnell erlernbar.

Darüberhinaus ist es eine C Bibliothek, das pa0t also.
http://www.libsdl.org/

sothis_

ich frage mich wo euer problem ist.

typedef void* PMUTEX;
typedef void* PTHREAD;

typedef void* (*PTHREAD_ROUTINE)(void* args);

PMUTEX ltk_createmutex(void)
{
#if WIN32
    HANDLE tm = 0;
    tm = CreateMutex(0, 0, 0);
#else
    pthread_mutex_t* tm = 0;
    tm = malloc(sizeof(pthread_mutex_t));
    if (tm) pthread_mutex_init(tm, 0);
#endif
    return tm;
}

void ltk_destroymutex(PMUTEX mutex)
{
    if (!mutex) return;
#if WIN32
    WaitForSingleObject(mutex, INFINITE);
    CloseHandle(mutex);
    mutex = 0;
#else
    pthread_mutex_lock(mutex);
    pthread_mutex_destroy(mutex);
    free(mutex);
    mutex = 0;
#endif
    return;
}

void ltk_mlock(PMUTEX mutex)
{
    if (!mutex) return;
#if WIN32
    WaitForSingleObject(mutex, INFINITE);
#else
    pthread_mutex_lock(mutex);
#endif
    return;
}

void ltk_munlock(PMUTEX mutex)
{
    if (!mutex) return;
#if WIN32
    ReleaseMutex(mutex);
#else
    pthread_mutex_unlock(mutex);
#endif
    return;
}

void ltk_join(PTHREAD thread)
{
    if (!thread) return;
#if WIN32
    WaitForSingleObject(thread, INFINITE);
#else
    pthread_join(*(pthread_t*)thread, 0);
#endif
    return;
}

PTHREAD ltk_createthread(PTHREAD_ROUTINE thread_routine, void* args)
{
#if WIN32
    HANDLE tt = 0;
    tt = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_routine, args, 0, 0);
#else
    pthread_t* tt = 0;
    tt = malloc(sizeof(pthread_t));
    if (tt) pthread_create(tt, NULL, thread_routine, args);
#endif
    return tt;
}

void ltk_destroythread(PTHREAD thread, int join)
{
    if (!thread) return;
    if (join) ltk_join(thread);
#if WIN32
    CloseHandle(thread);
    thread = 0;
#else
    pthread_detach(*(pthread_t*)thread);
    free(thread);
    thread = 0;
#endif
    return;
}

das sind 100 zeilen code und man hat das grundsätzliche für windows und linux.

Badestrand

sothis_ schrieb:

void ltk_destroymutex(PMUTEX mutex)
{
    ...
    mutex = 0;
}

Du weißt aber schon, dass hier nur die lokale Variable auf 0 gesetzt wird, oder?

sothis_

da wird der hund in der pfanne verrückt

edit:

void ltk_destroymutex(PMUTEX* mutex)
{
    if (!mutex || !*mutex) return;
#if WIN32
    WaitForSingleObject(*mutex, INFINITE);
    CloseHandle(*mutex);
    *mutex = 0;
#else
    pthread_mutex_lock(*mutex);
    pthread_mutex_destroy(*mutex);
    free(*mutex);
    *mutex = 0;
#endif
    return;
}

void ltk_destroythread(PTHREAD* thread, int join)
{
    if (!thread || !*thread) return;
    if (join) ltk_join(thread);
#if WIN32
    CloseHandle(*thread);
    *thread = 0;
#else
    pthread_detach(*(pthread_t*)*thread);
    free(*thread);
    *thread = 0;
#endif
    return;
}

sothis_

-wieso schrieb:

sothis_ schrieb:

zum glück hast du das nicht ins c++ subforum gepostet, da wär gleich wieder einer mit boost gekommen

ist das schlecht?

nein keinesfalls, ich wollte einfach nur mal trollen, wie dies häufig im c++ subforum gegenüber c geschieht. ist mir aber ehrlich gesagt nicht gut gelungen

Warum sich so viel Arbeit machen, benutz doch einfach boost::thread.

sothis_

So viel Arbeit schrieb:

Warum sich so viel Arbeit machen, benutz doch einfach boost::thread.

zu spät, jetzt isses nicht mehr lustig

-wieso schrieb:

sothis_ schrieb:

zum glück hast du das nicht ins c++ subforum gepostet, da wär gleich wieder einer mit boost gekommen

ist das schlecht?

es macht doch im prinzip auch nix anderes als:

#ifdef WIN32
 ...
#else
 ...
#endif