According to the OpenMP web site OpenMp is “the de-facto standard for parallel programming on shared memory systems” According to Wikipedia “Using memory for communication inside a single program, for example among its multiple threads, is generally not referred to as shared memory.”
What is wrong here ? Is it the “generally” term ?
OpenMp is really just creating threads “sharing memory” through a single same virtual adress space, isn’t it ?
Moreover, I guess OpenMP is able to run on NUMA architectures where all the memory can be addressed by all the processors, but with some increased memory access time when threads sharing data, are assigned to cores accessing to different memories at different access time. Is this true ?
I’m redacting a full-fledged answer here to try to answer further questions asked as comments to lucas1024’s answer.
On the meaning of “shared memory”
On the one hand, you have the software-oriented (i.e. OS-oriented) meaning of shared-memory: a way to enable different processes to access the same chunk of memory (i.e. to relax the usual OS constraint that a given process should not be able to tamper with other processes’ memory). As stated in the wikipedia page, the POSIX shared memory API is one implementation of such a facility. In this acception, it does not make much sense to speak of threads (an OS might well provide shared memory without even providing threads).
On the other hand, you have the hardware-oriented meaning of “shared-memory”: an hardware configuration where all CPUs have access to the same piece of RAM.
On the meaning of “thread”
Now we have to disambiguate another term: “thread”. An OS might provide a way to have multiple concurrent execution flows within a process. POSIX threads are an implementation of such a feature.
However, the OpenMP specification has its own definitions:
Such definitions fit nicely with the definition of e.g. POSIX threads, and most OpenMP implementations indeed use POSIX threads to create OpenMP threads. But you might imagine OpenMP implementations on top of OSes which do not provide POSIX threads or equivalent features. Such OpenMP implementations would have to internally manage execution flows, which is difficult enough but entirely doable. Alternatively, they might map OpenMP threads to OS processes and use some kind of “shared memory” feature (in the OS sense) to enable them sharing memory (though I don’t know of any OpenMP implementation doing this).
In the end, the only constraint you have for an OpenMP implementation is that all CPUs should have a way to share access to the same central memory. That is to say OpenMP programs should run on “shared memory” systems in the hardware sense. However, OpenMP threads do not necessarily have to be POSIX threads of the same OS process.