Parallel Computing in Julia

Explore Julia's native multithreading features and language primitives on a single node, and examine ecosystem packages to parallelize apps while understanding that threading is not a silver bullet for performance.

Practice practical multithreading in Julia using @threads to parallelize a for loop. Verify parallelism by showing thread IDs and structure safe kernels that don’t rely on thread id.

Learn to control threads in Julia by spawning tasks with begin and end blocks, building a non-blocking workflow, and synchronizing with at_sync while fetching results for timing in parallel loops.

Explore atomic operations and locks to protect critical sections, prevent race conditions when appending to a shared array, and compare lock performance with sequential code in parallel Julia.

Learn how channels coordinate threads in Julia, sending with put and receiving with take, using is ready checks and open and close operations for safe inter-thread communication.

Limit threads to two to four and assign each thread a chunk of the matrix, running sequential code inside, while managing global indices and local ranges with chunk splitters.

Explore parallel execution in julia by using the thread x map to simplify code, avoid locks, and run sequential logic in parallel for different atom counts.

Learn to parallelize an edge-detection algorithm in Julia by comparing a pixel's average rgb intensity with its left and bottom neighbors, producing a black-and-white edge map.

Parallelize a nested-loop image processing task in Julia with the parallel stencil package. Run on CUDA or CPU threads, convert to float32, and use in-place, parallel macros for speed.

Gain fine control over Julia parallelism beyond pmap by spawning processes with the distributed package, using spawn at, futures, and fetch, or remote call fetch with workers.

Explore distributing and multi-threading concepts by solving the subset problem with binary indices and item selections, and parallelize across computers and threads to enumerate all subsets.

Explore shared memory with SharedArrays to let multiple processes on a single machine work on different blocks of a matrix, using continuous memory and proper data types, with synchronization considerations.

Explore parallel k-means in Julia by distributing data across nodes, computing local centroids, and averaging results to converge, using shared arrays and inter-node broadcasting.

Explore parallel k-means in Julia using shared arrays, local indices, and argmin for nearest-centroid assignment across distributed workers; compare map, MapReduce, and p MapReduce approaches.

Explore distributing arrays across multiple nodes with Julia's distributed package, configuring row- or column-block divisions, and distributing problem parameters to minimize inter-node communication.

Explore a distributed array digging algorithm that uses local indices to excavate along three paths in a matrix, respecting boundaries and random starts, then visualize with sparse arrays.

Explore uneven work distribution using remote channels and a worker pool in Julia, building input and output channels, Pmap scheduling, and async synchronization across distributed processes.

Create a Julia pipeline using remote channels to move data from a main node to three processes and onward to a final stage in a production line.