SharedArray | Zero-copy sharing between managed and native arrays in Unity | Game Engine library

You are missing a barrier between the submission of the queue and the for loop in the host code.

Although it is true that an USM shared memory allocation is visible on the host and the device, there is no guarantees that the command group you have submitted to the queue will execute before the for loop in the host: Submissions to queues execute asynchronously w.r.t to the calling thread. Updated code below:

use Promise.all like this

As the comments note, this looks like perhaps more of a job for multithreading than multiprocessing. The best approach in detail will generally depend on whether you are CPU-bound or memory-bandwith-bound. With so simple a calculation as in the example, it may well be the latter, in which case you will reach a point of diminishing returns from adding additional threads, and and may want to turn to something featuring explicit memory modelling, and/or to GPUs.

However, one very easy general-purpose approach would be to use the multithreading built-in to LoopVectorization.jl

As pointed out by adamslc on the Julia discourse, the proper way to use Julia on a cluster is to either

• Start a session with one core from the job script, add more with addprocs() in the Julia script itself
• Use more specialized Julia packages

https://discourse.julialang.org/t/julia-distributed-redundant-iterations-appearing/57682/3

Here is a code after cleanup that works. Basically, the main problem is how the @distributed macro was trying to move the Python module around the cluster (it seems it does not know it is a library). So I packed it into a function which is always called locally at each given worker process (no risk of copying).

I assume that all your workers are on a single server and that you have actually added some workers using the addprocs command. The first problem with your code is that you create the SharedArray on all workers. Rather than that the syntax of a SharedArray is the following:

Per code, main.js represents Main process of Electron and filaA.js is for Renderer process. Since those 2 are different process, there is no way to share same object reference across processes: you should use IPC to ask one process's value if you want to achieve singleton across process.

SharedArrays works only within a single cluster node. In other words this is used to share RAM memory between processes running on the same server. When you add another server obviously you will not see that memory.

What you should do is to use DistributedArrays.jl instead:

There are the following problems in your code:

• You are spawning a remote task for each value of i a and this is just expensive and in the end it takes long. Basically the rule of thumb is to use @distributed macro for your load balancing across workers this will just evenly share the work.
• Never put addprocs inside your work function because every time you run it, every time you add new processes - spawning a new Julia process also takes lots of time and this was included in your measurements. In practice this means you want to run addprocs at some part of the script that performs the initialization or perhaps the processes are added via starting the julia process with -p or --machine-file parameter
• Finally, always run @time always twice - in the first measurement @time is also measuring compilation times and the compilation in a distributed environment takes much longer than in a single process.

Your function should look more or less like this