Critical Section vs. Mutex Object vs. Interlocked Access

hustbaer

Die Interlocked-Funktionen sind flexibler. Damit kannst du z.B. auch lockfreie Datenstrukturen implementieren. Also Datenstrukturen die ganz ohne extra "Mutex" oder CRITICAL_SECTION auskommen.
Ich würde empfehlen da grundsätzlich die Finger davon zu lassen, ausser du hast a) sehr spezielle Anforderungen und b) kennst dich schon sehr gut mit dem Thema aus.

CRITICAL_SECTION ist die "schnelle" Mutex-Variante von Windows. Kann man eigentlich überall verwenden, es sei denn man braucht ein Feature welches CRITICAL_SECTION nicht bietet. Das könnte sein
* Prozessübergreifend verwendbar (CRITICAL_SECTION ist nur innerhalb eines einzigen Prozesses verwendbar)
* Timed-Wait Funktion (CRITICAL_SECTION bietet nur TryEnter)
* Deterministisches Scheduling (z.B. FIFO, Priority)

Eine Windows Kernel Mutex schliesslich bietet die ersten beiden Features. Dafür sind die Dinger verdammt viel langsamer als CRITICAL_SECTIONs.

Meine Empfehlung wäre die erste mögliche Option aus dieser Liste zu verwenden:

Libraries ala Boost.Thread verwenden die das ganze abstrahieren/kapseln
CRITICAL_SECTION
Windows Kernel Mutex
Nur wenn's gar nicht anders geht Interlocked-Funktionen

RedPuma

hustbaer schrieb:

Libraries ala Boost.Thread verwenden die das ganze abstrahieren/kapseln

Ich wüsste nicht was die Boost Library anders machen sollte außer Critical Sections zu verwenden. Und wenn du unbedingt ne Objektorientierte Kapselung verwenden willst dann bitte:

Header:

#pragma once

#include <Windows.h>

//CThreadMutex is a wrapper for the Windows Mutex Synchronization Object

class CThreadMutex
{
public:
	CThreadMutex(void);
	~CThreadMutex(void);

	void SetOrWait( void );
	void Release( void );

private:
	CRITICAL_SECTION m_Crit;
};

.cpp File:

#include "stdafx.h"
#include "CThreadMutex.h"
#include <Windows.h>

CThreadMutex::CThreadMutex(void)
{
	InitializeCriticalSection( &m_Crit );
}

CThreadMutex::~CThreadMutex(void)
{
	DeleteCriticalSection( &m_Crit );
}

void CThreadMutex::SetOrWait( void )
{
	EnterCriticalSection( &m_Crit );
}

void CThreadMutex::Release( void )
{
	LeaveCriticalSection( &m_Crit );
}

Heißt leider noch CThreadMutex weil ich die Klasse zuerst für Mutexes genutzt habe und anschließend auf Critical Sections umgeschrieben habe, ich wollte aber keine weitreichenden Änderungen im Code meines Programms machen.

Kleines Beispiel:

CThreadMutex myMutex;

//...

myMutex.SetOrWait();

//do something critical

myMutex.Release();

Was ist mit den Interlocked-Funktionen? Sehr speziell? Nur, wenn's gar nicht anders geht?
Gibt es da Probleme? Ich nutze die überall, wo ich eine Variable synchronisieren muss.

RedPuma

Fräge! schrieb:

Was ist mit den Interlocked-Funktionen? Sehr speziell? Nur, wenn's gar nicht anders geht?
Gibt es da Probleme? Ich nutze die überall, wo ich eine Variable synchronisieren muss.

Speziell in dem Sinne dass man damit IMHO nur einzelne Variablen synchronisieren kann, und keine ganzen Codeabschnitte. Die Meinung dass man sie nur benutzen soll wenns gar nicht anders geht teile ich nicht, schließlich sind die eigentlich relativ einfach zu benutzen.

volkard

RedPuma schrieb:

Die Meinung dass man sie nur benutzen soll wenns gar nicht anders geht teile ich nicht, schließlich sind die eigentlich relativ einfach zu benutzen.

Naja, ich versuche immer das schnellste zu benutzen. Interlocked ist da schon recht weit vorne. Aber nicht vergessen man darf, daß die CritSect schon schneller als nur zwei Interlockeds ist.

Aber nicht vergessen man darf, daß die CritSect schon schneller als nur zwei Interlockeds ist.

Wirklich das stimmt? Kann jemand bestätigen?

volkard

Π schrieb:

