https://github.com/zevv/actors
https://github.com/zevv/actors
Last synced: 8 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/zevv/actors
- Owner: zevv
- Created: 2022-11-19T12:57:24.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2024-04-14T14:57:44.000Z (almost 2 years ago)
- Last Synced: 2025-06-27T14:05:08.434Z (8 months ago)
- Language: Nim
- Size: 710 KB
- Stars: 30
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
This is an experimental project to create a threaded, share-nothing actor based
framework on top of CPS
This is all very much at an alpha stage; APIs are not likely to stay stable,
names of stuff might change, etc.
## Limitations
At this time, actors do not work with Nim's `orc` memory management; be sure
to compile with `--mm:arc`.
## Introduction
The Actors library provides a platform for building applications with massive
concurrency, without burdening the users with the pain and suffering of "old
school" threading primitives like locks, wait conditions, semaphores, etc.
Actors are built on two basic primitives:
- "Processes": an actor process provides a separate flow of execution. The term
"process" is not to be confused with an operating-system process; instead,
Processes are lightweight and have a small memory footprint (hundreds of
bytes), are fast to create and terminate, and the scheduling overhead is
slow. Processes are closely related to goroutines in the Go programming
language, or processes in Erlang/Elixir.
- "Messages": Every process comes with a mailbox which can be used by other
processes to send messages. Messages are Nim objects that can contain any
kind of data, and can be sent from one process to another. The current
implementation sends messages by moving the data between threads instead of
copying, and is thus fast and low overhead.
## Quickstart
This section explains the bare necessities to get started with actors. It will
briefly explain the parts and concepts of the library, and show simple examples
on how to use them.
### The pool, and your first process
The actors library has a small runtime that manages the processes and messages,
which is called a "pool"; The pool spawns a number of OS threads to do the
work, and manages and schedules the actor processes. The `hatch()` function can
now be used to create new processes; (`hatch` is analogue to the `go` statement
in Golang or `spawn` in Elixir)
```
proc hello() {.actor.} =
echo "hello"
let pool = newPool()
let pid = pool.hatch hello()
pool.join()
```
In the above example a new process is spawned ("hatched"), with `proc hello()`
as its entry point. Note that the proc is marked with the `{.actor.}` pragma.
The pool will run in the background until `join()` is called; this will wait
for all the actors to terminate and clean up all the resources used.
### Valgrind
To make the library aware of being run with helgrind, the program needs to be
built with `-d:usesValgrind`, otherwise false positives could be reported.
### More to come
Sure.
Actors communicate by sending and receiving messages; a message can be sent to
another process with the `send()` proc.
## References
References and further reading:
- https://en.wikipedia.org/wiki/Actor_model
- https://www.erlang.org/doc/reference_manual/processes.html