Vraagje over C++ keywords

left part of the evil twins

Violate.
A violate specifer is a hint to the compiler that an object may change its value in ways not specified by the language so that aggressive optimalisations must be avoided. For example a real time clock might be declared

extern const voilate clock;

Als ik zie hoe goed je het kunt spellen heb je het VOLATILE keyword nog nooit gebruikt

En nog wat toelichting:
- auto is overbodig daar het de defaultstijl voor een variabeledeclaratie is.
- mutable variabelen hebben een impliciete const_cast. Als je een const-memberfunctie hebt in een class mag deze geen membervariabelen wijzigen BEHALVE de mutables. Errug zeldzaam

- register gebruik je in parameterlijsten of lokale variabelen om ervoor te zorgen dat ze niet in het geheugen belanden maar in een CPU-register blijven indien mogelijk. In principe overbodig door moderne optimizers inderdaad.
- volatile variabelen gebruik je in principe alleen in multithreaded programmas. Het zorgt ervoor dat iedere read/write op die variabele pas op het exacte moment van uitvoeren gedaan wordt: dus geen forward optimalizations of vooruitlopende conclusies in conditionals.

Met volatile kun je bijvoorbeeld een simpel type critical section of semaphore maken (overigens geen vervanger voor dat kernelmode object daar die een stuk effectiever is en beter beschermd, maar leuk ter illustratie):

code:

class MyCriticalSection
{
public:
  MyCriticalSection(bool p_Initial = false)
    {
    m_Locked = p_Initial; 
    }
  void Lock()
    {
    while(m_Locked)
    Sleep(0);
    m_Locked = true;
    }
  void Unlock()
    {
    m_Locked = false;
    }

private:
  volatile bool   m_Locked;
};

En als laatste de union, waarvoor we even een klassieke Variant uit de kast trekken:

code:

type union
  {
  char      m_Byte;
  short      m_Short;
  long      m_Long;
  __int64      m_Big;
  } t_Variant;

Als jij nu een variabele van het type t_Variant declareert zal deze sizeof(__int64) bytes groot zijn (8 dus). Dit komt omdat binnen een union alle members op dezelfde plaats in het geheugen liggen, en de grootte van een union dus gelijk is aan die van zijn grootste member. Dit staat je toe zoals in dit voorbeeld een variabele te declareren die verschillende types data kan opslaan afhankelijk van wat je op dat moment nodig hebt. Nog een mooi voorbeeld uit Windows:

code:

typedef union _LARGE_INTEGER { 
  struct {
    DWORD LowPart; 
    LONG  HighPart; 
  };
  LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;

Dit is een 64-bits waarde die je zowel als 64-bits waarde (quadpart) of als 2 32-bits waardes aan kunt spreken. Wijzigen van de 1 wijzigt de ander.

woensdag 26 september 2001 22:45

Acties:

Verwijderd

Op woensdag 26 september 2001 22:42 schreef curry684 het volgende:
Als ik zie hoe goed je het kunt spellen heb je het VOLATILE keyword nog nooit gebruikt

Sterker nog, ik moest het opzoeken in zo'n ding van vroeger zo'n ehh.. boek?

woensdag 26 september 2001 22:56

Acties:

left part of the evil twins

Op woensdag 26 september 2001 22:45 schreef Yarvieh het volgende:
Sterker nog, ik moest het opzoeken in zo'n ding van vroeger zo'n ehh.. boek?

Volatile ken ik al wel een tijd, maar toen ik 2 maanden terug of zo mutable in een class tegenkwam moest ik ook even aan het opzoeken... wel in de online help daarentegen

woensdag 26 september 2001 23:03

Acties:

Verwijderd

Curry je hebt het draaitje vern**kt... wat kunnen anderen nu nog toevoegen

Wanneer ga je les geven?

woensdag 26 september 2001 23:15

Acties:

woensdag 26 september 2001 23:30

Moderator Devschuur®

Demotivational Speaker

[ offtopic maar wel interessant :)]