Aber nicht vergessen man darf, daß die CritSect schon schneller als nur zwei Interlockeds ist.

Wirklich das stimmt? Kann jemand bestätigen?

Bei mir:
CritSect 3.047 Sekunden
Interlocked 3.406

Es muß mehrmals gemessen und der kleinste Wert genommen werden.

#include <iostream>
#include <ctime>
#include <Windows.h>
using namespace std;

int main(){
	CRITICAL_SECTION cs;
	LONG su=0;
	LONG lo=0;
	InitializeCriticalSection(&cs);
	clock_t cl=clock();
	while(cl==clock())
		;
	cl=clock();
	for(LONG i=0;i<100000000;++i){
#if 0
		EnterCriticalSection(&cs);
		su+=i;
		LeaveCriticalSection(&cs);
#else
		InterlockedExchange(&lo,su);
		su+=i;
		InterlockedExchange(&lo,i);
#endif
	}
	DeleteCriticalSection(&cs);
	cout<<(clock()-cl)/double(CLOCKS_PER_SEC)<<" Sekunden\n";
	cout<<"Antioptimierungsausgabe: "<<lo<<su<<'\n';
}

Würde ich interessieren, ob es bei Euch ähnlich ist.

hustbaer

RedPuma schrieb:

hustbaer schrieb:

Libraries ala Boost.Thread verwenden die das ganze abstrahieren/kapseln

Ich wüsste nicht was die Boost Library anders machen sollte außer Critical Sections zu verwenden.

Sie verwendet in der aktuellen Version soweit ich weiss Interlocked Funktionen, aber das ist eigentlich nicht wichtig.

Und wenn du unbedingt ne Objektorientierte Kapselung verwenden willst dann bitte:

Header:

#pragma once

#include <Windows.h>

//CThreadMutex is a wrapper for the Windows Mutex Synchronization Object

class CThreadMutex
{
public:
	CThreadMutex(void);
	~CThreadMutex(void);

	void SetOrWait( void );
	void Release( void );

private:
	CRITICAL_SECTION m_Crit;
};

.cpp File:

#include "stdafx.h"
#include "CThreadMutex.h"
#include <Windows.h>

CThreadMutex::CThreadMutex(void)
{
	InitializeCriticalSection( &m_Crit );
}

CThreadMutex::~CThreadMutex(void)
{
	DeleteCriticalSection( &m_Crit );
}

void CThreadMutex::SetOrWait( void )
{
	EnterCriticalSection( &m_Crit );
}

void CThreadMutex::Release( void )
{
	LeaveCriticalSection( &m_Crit );
}

Wieso sollte man sich immer alles selbst programmieren?
Etwas selbst zu machen, nur weil es geht, ist meist schlecht. Wenn man es macht um dabei zu lernen, OK. Wenn man es nur macht weil man einen furchtbaren Dickschädel hat, ist es aber fast immer ein Fehler.

* Die Boost.Thread ist quasi-Standard, und wird fast 1:1 in der Form wohl auch im neuen C++ Standard landen
* Die Boost.Thread ist "tried and true", und von Leuten programmiert die ziemlich gut wissen was sie tun
* Die Boost.Thread ist komfortabel zu handhaben, was ich von deiner Klasse nicht sagen würde. Es fehlt z.B. die "Scoped-Lock" Klasse, die die Mutex/CRITICAL_SECTION im Konstruktor lockt und im Destruktor unlockt

Und noch ganz konkret zum Thema warum ich es für eine schlechte Idee halte, sich selbst was zu basteln, was es schon (als allgemein akzeptierte Komponente) fertig gibt...
Die meisten Leute machen bei der Implementierung nicht nur Fehler, sondern gewöhnen sich dabei auch an, bestimmte Dinge nach ihrem eigenen Dickschädel zu machen, und nicht wie sie "alle anderen" machen. Reicht schon wenn etwas was überall "foo" heisst bei dir dann "bar" heisst. Der Effekt der Implementierungsfehler dürfte klar sein. Der Effekt von anderen Namen/Begriffen ist, dass man anfängt ein anderes Vokabular zu verwenden. Und das ist IMO immer ein Nachteil, da es eine unnötige Kommunikations-Barriere darstellt.

Konkret am Beispiel deines Codes:

Implementierungs-Fehler:

* Deine CThreadMutex Klasse ist copy-constructable, dürfte es aber nicht sein

* Deine CThreadMutex Klasse ist assignable, dürfte es aber nicht sein

Quality-Of-Implementation:

* Der Konstruktor verwendet InitializeCriticalSection. InitializeCriticalSection kann fehlschlagen, diesen Umstand aber nicht kommunizieren. -> Lieber InitializeCriticalSectionAndSpinCount verwenden

* Du bietest keine Scoped-Lock Klasse an

* Du bietest keine Try-Lock Funktion an

Namen:

* "CThreadMutex" ist ein seltsamer name (was soll das "Thread" im Namen?). Entweder CriticalSection, wenn man einen Windows-spezifischen Namen will, oder einfach Mutex/RecursiveMutex/RecursiveTryMutex.

* "SetOrWait" ist ein Name den ich *noch nie* irgendwo in dem Zusammenhang gelesen/gehört habe. (Und für mich persönlich auch kontraintuitiv - "set" assoziiere ich im Zusammenhang mit Threads mit Events). Üblich wären "Lock"/"Unlock", "Acquire"/"Release" und "Enter"/"Leave". (Manchmal auch "Wait", finde ich persönlich aber nicht gut. Allerdings immer noch besser als SetOrWait")

RedPuma schrieb:

Kleines Beispiel:
(...)

Kleines Beispiel mit Boost.Thread:

boost::recursive_mutex g_mutex;

void foo()
{
    boost::unique_lock<boost::recursive_mutex> lock(g_mutex); // lock

    //do something

} // unlock

FrEEzE2046

Vielen Dank für eure Antworten.
Ich denke, dass es definitiv am schnellsten ist die Interlocked-Funktionen zu benutzen, so lange es sich nur um den Zugriff auf eine Variable handelt.

Dabei würde mich noch interessieren, ob diese zwingend als volatile deklariert sein muss, oder ob das hier keine Rolle spielt.

volkard schrieb:

Würde ich interessieren, ob es bei Euch ähnlich ist.

CS: 3.285s
Interlocked: 2.745s

hustbaer

volkard schrieb:

Bei mir:
CritSect 3.047 Sekunden
Interlocked 3.406
(...)
Würde ich interessieren, ob es bei Euch ähnlich ist.

Auf dem P4 (Northwood, 2.8 GHz) von Mutti (hab Urlaub :)).

CS: 16.797 sec
interlocked: 12.703 sec

Deck sich inetwa mit dem was ich in Erinnerung habe (damals auch auf einem P4 gemessen), nämlich dass eine CS (lock + unlock) ca. 2.5 * so lange braucht wie eine Interlocked-Funktion.

Ob nun 2 oder 3 Interlocked-Calls macht IMO keinen grossen Unterschied. Wichtig ist zu wissen, dass eine CS ausreichend schnell ist, so dass es sich nicht (OK: kaum jemals) auszahlt sich was eigenes zu stricken.

Boost ist auf mutterns Rechner nicht installiert, sonst hätte ich auch noch schnell mit boost::mutex und boost::recursive_mutex verglichen.

hustbaer

FrEEzE2046 schrieb:

Dabei würde mich noch interessieren, ob diese zwingend als volatile deklariert sein muss, oder ob das hier keine Rolle spielt.

Wenn du NUR Interlocked Funktionen verwendest um auf die Variable zuzugreifen ist es egal.
Wenn du an bestimmten Stellen die Variable einfach nur lesen willst (oder auch schreiben), dann solltest du sie volatile machen.

Speziell sowas kann schnell in die Hose gehen:

LONG i_should_be_volatile = 0;

void some_thread_fn()
{
    // do stuff
    InterlockedExchange(&i_should_be_volatile, 1);
}

void foo()
{
    while (i_should_be_volatile == 0)
    {
        // do nothing
    }
}

Das wird ohne volatile in foo() hängen bleiben, wenn man mit Optimierungen compiliert.

Sobald man einen System-Call (oder auch nur einen Aufruf einer Funktion, die der Compiler nicht analysieren kann) in der Schleife einfügt, geht es dann.

D.h. so geht es mit den meisten Compilern, wobei es nichts ist, worauf man sich verlassen sollte:

int i_should_be_volatile = 0;

void some_thread_fn()
{
    // do stuff
    InterlockedExchange(&i_should_be_volatile, 1);
}

void foo()
{
    while (i_should_be_volatile == 0)
    {
        Sleep(0); // system-call, verhindert normalerweise das rausziehen des tests "i_should_be_volatile == 0" vor die schleife
    }
}

Wenn man InterlockedCompareExchange(&i_should_be_volatile, 0, 0) statt i_should_be_volatile == 0 verwendet, dann geht es auch (verlässlich) ohne volatile.

FrEEzE2046

