LAgent : an agent framework in F# – Part II – Agents and control messages

Download frame­work here.

All posts are here:

• Part I - Workers and ParallelWorkers
• Part II - Agents and control messages
• Part III - Default error management
• Part IV - Custom error management
• Part V - Timeout management
• Part VI - Hot swapping of code
• Part VII - An auction framework
• Part VIII – Implementing MapReduce (user model)
• Part IX – Counting words …

Agents

Agents are en­ti­ties that process mes­sages and keep state be­tween one mes­sage and the next. As such they need to be ini­tial­ized with a lambda that takes a mes­sage and a state and re­turns a new state. In F# pseudo code: msg –> state –> new­State. For ex­am­ple the fol­low­ing:

let counter = spawnAgent (fun msg state -> state + msg) 0

This is a counter that starts from 0 and gets in­cre­mented by the value of the re­ceived mes­sage. Let’s make it print some­thing when it re­ceives a mes­sage:

let counter1 = spawnAgent
                (fun msg state -> printfn "From %i to %i" state (state + msg); state + msg) 0
counter1 <-- 3
counter1 <-- 4

Which pro­duces:

**From 0 to 3

From 3 to 7**

There is no spawn­Par­al­le­lA­gent, be­cause I could­n’t fig­ure out its us­age pat­terns. Maybe I don’t have enough cre­ativ­ity. Obviously msg and state could be of what­ever type (in real ap­pli­ca­tion they end up be­ing tu­ples more of­ten than not).

Control messages

You can do things to agents. I’m al­ways adding to them but at this stage they are:

type Command =
| Restart
| Stop
| SetManager of AsyncAgent
| SetName of string

Plus some oth­ers. I’ll de­scribe most of them later on, right now I want to talk about Restart and Stop. You use the for­mer like this:

counter1 <-- Restart
counter1 <-- 3

Which pro­duces:

From 0 to 3

This should be some­how sur­pris­ing to you. You would have thought that you could just post in­te­gers to a counter. This is not the case. You can post what­ever ob­ject. This is use­ful be­cause it al­lows to have a com­mon model for pass­ing all sort of mes­sages, it al­lows for the agent not to be pa­ra­me­ter­ized by the type of the mes­sage (and of state) so that you can store them in data struc­tures and al­lows ad­vanced sce­nar­ios (i.e. hot swap­ping of code).

This is a de­bat­able de­ci­sion. I tried to get the best of strongly typ­ing and dy­namic typ­ing, while keep­ing sim­plic­ity of us­age. The im­ple­men­ta­tion of this is kind of a mess though. We’ll get there.

BTW: you use Stop just by post­ing Stop, which stops the agent (forever).

Tags

• FSHARP

3 Comments

Comments

DotNetShoutout

2009-06-07T02:36:05Z

Thank you for sub­mit­ting this cool story - Trackback from DotNetShoutout

Nick Gunn

2009-06-12T18:21:34Z

Good mini-se­ries. I have a some code and bi­na­ries at http://​fspread.code­plex.com that shows f# agents op­er­at­ing in a dis­trib­uted en­vi­ron­ment us­ing the Spread Toolkit. The server mod­els are sim­i­lar to yours and also show load-bal­anc­ing, fault-tol­er­ance and leader-elec­tion.

Andrey

2009-06-29T07:33:36Z

Where can I down­load your li­brary?