Skip to main content
100%

Safe flag test (emscripten)

✓ Published0🌍 Public
Aadamscott
Last edited Jul 12, 2025
Created on Jul 11, 2025

This example demonstrates a safe-flag test for WebAssembly threads, showing atomic boolean operations across thread creation and joins. The program stores and loads a boolean with `memory_order_release` and `memory_order_acquire` semantics, printing its value from both the main thread and a spawned thread. It builds with SCons using the Emscripten toolchain, enabling pthreads via `-sUSE_PTHREADS=1` and shared memory, while the C++17 code relies on `std::atomic_bool` and `std::thread`. The visualization compiles to `index.html`, `index.js`, and `index.wasm` for browser execution.

AI-generated description

Similar vizzes

Loading thumbnail…

find a thread safety bug

This example demonstrates a subtle thread-safety bug in a C# .NET console application. Two `ThreadUnsafe` instances execute a `Go()` method concurrently across 10,000 iterations, with a shared static `_val2` flag reset after each attempt. The code uses the `lock` keyword on a `syncObj` to guard the division `_val1/_val2`, but the assignment `_val2 = 0` occurs outside the lock. The visualization—rendered via console output—shows the iteration index and an `AggregateException` when a race condition triggers an arithmetic error, revealing the unprotected write that breaks the intended synchronization.

RRestuta
56% match
Loading thumbnail…

WebAssembly integer operations

This example demonstrates a JavaScript WebAssembly module that exports integer division and echo functions, highlighting a discrepancy between WebAssembly’s spec-defined `ToWebAssemblyValue` coercion and its inverse `ToJSValue` conversion for i32 values. It uses the WebAssembly JavaScript API’s `instantiate` and `instance.exports` to call compiled wasm functions, while manually implementing the ECMA-262 `ToInt32` algorithm and a guessed JavaScript conversion. The visualization presents console output comparing wasm results against equivalent JavaScript conversions, revealing that unsigned division produces different values due to overflow handling.

CColinEberhardt
53% match
Loading thumbnail…

Shared via Rust Playground

This example demonstrates how multiple threads can safely share and mutate a counter using Rust’s concurrency primitives. It shows the `Arc<Mutex<Toaster>>` pattern, where an atomic mutex lock protects the `count` field from race conditions. The code spawns three threads via `thread::spawn`, each cloning the `Arc` handle and acquiring the lock with `toaster.lock().unwrap()` before incrementing the count. The output prints each thread’s index, which is assigned from the prior value of `count` before incrementing. The example uses the standard library’s `std::sync::{Arc, Mutex}` and `std::thread` APIs, with no external data source or rendering—purely console output.

FFranklin Chen
53% match
Loading thumbnail…

Using WebAssembly in LLVM on Windows

This example demonstrates how to compile C code to WebAssembly on Windows using LLVM's experimental WebAssembly backend, and visualizes the intermediate and final artifacts generated at each stage of the toolchain. The source code defines a Fibonacci function in C, and the visualization walks through the transformation pipeline: C source (fib.c) → LLVM bitcode (fib.bc) → LLVM assembly (fib.s) → WebAssembly text format (fib.wast) → WebAssembly binary (fib.wasm). A hex dump of the resulting .wasm file shows the compiled binary, including the memory table and the fib function export. The gist includes commands for setting up the required tools—Git, Subversion, CMake, and Visual Studio—to build the necessary LLVM/Clang, Binaryen, and Wabt toolchain on Windows, along with a compile.bat script that automates the build steps.

AAntonio24
50% match
Loading thumbnail…

Shared via Rust Playground

This example simulates a concurrent breakfast scenario using Rust's standard library. It shows how multiple attendee threads send bagels through channels to a single toaster thread, which toasts them and returns them via acknowledgment channels. The visualization highlights thread synchronization and message passing with `std::thread::spawn`, `std::sync::mpsc::channel`, and channel send/receive operations. The code prints toasting progress and final consumption messages, illustrating the choreography of concurrent tasks through inter-thread communication. No external libraries or data sources are used; the rendering is purely textual output from the console.

FFranklin Chen
48% match
Loading thumbnail…

WebAssembly transform giving support for multi return values

This example demonstrates a WebAssembly transformation that rewrites WebAssembly text (WAT) modules to support multiple return values, a feature not natively supported. The code parses an input `.wat` file using `@webassemblyjs/wast-parser`, traverses and modifies the abstract syntax tree, and prints the result with `@webassemblyjs/wast-printer`. It calculates the maximum function return count, inserts global variables, and rewrites call sites, replacing multi-value returns with `set_global` and `get_global` instructions. The transform relies on the `traverse` API to visit `Func` and `CallInstruction` nodes.

CColinEberhardt
48% match
Loading thumbnail…

Gist d0ce3de688f2a5f8a7dab8c840b24151

This example shows a minimal ARM64 assembly program that exits cleanly using the Linux syscall interface, paired with a structured template for documenting student assignments. The assembly code initializes register x0 to zero and invokes the exit syscall (93) via the `svc` instruction, while the accompanying markdown file outlines required sections like problem description, pseudocode, and compilation steps. The visualization highlights how low-level assembly interacts with the operating system through syscalls, and the template demonstrates a reproducible workflow for compiling with `as` and linking with `ld`. No external libraries or data sources are used; the focus is on the code structure and documentation format.

IIoTeacher
47% match
Loading thumbnail…

Untitled

This example demonstrates JavaScript boolean operators by evaluating and displaying the results of `(a && b)` and `(a || b)` directly in the browser. It uses the `document.write()` method to output the operand values and their combined results, with each result separated by an HTML line break. The page relies on plain JavaScript embedded in an HTML body, with no external libraries or frameworks, showcasing a minimal approach to testing logical expressions in a static web page.

Iikbb-kbj
47% match