Message-Passing | NAME Message : :Passing - a simple way

I am using Argo and have a question about the workflow of workflows example. (https://github.com/argoproj/argo-workflows/blob/master/examples/workflow-of-workflows.yaml)

UPDATED YET AGAIN

As pointed out below, it is a task that I need to view. So my question is now - How do I view the logs from a task?

My workflow completes without error, but does not produce the expected output. I would like to look at the logs of one of the containers within one of the workflows within the overall workflow, but I cannot get the syntax right I am using the following convention to get the logs from the relevant pod.

I'm working with dbus in haskell, and I'm having difficulties figuring out how to export dbus methods that perform stateful operations. Below is a fully fleshed out example to illustrate where I'm stuck.

Let's say you're writing a counter service with dbus. When the service starts, the counter is initially at 0. The service defines a dbus API that exposes a count method, which returns the current value of the counter, and an update method, which increments that counter, and returns the new value.

Here's a pseudocodey implementation of the behavior I just described, using a message-passing-style of communication:

Suppose I have a bunch of same-origin windows or tabs A, B, C, D, and E, that don't hold references to each other. (e.g. a user opened them independently). Suppose A sends a BroadcastChannel message to the others, and as a result, D needs to send some data back to A, ideally without involving B, C, or E.

Is this possible, using any of the message-passing APIs?

There's an event.source property on the broadcast message event, which looked as if it should maybe contain a WindowProxy or MessagePort object in this context, but (in my tests with Firefox 78 at least) it was simply null. There's also a ports array, but that was empty.

...I'm aware that you could start up a SharedWorker to assign each window a unique ID and act as a waystation for passing messages between them, but (a) that seems very complicated for the functionality desired, and (b) every message sent that way is going to need 2 hops, from window to sharedWorker and back to a window, crossing thread boundaries both times, and (usually) getting serialized & unserialized both times as well - even when the two windows share the same javascript thread! So it's not very efficient.

This seems like such an obvious thing to want to do, I'm finding it hard to believe there isn't something obvious I'm missing... but I don't see it, if so!

I'm working in Fortran 90 with the latest stable version of MPICH (3.3)

I want to have an MPI_Window expose an array on the root process, and all other processes in the communicator call MPI_Get to copy the array into their own "local" copy.

Unfortunately, providing MPI_BOTTOM as the "base" argument in the non-root processes for MPI_Win_create(base, ...) results in the error

MPI_Win_create(192): MPI_Win_create(base=(nil), size=0, disp_unit=1275069467, MPI_INFO_NULL, MPI_COMM_WORLD, win=0x7ffcb343d9fc) failed

MPI_Win_create(156): Null pointer in parameter NULL base pointer is invalid when size is nonzero

I've been working off a textbook example, pg. 61 Fig 3.2, Using Advanced MPI, Modern Features of the Message-Passing Interface, Gropp, Hoefler, Thakur, Lusk.

What is the alternative kind(MPI_ADDRESS_KIND) that I'm supposed to use besides MPI_BOTTOM? Is this the correct way to initialize an MPI_Window on a process which isn't actually exposing it's internal memory, just accessing that of another process?

Obviously, changing the argument for base to an already allocated (non-null) array works, but this changes the behavior of the later GET so it doesn't work (creates an invalid memory access).

I don't know why the runtime error specifically says that a null base pointer is invalid with nonzero size, since I'm clearly specifying the size as 0 in the call to mpi_win_create(MPI_BOTTOM, 0, MPI_INTEGER, ...).

Here's all the code I have for this example for myself. It sets up the buffers and attempts to create the windows for each process. There is a commented out section between two calls to MPI_Fence that is the section where all non-root processes attempt the GET.

I am trying to test a code from MPI shared memory example from stackoverflow (MPI-3 Shared Memory for Array Struct). Here I will post the whole code for as a minimum reproducible example.

I'm having difficulty with a particularly spooky-looking TensorFlow issue. (TensorFlow 1.4.1 and Python 2.7)

I'm seeing a couple different errors when running the same program. Here is an example of one:

I am writing a GUI application using the Immediate Mode GUI pattern, and the UI runs on a thread separate to the engine that powers the actual functionality of the application. The GUI thread ends up iterating over many lists of objects that are conceptually "owned" by the engine thread, and these lists change extremely infrequently. The GUI thread is vsync'ed, meaning it runs at about 60Hz, and the engine thread runs at about 200Hz.

Sometimes, actions in the UI will change the contents of the collections in the engine, and I have a message-passing system to post Runnables to the engine thread to do these mutations to ensure that these mutations don't collide with what's happening in the engine. That way, I can ensure that the engine always sees a consistent view of the data, which for my application is very important.

Because the engine is in charge of all data mutations, though, it sometimes happens that the engine changes the contents of a collection while the GUI is iterating through it, and because these collections are standard Java collections, this predictably and correctly throws a ConcurrentModificationException. I can think of a few high-level ways to deal with this:

1. locking, either by using a synchronized collection or read-write locks
2. double-buffer the data that the GUI thread reads, and have the GUI thread flip the double-buffer when it's done drawing a frame
3. ignore the CME and abort drawing the rest of the frame, which will draw partial information for the frame in which the "bad" mutation happens, and just continue on to the next frame

Locking comes with a significant performance penalty, and while it would be fine for the GUI to sometimes stall while waiting to acquire the lock from the engine thread, it is very important for the engine thread to run at a consistent speed, and even an R/W lock would cause stalls in the engine thread. Double-buffering comes with significant complexity, as there is a lot of data that is read by the GUI on each frame.

I give you all of this background because I know that option 3 is ugly, and that my question is in some sense "not the right question". The Javadoc for ConcurrentModificationException even says:

Note that fail-fast behavior cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast operations throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.

But! I am not concerned with the correctness of the GUI for the single frame that would be marred by the CME. I am only concerned with what happens on the next frame. Which leads to my question: is it safe to continue using a Java collection (I'm most interested in the answer for ArrayList and HashMap) after a ConcurrentModificationException has been thrown from its iterator? It seems logical that it would be, but I can't find a piece of documentation that says that the object will still be in a usable state after the CME is thrown. Obviously the iterator is toast at that point, but I'd like to swallow the exception and continue using the collection.

I am currently attempting to create a message-passing library, and one of the tenets of message-passing is that mutable state is only modified through messages. The 'messages' that will be passed around are function objects that take a 'sender' (that created the message) and a 'receiver' (the worker/actor/what have you processing the message from it's queue.)

Workers are defined as follows, and the self-referential nature of the interface is used because a worker may have state that it wants to expose to message senders, and this requires a sender to be aware of it's unique type.

So in Ada programming language a rendezvous is a method of inter-process synchronization/message-passing. How do I implement this mechanism in java (along with task suspending and selective wait)? I was looking at java's remote method invocation and Exchanger class but I'm yet to find a suitable solution.