nonblocking | Nonblocking data structures | Dataset library

There is currently nothing built in for this in Reactor.

The solution in that other answer can probably be updated to Sinks.Many new API, it appears the associated project has indeed been updated: https://github.com/alex-pumpkin/reactor-lock

You could also use https://github.com/reactor/reactor-pool but that would be a bit overkill.

Looking at the setup.py, it looks like the package just doesn't support Windows. All those os.system() calls are POSIX-only.

The pts was created when a virtual terminal was attached to the system (usually ssh). The pts was connected as stdin/stdout for a shell which was started for the connection, therefore you already have a process attached to the pts and reading from it.

Once you attach your application, you effectively start a race between both processes (your application and the shell), so whoever is faster will receive the content of the buffer. The character had not remained in the buffer of the pts, rather it was read by the shell attached to the pts.

To be able to read without interruption from the attached process, you need to intercept the buffer of the pts by informing the master multiplexer ptmx, see more in ptmx(4). You can study how it's done in the interceptty

It's undefined behaviour to end the lifetime of a non-trivial object without calling it's destructor, which happens as soon as there is a second call_async invocation.

"heap-allocation related overhead" is a misnomer if the only alternative is undefined behaviour. The future returned by async has to live somewhere.

The updated code has defined behaviour: it waits for the previous invocation to be done before launching the next one.

I know that None-blocking communication is not blocking the code, such as MPI_Isend will send the data immediately.

This is not accurate the data is not send immediately. Let me explain in more detail:

MPI_Irecv and MPI_Isend are nonblocking communication routines, therefore one needs to use the MPI_Wait (or use MPI_Test to test for the completion of the request) to ensure that the message is completed, and that the data in the send/receive buffer can be again safely manipulated.

The nonblocking here means one does not wait for the data to be read and sent; rather the data is immediately made available to be read and sent. That does not imply, however, that the data is immediately sent. If it were, there would not be a need to call MPI_Wait.

But when we have some all-to-all communication and we need to read this data we need to use MPI_Wait to get the data first.

You need to call MPI_Wait (or MPI_Test) in call communication types 1 to 1, 1 to n, and so on not just in all-to-all. Calling MPI_Wait is not about getting the data first, but rather that during the MPI_Isend the content of the buffer (e.g., the array of ints) has to be read and sent; In the meantime, one can overlap some computation with the ongoing process, however this computation cannot change (or read) the contend of the send/recv buffer. Then one calls the MPI_Wait to ensure that from that point onwards the data send/recv can be safely read/modified without any issues.

I want to use two times MPI_Isend and MPI_Irecv in each iteration loop to overlap some the computation from the first receiving data and meanwhile do another send and receive, but this approach needs 4 waiting, Is there any algorithm for overlapping the nonblocking communications?

Whenever possible just use in build communication routines they are likely more optimized than one would able to optimized. What you have described fits perfectly the MPI routine MPI_Ialltoall:

Sends data from all to all processes in a nonblocking way

> Is a DispatcherTimer ok for WaitForSlotEvent?

It should be OK in general. You might also consider using WaitForSlotEvent in blocking mode called from a separate thread.

> What should I do to avoid C_WaitForSlotEvent CKR_DEVICE_ERROR?

You need to ask the vendor of your unmanaged PKCS#11 library.

AFAIK C_WaitForSlotEvent was designed for token/card related events not for slot/reader related events. PKCS#11 specification states that when you add or remove slot/reader you might need to reload PKCS#11 library or even restart OS:

On some platforms, or earlier PKCS11 compliant libraries, it may be necessary to successfully call C_Initialize or to restart the entire system.

> Does pkcs11Interop handle the adding and removing of slots (ie. SmartCard Readers)?

Pkcs11Interop does nothing else but gives you access to unmanaged function C_WaitForSlotEvent described in PKCS#11 specification.

> If pkcs11Interop does not handle adding and removing slots is polling the only way and what would be the best to poll?

See answer to first question.

This is rather theoretical question. If sockets I/O (either read or write) is set to O_NONBLOCK, but then this socket is set in fd_set to select() which blocks (waiting for an event the file descriptor become either readable or writable), then that socket is blocking anyway (due to the select())?

The select is blocking. The socket is still non-blocking.

Why would I set the socket to be non-blocking, when even the blocking (default) version once become readable (or writable) (thanks to select()), won't block, because the select() said it has data to read (or write) and thus the socket is able to perform its operation with that data without blocking.

No, no, no! That is not a safe assumption. There is no guarantee that a subsequent read or write will not block. You must set the socket non-blocking if you need a future guarantee that a later operation will not block.

So why to bother setting socket non-blocking when select() blocks anyway?

Because you don't want operations on the socket to block. The select function does not guarantee that a future operation won't block and people have gotten burnt by making that assumption in the past.

For example, you do select on a UDP socket and it says that a receive won't block. But before you call recv, the administrator enables UDP checksums which were previously disabled. Guess what, now your recv will block if the checksum was incorrect on the only received datagram.

Unless you think you could have foreseen every way something like that could happen, and you definitely can't, you must set the socket non-blocking if you do not wish it to block.

Here's what I ended up doing. I don't know if it makes sense or not, but it does get rid of the warnings. I really wish they'd fix the documentation. The example script doesn't work properly.

mysql_free_result needs to occur for (sqlRes) && !(numRows)