Op woensdag 26 september 2001 22:42 schreef curry684 het volgende:

[..]

Met volatile kun je bijvoorbeeld een simpel type critical section of semaphore maken (overigens geen vervanger voor dat kernelmode object daar die een stuk effectiever is en beter beschermd, maar leuk ter illustratie):
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MyCriticalSection
{
public:
  MyCriticalSection(bool p_Initial = false)
    {
    m_Locked = p_Initial; 
    }
  void Lock()
    {
    while(m_Locked)
    Sleep(0);
    m_Locked = true;
    }
  void Unlock()
    {
    m_Locked = false;
    }

private:
  volatile bool   m_Locked;
};

leuk voorbeeld (daar ik het zelf ook gebruikt heb in mijn multithreading hack voor djgpp), er is alleen iets mee.
Wat nou als er een thread permissie heeft om te locken (dus niemand anders heeft gelockt), en net als hij uit de while lus komt wordt er van thread geswitched. En dan komt er een andere thread die ook de lock wil hebben, en dat kan ook, want de lock was immers nog niet gezet. Tijdens de lock wordt er weer van thread geswitched, en die ene thread is weer aan de beurt, dus vervolgens de lock zet (terwijl die al was gezet). Je hebt dan 2 threads die de lock bezitten

Oplossing: gebruik 2 lock variabelen

code:

class Synchronization
{
private:
    volatile bool _lock1, _lock2;
public:
    Synchronization () : lock1 (false), lock2 (false) { }
    void lock ()
    {
      while (_lock1);
      _lock1 = true;
      while (_lock2);
      _lock2 = true;
      _lock1 = false;
    }

    void unlock ()
    {
      _lock2 = false;
    }
};

Er kunnen nu wel meerdere threads tegelijk tussen lock1 en lock2 zitten, maar na lock2 kunnen niet meerdere threads zijn mits de tijd tussen 2 thread switches lang genoeg is om zoveel code uit te voeren. Maar aangezien dat stukje code zo weinig is is dat altijd het geval, want wie switched er nou elke ongeveer 3 clocks van thread

Werkt dus al beter, maar er is nog een probleem: een thread moet meerdere keren de lock kunnen vragen. Als hij nou 2 keer een lock vraagt krijg je dus een deadlock: hij gaat wachten tot hij zelf de lock vrijlaat, wat dus nooit zal gebeuren. Dit is op te lossen door een count bij te houden, en in plaats van boolean locks de thread IDs te gebruiken

code:

class Synchronization
{
private:
    volatile bool _thisID, _nextID;
    volatile int _count;
public:
    Synchronization () : _thisID (-1), _nextID (-1), _count (0) { }
    void lock ()
    {
      int currentID = GetCurrentThreadID ();
      if (currentID == _thisID)
      {
        _count++;
        return;
      }

      while (_nextID != -1);
      _nextID = currentID;
      while (_thisID != -1);
      _lock2 = currentID;
      _lock1 = -1;
    }

    void unlock ()
    {
      if (_thisID == GetCurrentThreadID ())
      {
        if (--_count == 0)
            _thisID = -1;
      }
    }
};

Maar ja, zoals je ook al opmerkte, je kunt je beter houden aan de kernel API die daarin is gespecializeerd

[/offtopic]

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

left part of the evil twins

Op woensdag 26 september 2001 23:03 schreef mgfun het volgende:
Curry je hebt het draaitje vern**kt... wat kunnen anderen nu nog toevoegen

Een benchmark?

Wanneer ga je les geven?

Zodra leraren ook leaseauto's, optieregelingen e.d. krijgen?

woensdag 26 september 2001 23:33

Acties:

marcusk

Met volatile kun je bijvoorbeeld een simpel type critical section of semaphore maken (overigens geen vervanger voor dat kernelmode object daar die een stuk effectiever is en beter beschermd, maar leuk ter illustratie):

[miereneukmode >:)]
time critical section bedoel je zeker ?

