Modelo de memória

[editar] Byte

[editar] Endereçamento de memória

• um objeto do tipo scalar (tipo aritmético, tipo ponteiro, tipo enumerado, ou std::nullptr_t)

  Original:

  an object of scalar type (arithmetic type, pointer type, enumeration type, or std::nullptr_t)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• ou a maior sequência contínua de campo de bits de tamanho diferente de zero

  Original:

  or the largest contiguous sequence of bit fields of non-zero length

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

struct S {
    char a;     // memory location #1
    int b : 5;  // memory location #2
    int c : 11, // memory location #2 (continued)
          : 0,
        d : 8;  // memory location #3
    struct {
        int ee : 8; // memory location #4
    } e;
} obj; // The object 'obj' consists of 4 separate memory locations

[editar] Threads e condições de corrida

• ambas as avaliações executem na mesma thread ou no mesmo signal handler, ou

  Original:

  both evaluations execute on the same thread or in the same signal handler, or

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• ambas as avaliações conflitantes sejam operações atômicas (veja std::atomic), ou

  Original:

  both conflicting evaluations are atomic operations (see std::atomic), or

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• uma das avaliações conflitantes ocorra-antes (see std::memory_order)

  Original:

  one of the conflicting evaluations happens-before another (see std::memory_order)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

(

int cnt = 0;
auto f = [&]{cnt++;};
std::thread t1{f}, t2{f}, t3{f}; // undefined behavior

std::atomic<int> cnt{0};
auto f = [&]{cnt++;};
std::thread t1{f}, t2{f}, t3{f}; // OK

[editar] Ordem de memória

[editar] Forward progress

[editar] Obstruction freedom

When only one thread that is not blocked in a standard library function executes an atomic function that is lock-free, that execution is guaranteed to complete (all standard library lock-free operations are obstruction-free)

[editar] Lock freedom

When one or more lock-free atomic functions run concurrently, at least one of them is guaranteed to complete (all standard library lock-free operations are lock-free -- it is the job of the implementation to ensure they cannot be live-locked indefinitely by other threads, such as by continuously stealing the cache line)

[editar] Progress guarantee

In a valid C++ program, every thread eventually does one of the following:

• terminate
• makes a call to an I/O library function
• performs an access through a volatile glvalue
• performs an atomic operation or a synchronization operation

No thread of execution can execute forever without performing any of these observable behaviors.

Note that it means that a program with endless recursion or endless loop (whether implemented as a for-statement or by looping goto or otherwise) has undefined behavior. This allows the compilers to remove all loops that have no observable behavior, without having to prove that they would eventually terminate.

A thread is said to make progress if it performs one of the execution steps above (I/O, volatile, atomic, or synchronization), blocks in a standard library function, or calls an atomic lock-free function that does not complete because of a non-blocked concurrent thread.

[editar] See also