Les compilateurs Microsoft Visual C ++ ont le Quel est l'équivalent GCC?
Je vois des références autour de En fait, je vois une mention d'un certain nombre d'atomes J'utilise réellement Lesquels devrais-je utiliser? Y a-t-il des constructions en C ++ que je peux utiliser dans la dernière version de GCC et Visual C ++ 2010 disponible car je vais écrire du code multiplate-forme.
Je vois que Boost a quelques fonctions disponibles, mais pour diverses raisons, je ne suis pas autorisé à utiliser Boost sous Windows. Entriticalsection et ExitCriticalSection
objets pour permettre la synchronisation entre les threads.
__ sync_synchroniser avec __ scoped_lock
__ sync fonctionne avec un certain nombre de
__ atomique .
__ sync_fetch_and_add pour mon incrément atomique
Dois-je utiliser __ atomic_add_dispatch à la place?
Quelle est la différence?
4 Réponses :
sur Linux (et d'autres Unixen), vous devez utiliser Pthreads ou des threads POSIX. Il n'y a pas d'équivalent aux sections critiques sur Windows; Utilisez un mutex à la place.
Edit: Voir le premier commentaire ci-dessous - Apparemment, Posix Mutexes sont les mêmes que les sections critiques Win32 en ce qu'elles sont liées à un seul processus.
En réalité, les mutex de POSIX sont équivalents aux sections critiques Win32 (délimitée de processus); Les mutiles Win32 diffèrent des sections critiques en cours de croix.
@Msalters: Ah - Je ne le savais pas. Doit casser la réutilisation de la terminologie.
@Msalters, également, Win32 Les sections critiques sont beaucoup plus rapides que Win32 Mutilex, car elles sont implémentées dans l'espace utilisateur et n'impliquent pas la surcharge associée à l'appel du système. Je ne sais cependant pas sur Posix Mutilex?
@Tanuj: Vous voudrez peut-être comparer cette déclaration. La plupart des frais de tête de filetage sont généralement le résultat des commutateurs contextuels plutôt que de verrouiller, dans tous les cas.
Cela dépend fortement de la conflit. Sur une serrure hautement soutenue, la commutation contextuelle sur d'autres threads dominera. Sur une serrure ci-dessus, un commutateur de contexte entre l'espace utilisateur et l'espace du noyau domineraient (une section critique Win32 évite dans le cas non compris)
J'ai fait des tests et dans de lourdes conditions de contestation par de nombreux threads, les sections critiques de Windows sont nettement plus rapides que Linux MuTex.
@Arsen: n'aurait pas surpris de moi. Ce sont des bêtes différentes sous le capot, à ma compréhension (très limitée). Je sais que les Windows Guys ont passé beaucoup de temps à optimiser la manière dont les serrures se comportent.
Entriticalsection et le reste des API sont des API Win32. En ce qui concerne les API de synchronisation multiplate-forme, je ne pense pas qu'il y en ait (puisque vous mentionnez, vous ne pouvez pas utiliser Boost). En outre, vous avez mentionné une plate-forme multiplate-forme, cela signifie-t-il aussi des architectures différentes (pour la partie GCC, c'est-à-dire.).
J'ai vu une grande implémentation là où il y avait un ensemble commun d'API prévu qui ont été compilées sous condition d'avoir les API natives (comme Fetch_and_Add sur AIX) ou utilisées Pthreads les API Win32.
J'ai déjà essayé d'utiliser threads POSIX sur Win32 mais a eu un tas de problèmes (mais c'était un très ancienne version). Maintenant ymmv.
vérifier ici: http://en.wikipedia.org/wiki/critical_section
/* Sample C/C++, Unix/Linux */
#include <pthread.h>
/* This is the critical section object (statically allocated). */
static pthread_mutex_t cs_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
void f()
{
/* Enter the critical section -- other threads are locked out */
pthread_mutex_lock( &cs_mutex );
/* Do some thread-safe processing! */
/*Leave the critical section -- other threads can now pthread_mutex_lock() */
pthread_mutex_unlock( &cs_mutex );
}
int main()
{
f();
return 0;
}
Si vous développez des programmes uniquement pour la plate-forme Windows, je pense que le meilleur moyen consiste à utiliser Win32 API. Sinon, vous pouvez utiliser les bibliothèques QT C ++ (à cette fin, le noyau QT est suffisant).
Voir aussi: qmutex et qmutexLocker Vous pouvez également utiliser: qreadwritelock
Je suppose que vous ne pouvez utiliser aucune autre bibliothèque non plus alors? QT a une API de filetage (plate-forme inter-plateforme).