*WARNING: Circo is in its infancy, not yet useful for real projects. It may seem dormant while undergoing full rewrite, as the code is splitted into different repos (mainly CircoCore, CircoCore.js and Plugins.jl).
Circo is a distributed computing platform, designed to scale to millions of nodes while providing metaphoric abstractions that help the programmer reason about such a complex system.
Circo achieves this by integrating an Actor model with a loosened Bulk synchronous parallel model into a component system that is driven by a distributed microkernel.
Components can send messages to each other, spawn new components and self-organize into a computing graph resembling a neural network. Components are "grounded" to a 3D space, their position is optimized to minimize approximated communication overhead.
Circo systems typically build themself from a single spawn and their structure responds dynamically to changes of the environment, e.g. they grow new components where load is high while unneeded components die. This dynamics can be described using a high level graph grammar.
Not much of that is available at the time, but you may feel the flavor if you check the following, working example:
# This test builds a binary tree of actors, growing a new level for every
# Start() message received by the original spawn (the TreeCreator).
# The growth of every leaf is reported back by its parent to the
# TreeCreator, which counts the nodes in the tree.
using Test
using Circo
import Circo.onmessage
GrowRequest = Message{ComponentId}
GrowResponse = Message{Vector{ComponentId}}
Start = Message{Nothing}
@component mutable struct TreeActor
children::Vector{ComponentId}
TreeActor() = new([])
end
Messages that components can send to each other are typed. The @component
macro is a simple helper to generate the required fields and mark the component as subtype of Component
.
function onmessage(me::TreeActor, message::GrowRequest, service)
if length(me.children) == 0
push!(me.children, spawn(service, TreeActor()))
push!(me.children, spawn(service, TreeActor()))
send(service, GrowResponse(me, body(message), me.children))
else
for child in me.children
send(service, redirect(message, child))
end # TODO Would be nice to allow this instead: me.children |> redirect(message) |> send(service))
end
end
Leafs and inner nodes handle GrowRequest
s differently:
- Leafs (nodes that have no children yet) grow two new leafs and report this event as a
GrowResponse
back to the address found in the body of the request. - Inner nodes forward the message to all of their children.
@component mutable struct TreeCreator
nodecount::UInt64
root::ComponentId
TreeCreator() = new(0, 0)
end
function onmessage(me::TreeCreator, ::Start, service)
if me.root == 0
me.root = spawn(service, TreeActor())
me.nodecount = 1
end
send(service, GrowRequest(me, me.root, id(me)))
end
function onmessage(me::TreeCreator, message::GrowResponse, service)
me.nodecount += length(body(message))
end
The TreeCreator
handles communication with both the user (by handling Start
messages) and the tree (by sending a single GrowRequest
to the root and receiving a GrowResponse
from every node that was a leaf before this grow).
@testset "Actor-Tree" begin
creator = TreeCreator()
machine = Machine(creator) # Create the machine and spawn creator
for i in 1:10
machine(Start()) # The Start signal will be delivered to the firstly spawned component
@test creator.nodecount == 2^(i+1)-1
end
end
The Machine
is your interface for creating and running the actor system. Its default behavior is to run synchronously until the message queue empties, so here we can grow a new level of the tree by sending a Start
message. Check the actor tests and benchmarks for more examples.