Critical Section vs. Mutex Object vs. Interlocked Access

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?

hustbaer

InterlockedCompareExchange(&v, 0, 0) geht schön, bzw. natürlich auch allgemein InterlockedCompareExchange(&v, X,

Mit MSVC (ab Version 8 aka 2005) + x86 reicht allerdings einfach ein Lesezugriff auf eine volatile Variable.

Bzw. glaube ich sogar ein normaler Lesezugriff wenn man ihn mit zwei _ReadWriteBarrier() Aufrufen einklammert.

EDIT:

MSDN schrieb:

Microsoft Specific

Objects declared as volatile are not used in certain optimizations because their values can change at any time. The system always reads the current value of a volatile object at the point it is requested, even if a previous instruction asked for a value from the same object. Also, the value of the object is written immediately on assignment.

Also, when optimizing, the compiler must maintain ordering among references to volatile objects as well as references to other global objects. In particular,
*
A write to a volatile object (volatile write) has Release semantics; a reference to a global or static object that occurs before a write to a volatile object in the instruction sequence will occur before that volatile write in the compiled binary.

A read of a volatile object (volatile read) has Acquire semantics; a reference to a global or static object that occurs after a read of volatile memory in the instruction sequence will occur after that volatile read in the compiled binary.
*
This allows volatile objects to be used for memory locks and releases in multithreaded applications.

Note

Although the processor will not reorder un-cacheable memory accesses, un-cacheable variables must be volatile to guarantee that the compiler will not change memory order.

End Microsoft Specific

Ich begreif's nicht.

Ich schon lang nicht mehr ...

Andreas XXL

Ich schlage diesen Beitrag für die FAQ vor!

(Wird zwar nicht so häufig gefragt, sind aber recht vernünftige Beiträge)

xor

Falls es um Geschwindigkeit geht, möchte ich noch die intrinsics des MSVC einbringen. So laufen die Operationen nicht als WinAPI Aufruf, sonder werden direkt als atomare CPU-Anweisung in den Code eingefügt. Und dass geht dann noch schneller als über die API.
Hab mir dafür mittels Makros die Funktionen umdefiniert ... hier ein Auszug:

#include "windows.h"

#if defined(CPP_MSVC05) && !defined(WINCE)
#  include "intrin.h"
#  define InterlockedExchange         _InterlockedExchange
#  define InterlockedCompareExchange  _InterlockedCompareExchange
#  define InterlockedIncrement        _InterlockedIncrement
#  define InterlockedDecrement        _InterlockedDecrement
#endif

lg XOR

hustbaer

defined(CPP_MSVC05) - huch?

ich mach immer defined(_MSC_VER) && (_MSC_VER >= ...)