Thread Pool Example

This example demonstrates parallel log processing using Logly's thread pool.

Centralized Configuration

const logly = @import("logly");

var config = logly.Config.default();
config.threadPool = .{
    .enabled = true,
    .threadCount = 8,
    .queueSize = 2048,
    .stackSize = 1024 * 1024,
};

// Or use helper method
var config2 = logly.Config.default().withThreadPool(.{
    .threadCount = 4,
    .queueSize = 1024,
});

Source Code

//! Thread Pool Example
//!
//! Demonstrates parallel log processing with configurable thread pools.

const std = @import("std");
const logly = @import("logly");

pub fn main() !void {
    var gpa = std.heap.DebugAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // Create thread pool with 4 workers using explicit config
    const pool = try logly.ThreadPool.initWithConfig(allocator, .{
        .threadCount = 4,
        .queueSize = 1024,
        .workStealing = true,
    });
    defer pool.deinit();

    // Start workers
    try pool.start();

    // Submit tasks
    var counter: std.atomic.Value(u32) = std.atomic.Value(u32).init(0);
    const numTasks: u32 = 100;

    const TestTask = struct {
        fn increment(ctx: *anyopaque, maybeAllocator: ?std.mem.Allocator) void {
            _ = maybeAllocator;
            const c: *std.atomic.Value(u32) = @ptrCast(@alignCast(ctx));
            _ = c.fetchAdd(1, .monotonic);
        }
    };

    for (0..numTasks) |_| {
        _ = pool.submitCallback(TestTask.increment, @ptrCast(&counter));
    }

    // Wait for completion
    pool.waitAll();

    // Check results
    std.debug.print("Counter value: {d}\n", .{counter.load(.monotonic)});

    const stats = pool.getStats();
    std.debug.print("Tasks completed: {d}\n", .{
        stats.getCompleted(),
    });
}

Running the Example

zig build run-thread-pool-demo

Expected Output

Counter value: 101
Tasks completed: 101

Key Concepts

Thread Pool Configuration

.threadCount = 4,      // Number of worker threads
.queueSize = 1024,     // Queue size per thread
.workStealing = true,  // Enable work stealing
.enable_priorities = true, // Priority queues

Task Priorities

.priority = .low,      // Background tasks
.priority = .normal,   // Regular tasks
.priority = .high,     // Important tasks
.priority = .critical, // Must process first

Using Presets

// Single thread (for testing)
const single = logly.ThreadPoolPresets.singleThread();

// CPU-bound workloads
const cpu = logly.ThreadPoolPresets.cpuBound();

// I/O-bound workloads
const io = logly.ThreadPoolPresets.ioBound();

// Maximum throughput
const high = logly.ThreadPoolPresets.highThroughput();

Parallel Sink Writing

var writer = try logly.ParallelSinkWriter.init(allocator, .{
    .maxConcurrent = 4,
});

try writer.addSink(&fileSink);
try writer.addSink(&console_sink);

// Write to all sinks in parallel
try writer.write(&record);

Statistics

const stats = pool.getStats();
std.debug.print("Completed: {d}\n", .{stats.getCompleted()});
std.debug.print("Stolen: {d}\n", .{stats.getStolen()});
std.debug.print("Throughput: {d:.2}/sec\n", .{stats.throughput()});

See Also

• Thread Pool API
• Thread Pool Guide
• Async Logging Example

New Methods (v0.0.9)

var pool = try logly.ThreadPool.init(allocator, config);
defer pool.deinit();

// State methods
const empty = pool.isEmpty();
const full = pool.isFull();

// Performance metrics
const util = pool.utilization();  // 0.0 - 1.0

// Reset statistics
pool.resetStats();

Aliases

Alias	Method
flush	clear
statistics	getStats
stop	shutdown
halt	shutdown
begin	start
add	submit