Parallel

100%

✓ Published0🌍 Public

Last edited Nov 19, 2015

Created on Nov 19, 2015

This example shows how GNU Parallel distributes the processing of a large text file across multiple CPU cores. The visualization maps the input stream through a pipeline, highlighting the chunks that match the pattern “foo” as they are filtered by the `grep` command. The code uses the `parallel` command with `--pipe --block 2M` to split the data into 2-megabyte blocks, which are then processed concurrently. The rendering displays the block boundaries and matches in real time, using a simple custom canvas-based layout to depict the file’s contents and the parallel task execution.

AI-generated description

Similar vizzes

Loading thumbnail…

GNU parallel logo

This example replicates the GNU parallel logo using D3.js (v4). A grid of nine groups is generated with `d3.range()`, each containing 15 rectangles positioned via `translate` and `x` attributes. The rectangles alternate black and white fills with gray strokes, creating a barcode-like pattern. Below, styled `text` and `tspan` elements render the "GNU parallel" wordmark, with bold and italic segments, all within an SVG canvas. The data is procedural, derived from ranges rather than an external dataset.

PPhilippe Rivière

59% match

Loading thumbnail…

Gist 1075489a3f6f94d13b2ab76cff4c7cea

This example visualizes the asynchronous execution order of Node.js operations by logging their completion times relative to a shared start timestamp. It uses Node’s `https.request` to fetch Google’s homepage, `crypto.pbkdf2` for four CPU-intensive password hashes, and `fs.readFile` to read a local file. The console output reveals how the event loop interleaves I/O callbacks, with the network request finishing before the file read and hash computations, illustrating the non-blocking concurrency model.

Aamazingandyyy

56% match

Loading thumbnail…

simple-parallel-control-flow.js

This example demonstrates a minimal asynchronous control-flow pattern using a counter-based callback mechanism. It shows how a JavaScript function can coordinate multiple parallel tasks by decrementing a shared counter, invoking a final callback only when all tasks complete. The `doParallel` function initializes the counter and returns a closure; each call to `next()` reduces the counter, and when it reaches zero, the callback logs `"ok"` to the console. The code uses plain JavaScript with no external libraries, highlighting a simple, dependency-free approach to parallel execution.

Aalessioalex

55% match

Loading thumbnail…

Parallel Coordinates CSV Upload

This example presents an interactive parallel coordinates visualization that lets users upload a CSV file and explore multivariate datasets. It renders data as polylines across multiple vertical axes, with brushing to filter values, axis reordering via drag, and axis inversion on click. The visualization combines three stacked canvases for foreground, background, and highlighted lines with a D3.js SVG overlay for axes and labels. It uses `d3.csv.parse` for file parsing and `d3.svg.brush` for interactive filtering, with sample datasets included for cars, earthquakes, and nutrient compositions.

PPacsangon

55% match

Loading thumbnail…

Parallel execution with Azure Function PART2

This example shows a serverless Azure Function that computes a single row of a Mandelbrot set and writes it to blob storage, demonstrating parallel execution by partitioning the workload across multiple function invocations. The code uses an `IBinder` to dynamically create a blob output for each batch, with `Generate.LinearSpaced` generating the x-coordinates and LINQ’s `Select` mapping each x-value to a `MandelbrotPoint` at a fixed y-coordinate. Each function run processes one batch and serializes the resulting row as JSON via `JsonConvert.SerializeObject`, saving it as a GUID-named blob in the specified folder. The visualization implicitly relies on the aggregation of these row blobs, though the rendering itself is not shown here.

HHugoberry

55% match

Loading thumbnail…

Split large file by number of lines

This example demonstrates how to split a large file into smaller, more manageable pieces by specifying a line count. It shows the command-line utility `split` dividing a source file into multiple output files, each containing exactly one million lines. The code uses the `-l` flag to set the line limit and a prefix (`data.`) to generate sequential filenames like `data.aa`, `data.ab`, and `data.ac`. The rendering approach is purely text-based, illustrating a shell command and its expected output files.

WWilliamQLiu

54% match

Loading thumbnail…

multiprocessing

This example demonstrates a multiprocessing pipeline where eight producer processes concurrently process one hundred documents from a shared task queue, while the main process consumes and prints the results. The code uses Python's `multiprocessing` module, specifically the `Process`, `Queue`, and `join()` APIs to coordinate work and synchronization. Each producer pulls documents, simulates variable processing time with `time.sleep` and `random.uniform`, and pushes results to a separate result queue. The consumer function tracks completion until all documents are processed, illustrating a classic producer-consumer pattern with sentinel values to terminate workers.

JJastor11

54% match

Loading thumbnail…

Parallel execution with Azure Functions PART1

This example demonstrates a serverless approach to computing a Mandelbrot set in parallel using Azure Functions. It shows how an HTTP-triggered function decomposes a rendering task into discrete horizontal strips, each queued as a separate work item via `IAsyncCollector<MandelbrotBatch>`. The code uses `HttpRequestMessage` to receive a `MandelbrotSetRequest`, generates evenly spaced y-coordinates with `Generate.LinearSpaced`, and enqueues each batch with a unique output folder GUID. The function returns the folder ID to the caller, while the queue orchestrates distributed processing of each row, leveraging Azure Queues for scalable parallelism.

HHugoberry

54% match