[c++] Multithreading: beschermen van primitive datatypen

[SuperNull]

Hi.

Ik heb een simpele vraag over multithreading in C++.
Ik snap dat complexe datatypen met dynamische geheugen allocatie noot tegelijk gelezen en geschreven mogen worden. Het is me echter niet geheel duidelijk of dit ook voor primitieven zoals een int het geval is.


Stel je hebt een int X en thread A en thread B.
Int X is NIET beschermt door semaforen en zit in de scope van zowel thread A als thread B.

Thread A schrijft met enige regelmaat naar X. De mogelijke waarden voor X die A kan schrijven zijn 3, 15, 200 en 5000.
Thread B leest met enige regelmaat int X.

Zal thread B nu ALTIJD een waarde van 3, 15, 200 of 5000 zien, of kan het theoretisch gebeuren dat B ooit een heel andere waarde ziet omdat A net bezig is met schrijven?

Alvast bedankt.

[.oisyn]

Dat ligt volledig aan het gebruikte platform, C++ doet geen enkele garanties over de atomiciteit van datatypen. In C++0x kun je een atomic<int> gebruiken.

That said, op veruit alle 32 bits platformen zijn reads en writes naar ints en kleiner atomair. Wel moet je rekening houden met het feit dat zowel de compiler als de CPU de statements kan herordenen. Een write naar a gevolgd door een write naar b impliceert niet dat dat ook daadwerkelijk in die volgorde te observeren is vanuit een andere thread. Daarnaast zul je ook de cache op sommige platforms moeten synchroniseren.

Beter kijk je dus gewoon naar de atomaire functionaliteit die het platform je biedt. Zo heb je onder Windows de Interlocked* API functies.

[SuperNull]

That said, op veruit alle 32 bits platformen zijn reads en writes naar ints en kleiner atomair.

Lol. Bedoel je nu 'alle' of 'veruit de meeste' ?

Ik neem aan je me wilde vertellen dat zolang ik bij de 'mainstream' procs (x86, POWER, ARM) blijf, ik er vanuit kan gaan dat een 32bit datatype atomair is? Begrijp ik dat goed?

Execution order is weer een ander probleem, het ging me hier puur en alleen om dat er nooit een waarde gelezen kan worden die nooit geschreven is.

[.oisyn]

SuperNull schreef op donderdag 12 augustus 2010 @ 15:58:
Ik neem aan je me wilde vertellen dat zolang ik bij de 'mainstream' procs (x86, POWER, ARM) blijf, ik er vanuit kan gaan dat een 32bit datatype atomair is? Begrijp ik dat goed?

Van x86 en PowerPC weet ik het zeker, ARM zul je even moeten verifieren.

[bobo1on1]

Volgens microsoft kun je met volatile ook nog een eind komen: http://msdn.microsoft.com.../12a04hfd%28VS.80%29.aspx

[SuperNull]

Ik heb voorlopig genoeg info om door te prutsen.
Mannen, bedankt.

[.oisyn]

Volatile op MS compilers helpt je hooguit tegen compiler reordering, niet tegen CPU reordering en het maakt reads/writes ook niet ineens atomair.