[/miereneukmode >:)]

woensdag 26 september 2001 23:36

Acties:

left part of the evil twins

Op woensdag 26 september 2001 23:15 schreef OiSyN het volgende:
[offtopic maar wel interessant :)]
...

Je vergeet ook nog dat we hier niet aan queueing doen: als thread 1 de lock heeft, en thread 2 vraagt daarna, en thread 3 DAARNA, is het vrijwel random of thread 2 of 3 de lock krijgt zodra 1 unlockt

Zullen we hier een nieuwe topic over opzetten?

woensdag 26 september 2001 23:37

Acties:

farlane

volatile wordt nog wel eens gebruikt in (besturings?) software waar bijvoorbeeld via DP RAM met een extern proces wordt gecommuniceerd. (positioneringskaart bijvoorbeeld)

Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.

woensdag 26 september 2001 23:38

Acties:

left part of the evil twins

Op woensdag 26 september 2001 23:33 schreef marcusk het volgende:
[miereneukmode >:)]
time critical section bedoel je zeker ?
[/miereneukmode >:)]

Nee

Lees de zin nog maar een keer, en je moet het lezen als 'ik heb een mooi type auto gezien'.

woensdag 26 september 2001 23:40

Acties:

marcusk

Op woensdag 26 september 2001 23:38 schreef curry684 het volgende:

[..]

Nee

Lees de zin nog maar een keer, en je moet het lezen als 'ik heb een mooi type auto gezien'.

smoesjes

woensdag 26 september 2001 23:41

Acties:

left part of the evil twins

Op woensdag 26 september 2001 23:37 schreef farlane het volgende:
volatile wordt nog wel eens gebruikt in (besturings?) software waar bijvoorbeeld via DP RAM met een extern proces wordt gecommuniceerd. (positioneringskaart bijvoorbeeld)

Het is ook handig voor reference counts e.d. Een int of bool weet je van dat de CPU 'm in 1 instructie kan testen/ophogen, dus in principe hoef je voor multithreaded access op een atomair type zoals dit geen synchronization object te gebruiken als je 'm volatile maakt.

woensdag 26 september 2001 23:49

Acties:

left part of the evil twins

Zit net even wat documentatie in VS.net door te lezen, en zie dat je memberfunctions niet alleen const maar ook volatile mag maken, bijv.:

code:

class MyClass
{
public:
  void      ConstFunction() const;
  void      VolatileFunction() volatile;
};

Net zoals de eerste functie ervoor zorgt dat je binnen die functie context met een this-variabele van het type

code:

1	MyClass* const this

werkt heb je in het tweede geval te maken met

code:

1	MyClass* volatile this

Het resultaat:

volatile
Member data is loaded from memory each time it is accessed; disables certain optimizations.

Toch leuk om erbij te weten

woensdag 26 september 2001 23:51

Acties:

woensdag 26 september 2001 23:53

Moderator Devschuur®

Demotivational Speaker

Op woensdag 26 september 2001 23:36 schreef curry684 het volgende:

[..]

Je vergeet ook nog dat we hier niet aan queueing doen: als thread 1 de lock heeft, en thread 2 vraagt daarna, en thread 3 DAARNA, is het vrijwel random of thread 2 of 3 de lock krijgt zodra 1 unlockt

Zullen we hier een nieuwe topic over opzetten?

niet als ze steeds omstebeurt aan de beurt zijn, dan gaat het queueen gewoon automatisch omdat je met 2 locks werkt

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

woensdag 26 september 2001 23:54

Moderator Devschuur®

Demotivational Speaker

Op woensdag 26 september 2001 23:41 schreef curry684 het volgende:

[..]

Het is ook handig voor reference counts e.d. Een int of bool weet je van dat de CPU 'm in 1 instructie kan testen/ophogen, dus in principe hoef je voor multithreaded access op een atomair type zoals dit geen synchronization object te gebruiken als je 'm volatile maakt.

bij een CISC processor zoals de x86 ja

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties: