C++-ban mire való és mikor érdemes használni a volatile-t?

"Fokent multi-threaded programoknal erdemes hasznalni"

Az a cikk 2001-es, most pedig 2016 van. Arra célzok, hogy már csúnya dolog azt használni multi threadre.

unsigned inportb(unsigned short port)

{

unsigned char ret_val;

__asm__ __volatile__("inb %1,%0"

: "=a"(ret_val)

: "d"(port));

return ret_val;

}

// ------------

void outportb(unsigned port, unsigned val)

{

__asm__ __volatile__("outb %b0,%w1"

:

: "a"(val), "d"(port));

}

Kérdés a C/C++ nyelv volatile típusminősítéjéről?

Programozzunk C nyelven és Programozzunk C++ nyelven c. könyv:

"A volatile típusminősítővel olyan objektum hozható létre, amelyet (teljesen hivatalosan) a programunktól független kód (például egy másik futó folyamat, vagy megszakítást kezelő rutin) is megváltoztathat."

Amikor egy utasítás egy memóriacímre hivatkozik, akkor először a cache-ben (gyorsítótárban) keresi, sőt ha a kód úgy van megírva, akkor a korábbi használat miatt be sem olvassa, mert már valamelyik regiszterben van. Ilyenkor az utasítás az operandust nem a memóriából veszi, mert "közelebb" is rendelkezésre áll. Ez gyorsabb műveletvégzést tesz lehetővé.

Azonban lehetnek olyan memóriarekeszek (pl. objektum változók), amiket "kívülről" más alkalmazás is ír. Ilyenkor hiába van az értéke valamelyik regiszterben, mert taszkváltáskor (mikor visszakerül hozzád a vezérlés) a korábbi, most már rossz értékkel fog számolni a programod. Még rosszabb a helyzet, ha mondjuk egy érzékelő hardverének a memóriájából kell beolvasni valamit, amit a hardver folyamatosan frissít a prpcesszortól függetlenül.

Működés közben csak azt látod, hogy a hőszenzor szerencsétlen írja az adatokat a memóriába, de a programod nem reagál rá, mert rá sem néz. Nem tudja, hogy az értéke megváltozhatott annak ellenére, hogy nem is írt bele új adatot.

Na az ilyen változókat kell volatile szóval jelölni.

forrás: http://www.gyakorikerdesek.hu/szamitastechnika__programozas_..

"A const, signed és volatile új az ANSI szabványban;"

forrás: [link]

A forrás egyébként a C nyelv alkotóinak könyve.

1983-ban az Amerikai Nemzeti Szabványügyi Hivatal (angolul: American National Standards Institute, röviden ANSI) megalakította az X3J11 bizottságot, hogy létrehozzanak egy egységes (szabvány) C definíciót. A hosszú és fáradságos folyamat végén 1989-ben elkészült a szabvány (egy évvel az első C++ ANSI szabvány után!) és jóváhagyták mint: ANSI X3.159–1989 „A C programozási nyelv”. A nyelvnek ezt a verzióját nevezik ANSI C-nek. 1990-ben az ANSI C szabványt (néhány apróbb módosítással) átvette a Nemzetközi Szabványügyi Szervezet (angolul: International Organization for Standardization, röviden ISO) mint ISO/EC 9899:1990.

Az ANSI C szabványosítás egyik célja az volt, hogy a K&R C-ből és a nem hivatalos bővítésekből egy egységeset alakítson ki. Belevettek azonban számos új megoldást is, mint például függvény prototípust (a C++ nyelvből) valamint egy jobban alkalmazható (fejlettebb) előfordítót (preprocessor).

ANSI C-t szinte minden fordító támogat. A legtöbb C kód, mely manapság íródott, az ANSI C-n alapul. Bármilyen program, amely a szabvány C-ben íródott, helyesen működik bármely platformon, amelyen szabványos C létezik. Vannak azonban programok, melyek csak adott platformon vagy adott fordítóval fordíthatók le, a használt nem szabvány függvénygyűjtemények miatt (például grafikus függvények) és vannak olyan fordítók, melyek nem támogatják alapértelmezésben az ANSI C szabványt.

C99[szerkesztés]

Az ANSI szabványosítási folyamatot követően, a C nyelv viszonylag állandó maradt, míg a C++ fejlődött. Új C verzió, 1995-ben az első normatív kiegészítéssel jött létre, de ezt a változatot ritkán használják.

A szabványt átdolgozták az 1990-es években és ebből lett az ISO 9899:1999 1999-ben. Ez a szabvány „C99” néven vált ismertté, majd 2000 márciusában bekerült az ANSI szabványok közé is.