How does luaproc compare to Lua coroutines for concurrency?

Luaproc enables true parallel execution using system threads, while Lua coroutines are cooperative and single-threaded. This makes luaproc better for CPU-bound parallelism but adds complexity with message passing and no shared data.

How to send complex data like tables in luaproc?

Complex types must be encoded, such as by converting to strings using Lua code. The README suggests using strings of Lua code that when executed return the type, which requires additional serialization steps.

Is luaproc suitable for building high-concurrency web servers?

It can be used, but synchronous message passing might not scale well for I/O-bound tasks. Other Lua libraries with asynchronous I/O or event-driven models might be more efficient for web servers.

How to dynamically scale worker threads in luaproc?

Use luaproc.setnumworkers(int) to adjust the number of active pthreads. This allows scaling based on workload, but you must manage it manually to avoid resource exhaustion or underutilization.

What happens if a channel is destroyed while processes are waiting?

Processes waiting on destroyed channels are resumed and receive an error message, as per luaproc.delchannel. This requires error handling in your code to prevent crashes or undefined behavior.

Can luaproc be used with LuaJIT for better performance?

Luaproc is compatible with Lua 5.1-5.3; LuaJIT is based on 5.1, so it likely works, but the README doesn't specify optimizations or benchmarks, so performance may vary.

Open-Awesome

luaproc

NOASSERTIONC1.0-4

A concurrent programming library for Lua that enables parallel execution of Lua processes using message passing and POSIX threads.

GitHub

130 stars27 forks0 contributors

What is luaproc?

luaproc is a concurrent programming library for Lua that enables parallel execution of Lua code through Lua processes and message passing. It solves the limitation of Lua's native coroutines, which cannot run in parallel, by using system threads (workers) and communication channels for inter-process communication.

Target Audience

Lua developers and researchers needing parallel processing capabilities in Lua applications, such as those building concurrent systems, simulations, or performance-sensitive scripts.

Value Proposition

Developers choose luaproc because it provides a lightweight, message-passing concurrency model for Lua without shared data, reducing common concurrency issues like race conditions, while maintaining compatibility across Lua 5.1 to 5.3.

Overview

luaproc is a concurrent programming library for Lua

Use Cases

Best For

Adding parallel processing to Lua scripts that require performance improvements
Implementing concurrent simulations or models in Lua using message passing
Building actor-model systems in Lua with isolated processes
Researching concurrency patterns in Lua with POSIX thread integration
Extending Lua applications with true multithreading capabilities
Creating educational examples of concurrent programming in Lua

Not Ideal For

Applications requiring shared memory concurrency for high-speed data exchange
Real-time systems where process suspension during message passing causes unacceptable latency
Simple Lua scripts without parallelism needs, to avoid added complexity
Non-POSIX environments, as it relies on pthreads for system threads

Pros & Cons

Pros

True Parallel Execution

Uses POSIX threads to run Lua processes in parallel, overcoming Lua's native coroutine limitation that prevents parallel execution, as stated in the introduction.

Safe Message Passing

Implements the actor model with channels for communication, avoiding shared data and reducing race conditions, promoting safer concurrency as per the philosophy section.

Performance Optimization

Offers process recycling to reuse Lua states from finished processes, improving performance by reducing overhead, detailed in the recycling facility description.

Dynamic Resource Control

Allows adjustment of active worker threads via setnumworkers, enabling management of system resource usage based on load, as described in the API.

Cons

Limited Message Data Types

Only atomic Lua values (strings, numbers, booleans, nil) can be sent directly; complex types require encoding, adding overhead and complexity, as admitted in the message passing section.

Synchronous Send Bottlenecks

Sends are always synchronous, blocking processes until received, which can lead to performance issues and deadlocks if not carefully designed, per the API for luaproc.send.

Manual Channel Management

Channels must be explicitly created and destroyed, increasing boilerplate code and risk of errors like using destroyed channels, as noted in the channel management functions.

Frequently Asked Questions

Related Projects

lanes

Lanes is a lightweight, native, lazy evaluating multithreading library for Lua 5.1 to 5.5.

Stars536

Forks99

Last commit4 months ago

ConcurrentLua

Concurrency oriented programming in Lua

Stars162

Forks12

Last commit11 years ago

Lumen

Lua Multitasking Environment.

Stars161

Forks23

Last commit9 months ago

llthreads

Low-Level threads(pthreads or WIN32 threads) for Lua.

Stars150

Forks35

Last commit1 year ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub