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 how to use synchronization in Julia to run disk reads in parallel while preserving order, showing proper placement of @sync and fetch inside for loops to achieve speedups.

Explore how atomic data types and atomic add prevent race conditions in parallel summations, and note that these operations can be slow, suggesting final synchronization when possible.

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.

Use thread-based parallelism in julia to divide a matrix into submatrices with spawn, pass the local indices to a kernel, and join per-chunk results lock-free for comparison with sequential version.

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.

Use Julia's distributed package to prototype on a notebook, add and manage workers, configure topology, and control threads and OpenBLAS or Intel MKL for linear algebra.

Learn to run functions in a Julia distributed environment with the @everywhere macro, use pmap for parallel mapping across workers, and combine results with reduce, cat, or sum.

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 distributed computing and multi-threading in Julia on a 16-core machine using the distributed and chunk splitters packages. Adopt a target-sum parallel subset approach.

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.

Learn to index and write to distributed arrays in Julia by using the local part and proper local range, ensuring correct access across multiple workers and blocks.

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.

Explore how to spawn forever-running worker processes and use channels and remote services to distribute work unevenly in Julia pipelines, with testing data between local and worker nodes.

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.

Set up a five-process pipeline in Julia using remote services and channels (rc1, rc2) to run Pmap on positive and negative numbers, with start, end, and result messages.