Wäre es nicht sinnvoller Acquire u. Release Semantic in diesem Fall zu benutzen:

while( InterlockedCompareExchangeAcquire(&lo, 1, 0) != 0 );
su+=i;
while( InterlockedCompareExchangeRelease(&lo, 0, 1) != 1 );

volkard

FrEEzE2046 schrieb:

Wäre es nicht sinnvoller Acquire u. Release Semantic in diesem Fall zu benutzen:
while( InterlockedCompareExchangeAcquire(&lo, 1, 0) != 0 );
su+=i;
while( InterlockedCompareExchangeRelease(&lo, 0, 1) != 1 );

Weiß nicht.
Aber wenn ich es mache, habe ich anscheinend keinen Unterschied mehr zwischen Interlocked und CritSect. AMD Sempron 64 3000+ (oh, er kostet nur noch 15€).

FrEEzE2046

volkard schrieb:

Aber wenn ich es mache, habe ich anscheinend keinen Unterschied mehr zwischen Interlocked und CritSect. AMD Sempron 64 3000+ (oh, er kostet nur noch 15€).

Gut, es ging jetzt weniger um die Zeit. Viel mehr um die Sicherheit, dass "su" den Wert hat, den es haben soll.

hustbaer

FrEEzE2046 schrieb:

volkard schrieb:

Aber wenn ich es mache, habe ich anscheinend keinen Unterschied mehr zwischen Interlocked und CritSect. AMD Sempron 64 3000+ (oh, er kostet nur noch 15€).

Gut, es ging jetzt weniger um die Zeit. Viel mehr um die Sicherheit, dass "su" den Wert hat, den es haben soll.

Die Funktionen die nicht auf Acquire oder Release enden haben Acquire+Release Semantik, d.h. auf der sicheren Seite bist du damit auf jeden Fall.
(Auf Intel x86 haben die sogar "full barrier" Semantik, weiss aber nicht ob das z.B. auch für IA64 garantiert ist)

EDIT: hab gerade nachgesene, "full barrier" ist anscheinend für alle Plattformen garantiert:

MSDN schrieb:

InterlockedCompareExchange Function
(...)
This function generates a full memory barrier (or fence) to ensure that memory operations are completed in order.

RedPuma

Wieso sollte man sich immer alles selbst programmieren?
Etwas selbst zu machen, nur weil es geht, ist meist schlecht. Wenn man es macht um dabei zu lernen, OK. Wenn man es nur macht weil man einen furchtbaren Dickschädel hat, ist es aber fast immer ein Fehler.

* Die Boost.Thread ist quasi-Standard, und wird fast 1:1 in der Form wohl auch im neuen C++ Standard landen
* Die Boost.Thread ist "tried and true", und von Leuten programmiert die ziemlich gut wissen was sie tun
* Die Boost.Thread ist komfortabel zu handhaben, was ich von deiner Klasse nicht sagen würde. Es fehlt z.B. die "Scoped-Lock" Klasse, die die Mutex/CRITICAL_SECTION im Konstruktor lockt und im Destruktor unlockt

Und noch ganz konkret zum Thema warum ich es für eine schlechte Idee halte, sich selbst was zu basteln, was es schon (als allgemein akzeptierte Komponente) fertig gibt...
Die meisten Leute machen bei der Implementierung nicht nur Fehler, sondern gewöhnen sich dabei auch an, bestimmte Dinge nach ihrem eigenen Dickschädel zu machen, und nicht wie sie "alle anderen" machen. Reicht schon wenn etwas was überall "foo" heisst bei dir dann "bar" heisst. Der Effekt der Implementierungsfehler dürfte klar sein. Der Effekt von anderen Namen/Begriffen ist, dass man anfängt ein anderes Vokabular zu verwenden. Und das ist IMO immer ein Nachteil, da es eine unnötige Kommunikations-Barriere darstellt.

Konkret am Beispiel deines Codes:

Implementierungs-Fehler:

* Deine CThreadMutex Klasse ist copy-constructable, dürfte es aber nicht sein

* Deine CThreadMutex Klasse ist assignable, dürfte es aber nicht sein

Quality-Of-Implementation:

* Der Konstruktor verwendet InitializeCriticalSection. InitializeCriticalSection kann fehlschlagen, diesen Umstand aber nicht kommunizieren. -> Lieber InitializeCriticalSectionAndSpinCount verwenden

* Du bietest keine Scoped-Lock Klasse an

* Du bietest keine Try-Lock Funktion an

