operating-system


Difference between shared memory IPC mechanism and API/system-call invocation


I am studying about operating systems(Silberscatz, Galvin et al). My programming experiences are limited to occasional coding of exercise problems given in a programing text or an algorithm text. In other words I do not have a proper application programming or system programming experience. I think my below question is a result of a lack of experience of the above and hence a lack of context.
I am specifically studying IPC mechanisms. While reading about shared memory(SM) I couldn't imagine a real life scenario where processes communicate using SM. An inspection of processes attached to the same SM segment on my linux(ubuntu) machine(using 'ipcs' in a small shell script) is uploaded here
Most of the sharing by applications seem to be with the X deamon. From what I know , X is the process responsible for giving me my GUI. I infered that these applications(mostly applets which stay on my taskbar) share data with X about what needs to change in their appearances and displayed values. Is this a reasonable inference??
If so,
my question is, what is the difference between my applications communicating with 'X' via shared memory segments versus my applications invoking certain API's provided by 'X' and communicate to 'X' about the need to refresh their appearances?? BY difference I mean, why isn't the later approach used?
Isn't that how user processes and the kernel communicate? Application invokes a system call when it wants to, say read a file, communicating the name of the file and other related info via arguments of the system call?
Also could you provide me with examples of routinely used applications which make use of shared memory and message-passing for communication?
EDIT
I have made the question more clearer. I have formatted the edited part to be bold
The difference is that with an API you as a developer might not have access to what is happening inside these functions, so memory would not necessarily be shared.
Shared Memory is mostly a specific region of memory to which both apps can write and read from. This off course requires that access to that memory is synchronized so things don't get corrupted.
Using somebody's API does not mean you are sharing memory with them, that process will just do what you asked and perhaps return the result of that operation to you, however that doesn't necessarily go via shared memory. Although it could, it depends, as always.
The preference for one over another I'd say depends on the specifications of the particular application and what it is doing and what it needs to share. I can imagine that a big dataset of some kind or another would be shared by shared memory, but passing a file name to another app might only need an API call. However largely dependent on requirements I'd say.
First, since the X server is just another user space process, it cannot use the operating system's system call mechanism. Even when the communication is done through an API, if it is between user space processes, there will be some inter-process-communication (IPC) mechanism behind that API. Which might be shared memory, sockets, or others.
Typically shared memory is used when a lot of data is involved. Maybe there is a lot of data that multiple processes need to access, and it would be a waste of memory for each process to have its own copy. Or a lot of data needs to be communicated between processes, which would be slower if it were to be streamed, a byte at a time, through another IPC mechanism.
For graphics, it is not uncommon for a program to keep a buffer containing a pixel map of an image, a window, or even the whole screen that then needs to be regularly copied to the screen. Sometimes at a very high rate...30 times a second or more. I suspect this is why X uses shared memory when possible.

Related Links

Can't Link together GDT and the IDT
Why is there an OS segment reserved in virtual memory
What check to make in exec-missing in PINTOS
What does the kernel do while another process is running
Not able to understand fork() system call clearly?
Process termination by his parent or other processes
Using SIMD instructions in application oriented to multiple platforms and OS
Identify operating system
Do CPU and main memory need drivers to work?
Page frame number vs. Page table entry
About FAT-32 File System
Does a virtual address always translate to a physical one
How does the Virtual Memory Management System determine the backing store location in the disk?
Paged virtual address translation using a linear page table
Condition for deadlock to happen
Upating page table when an entry is evicted from TLB

Categories

HOME
php
events
svn
weblogic12c
openxml
tcsh
dry
nsview
iverilog
google-sheets-query
elk-stack
flurry
tibco
phpmqtt
stack-overflow
mailgun
global-variables
google-tasks-api
pfobject
connection-refused
amazon-sns
quantitative-finance
strophe.js
tf-idf
snap-framework
nsmutablearray
cloveretl
rails-postgresql
busboy
bluemixtools
identify
fastlane
elastica
rdp
utf
resampling
word-cloud
type-inference
react-intl
kitura
viewmodel
beeline
stateless-session-bean
instafeedjs
email-injection
oid
allegro
scheduledexecutorservice
controllers
xcode6.4
raw-sockets
declarative
perforce-integrate
qpixmap
android-syncadapter
apache-pig-grunt
odp.net-managed
jeasyui
accessibilityservice
univocity
cryptojs
perceptron
fanotify
espresso
blockquote
supercomputers
darwin
physicsjs
innerhtml
maven-shade-plugin
createfile
directorysearcher
phonegap-facebook-plugin
thoughtworks-go
image-rotation
jquery-mobile-flipswitch
communicate
hyperloglog
reference-counting
meteor-collections
xmi
django-settings
ember-table
rikulo
web-frameworks
user-forums
popup-blocker
server-name
jzmq
differentiation
asio
net-use
botnet
uipasteboard
azure-acs
fragment-identifier
regression-testing
activestate
subtext
efs

Resources

Database Users
RDBMS discuss
Database Dev&Adm
javascript
java
csharp
php
android
javascript
java
csharp
php
python
android
jquery
ruby
ios
html
Mobile App
Mobile App
Mobile App