Concepts of synchronous, asynchronous, blocking, and non-blocking

During network programming, we often see four call Methods: synchronous, asynchronous, blocking, and non-blocking. These methods are not easy to understand. The following is my understanding of these terms.
Synchronization
The so-called synchronization means that when a function call is sent, the call will not return until the result is not obtained. According to this definition, most functions are called synchronously (such as sin and isdigit ). But in general, when we talk about synchronization and Asynchronization, we are referring to the tasks that require the collaboration of other components or a certain amount of time. The most common example is sendmessage. This function sends a message to a window. This function does not return a message before the recipient finishes processing the message. After the other party completes processing, the function returns the lresult value returned by the message processing function to the caller.
Asynchronous
Asynchronous concept and synchronization relative. When an asynchronous process is called, the caller cannot obtain the result immediately. After the call is completed, the caller is notified by status, notification, and callback. Take the casycsocket class as an example (note that csocket is derived from casyncsocket, but the function has been converted from Asynchronous to synchronous). When a client sends a connection request by calling the connect function, the caller's thread can run down immediately. After the connection is established, the socket underlying layer sends a message to notify the object. The Execution Component and caller can return results in three ways: Status, notification, and callback. Which one can be used depends on the implementation of the execution part, unless the execution part provides multiple options, it is not controlled by the caller. If the execution part is notified by the status, the caller needs to check the status at intervals, which is very inefficient. (Some new programmers prefer to use a loop to check the value of a variable, this is actually a very serious error ). If you use the notification method, the efficiency is very high, because the execution of components almost do not need to do additional operations. As for the callback function, there is actually no much difference with the notification.
Blocking
Blocking call means that the current thread will be suspended before the call result is returned. The function is returned only after the result is obtained. Some people may equate blocking calls with synchronous calls. In fact, they are different. For synchronous calls, the current thread is still activated in many cases, but the current function does not return logically. For example, we call the receive function in csocket. If there is no data in the buffer zone, this function will wait until data is returned. At this time, the current thread will continue to process a variety of messages. If the main window and the calling function are in the same thread, the main interface should be refreshed unless you call the function in special interface operations. Another function Recv used by socket to receive data is an example of blocking calls. When the socket works in blocking mode, if the function is called without data, the current thread will be suspended until there is data.
Non-blocking
The concept of non-blocking corresponds to blocking, which means that the function will not block the current thread and return immediately before the result cannot be obtained immediately.
Object blocking mode and function calling
Whether the object is in blocking mode is highly correlated with whether the function is blocked or not, but it is not one-to-one. Blocking objects can have non-blocking calling methods. We can use certain APIs to poll the status and call the blocking function as appropriate to avoid blocking. For non-blocking objects, calling special functions can also be blocked. The select function is an example.

Blocking Communication

--------------------------------------------------------------------------------

Through overlapping communication and computing, high performance can be improved in many systems. An intelligent communication controller automatically executes communications. Light-heavy evidence is a mechanism to achieve such overlap. An optional mechanism that causes good performance is non-blocking communication. A blocked sending starts to call the initialization of this sending operation, but it cannot be completed. Before the message is copied from the sending cache, the call to start sending will be returned. An independent "sending completed" call is required to complete the communication, for example, to check the data copied from the sending cache. With appropriate hardware, after the sender is initialized and before it is completed, data conversion from the sender's storage can be performed simultaneously with the computation completed by the sender. Similarly, a non-blocking "receive start call" initializes the receive operation, but does not complete it. Before a message is stored in the receiving cache, this call will return. An independent "receive completed" call is required to complete the receiving operation and check the received data cached. With appropriate hardware, after receiving operation initialization and before it completes, the data stored in the receiver can be converted at the same time as the computing. The use of non-blocking reception can avoid system caching and copying from memory to memory even though information is provided earlier in the receiving cache location.

The non-blocking sending start call can use the same four modes as blocking sending: Standard, cache, synchronization, and preparation modes. These have the same meaning. No matter whether a matching recipient is logged on or not, you can start sending in all modes except "prepared". If one matching recipient is logged on, you can start sending in a non-blocking "prepared" mode. In all cases, the start call of sending is local: no matter the status of other processes, it immediately returns. If this call causes some system resources to run out, it will fail and return an error.Code. High-quality MPI implementation should ensure that this situation only occurs when it is "Diseased. That is, one MPI implementation will support a large number of pending non-blocking operations.

When the data has been copied from the sending cache, this sending completion call is returned. It can have additional meaning, depending on the sending mode.

If the sending mode is "synchronous", only one matching recipient can complete the sending. That is, a receiver has been logged on and matched with the sender. In this case, the call to the sending completion is non-local. Note: Before a call to receive completion occurs, it can be completed if a synchronous, non-blocking message matches a non-blocking message. (Once the sender "knows" the conversion will end, it will be able to complete, but before the receiver "knows" the conversion will end ).

If the sending mode is "cached" and the message is not suspended, the message must be cached. At this time, the sending completion call is local, and it must be successful regardless of the status in which a request is received.

If the sending mode is standard and the message is cached, the sending end call can be returned before a matching message is received. On the other hand, sending is complete until a matching message is received, and the message has been copied to the receiving cache.

Non-blocking sending can be matched by blocking receiving, or vice versa.

Suggestions for users. A sending operation can be delayed in standard mode, and must be delayed in the same mode until a matching user receives the login. In both cases, the use of non-blocking sending allows the sender to proceed ahead of the receiver, so that the calculation of the speed of the two processes is more tolerant of fluctuations.

Non-blocking sending in cache and readiness modes has a limited impact. One possible non-blocking message will be returned, and one blocking message will be returned after the data is copied from the sender's storage. As long as data copying can be the same as computing, the use of non-blocking transmission has advantages.

The message sending mode implies that communication is initiated by the sender. When the sender initializes the communication (data is directly moved to the receiving cache and does not need to queue a pending sending request), if the receiving has been logged in, this communication will generally have a low extra burden. However, only after a matched message has been sent can one receive operation be completed. When the non-blocking receiving waits for sending, there is no blocking receiving, and its use allows for a lower additional communication burden. (End with your suggestions ).