Du hast natürlich völlig recht wenn es dabei um einen industriellen Maßstab geht. Dass meine Wrapper-Klasse vollständig oder besser als die boost-library ist habe ich nicht behauptet, dass sie fehlerfrei ist oder sonstiges auch nicht. Die sollte sowieso nur ein Beispiel sein wie einfach man sowas basteln kann. Bei der Einfachheit hätte ich z.B. gar keine Wrapper-Klasse genommen, jedoch kann ich bei meiner Version wie gesagt noch zwischen Mutex und Crit Section umschalten.

Dass die boost library inzwischen standard ist ist mir auch klar, nur finde ich eher dass man bei solch "kleinen" Problemen keine solch "riesige" Bibliothek heranziehen muss, und sich mit deren Benutzung auseinandersetzen muss. Vor allem in dem Hinblick dass sich der Eröffner dieses Threads schon zahlreich mit den Windows-Synchronisations-Objekten vertraut gemacht hat, und das Einarbeiten in boost::thread unnötig währe.

/Edit: Ach ja, der Name CThreadMutex stammt daher dass mich Visual Studio 10 keine Klasse mit dem Namen CMutex erstellen ließ. Also zumindest der Dialog nach der Schaltfläche "Klasse hinzufügen" verweigerte mir dies. Da ich mir dachte das dies vielleicht aus gutem Grund geschieht habe ich meine Klasse dann nicht einfach über den Texteditor erstellt sondern umbenannt.

FrEEzE2046

RedPuma schrieb:

Also zumindest der Dialog nach der Schaltfläche "Klasse hinzufügen" verweigerte mir dies. Da ich mir dachte das dies vielleicht aus gutem Grund geschieht habe ich meine Klasse dann nicht einfach über den Texteditor erstellt sondern umbenannt.

Das benutzt jemand? Das vorangestellte "C" sieht man sonst vor allem beim - mir zu widerem - MFC.

Desweiteren möchte ich die boost Library nicht heranziehen. Das wäre auch unnötig, da es sich hier um eine relativ kleine Problematik handelt für die man prinzipiell nicht mal eine Thread-Wrapper Klasse benötigt.

FrEEzE2046

Evtl. habe ich irgendetwas - event objects betreffend - noch nicht richtig verstanden. Kann mir jemand sagen warum ich hier beim Aufruf von WaitForSingleObject() in einer Endlosschleife hängen bleibe?

#include <iostream>
#include <process.h>
#include <Windows.h>

using namespace std;

unsigned __stdcall ThreadProc(void*);

int main()
{
	unsigned threadID = 0;
	DWORD	 threadExitCode = 0;

	HANDLE hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
	HANDLE hThread = reinterpret_cast<HANDLE>(_beginthreadex(
		nullptr,
		0,
		ThreadProc,
		&hEvent,
		0,
		&threadID
	));

	for( ;; )
	{
		while( WaitForSingleObject(hEvent, 1) == WAIT_TIMEOUT ) {Sleep(1);}
		cout << "time elapsed" << endl;
		Sleep(1);

		if( !WaitForSingleObject(hThread, 1) /*WAIT_OBJECT_0*/ )
			break;
	}

	GetExitCodeThread(hThread, &threadExitCode);
	cout << threadExitCode << endl;

	CloseHandle(hEvent);
	CloseHandle(hThread);
	return 0;
}

unsigned __stdcall ThreadProc(void* param)
{
	HANDLE  hEvent = static_cast<HANDLE>(param);

	for( int i = 0; i < 10; ++i )
	{
		for( int j = 0; j < 1 << 31 - 1; ++j );
		PulseEvent(hEvent);
		Sleep(1);
	}

	_endthreadex(4711);
	return 0;
}

FrEEzE2046

Man sollte dazu sagen, dass ich heute seit Freitag krank bin. Anders kann ich mir diesen lächerlichen Fehler auch nicht erklären. In Zeile 47 muss es natürlich so aussehen:

HANDLE hEvent = *static_cast<HANDLE*>(param);

Jetzt funktioniert das auch.

FrEEzE2046

Ich hole diesen Thread nochmal vor. Wie kann ich denn eine Variable auf die gleichzeitig geschrieben werden könnte sicher lesen?

Ich nutze in meinem Code generell die Interlocked-Funktionen wenn möglich. Ich könnte natürlich mit InterlockedAnd oder InterlockedCompareExchange operieren, die mir jeweils den "alten" Wert zurückliefern, allerdings möchte ich weder austauschen noch konjugieren.

Kennt jemand eine andere Möglichkeit?