Hi

I'm pretty new to using MailboxProcessor in my code. I've been adding the whole message passing notion to an application. Adding MailboxProcessor to my first couple of classes worked pretty much as I expected. However when I added it to the third class I ran into a problem where the mailboxes had some inexplicable delay before they started dequeueing the messages that they had received.

My application is a simulation of a computer network and the classes represent files, disks and computers. The mailboxes on the files and disks worked as expected, and they don't send messages to other objects. However the computer class sends messages to other computers and to the disk drives.

The initialization logic looks like this:

let machineCount = 25
let gateway = new Computer(0, smallCapacity)
let network = Map.add gateway.ID gateway Map.empty
let rec computerGenerator count gw acc =
match count with
| 0 -> acc
| _ -> let newPC = new Computer(count, smallCapacity, gw)
let acc = Map.add count newPC acc
computerGenerator (count - 1) gw acc

let network = computerGenerator machineCount gateway network

let gwChildren = gateway.Children
// the application would just pause at this point for 10 to 30 seconds

When a computer was constructed with a reference to the gateway, the child computer would send an AddChild message to its gateway. All of those AddChild messages would arrive, but wouldn't be processed immediately (usually 10-30 sec wait) then the gateway would start handling adding all the child computers.

With lots of debug statements I eventually figured out that the Computer's MailboxProcessor logic wasn't getting activated at the start like I expected. But I don't really understand why? After a while I decided that I needed to jump start the processing of the MP msg queue, so I added a line to the end of the constructor which sends the GetState message to its own MailboxProcessor.

Can someone please explain what is going on, or maybe point out what I'm doing wrong here?

The Computer type definition looks like this:

type ComputerState =
{ ProcessQ: BatchedQueue.t
Parent: Option<Computer>
Disk: FileSystem
Children: Map<int, Computer> }

and Message =
| GetState of AsyncReplyChannel<ComputerState>
| AddProcess of Process
| PopProcess of AsyncReplyChannel<Option>
| AddChild of Computer
| RemoveChild of int
| SetParent of Computer
and Reply =
| State of ComputerState

and Computer(id:int, capacity, ?gateway:Computer) as this =
let id = id

let mbox = MailboxProcessor.Start(fun mbox ->
let rec loop(pcState: ComputerState) = async {
let! msg = mbox.Receive()
match msg with
| GetState chnl ->
chnl.Reply(pcState)
return! loop(pcState)
| AddProcess proc ->
return! loop({pcState with ProcessQ = BatchedQueue.snoc proc pcState.ProcessQ})
| PopProcess chnl ->
if not (BatchedQueue.isEmpty pcState.ProcessQ) then
chnl.Reply(Some(BatchedQueue.head pcState.ProcessQ))
else
chnl.Reply(None)
return! loop({pcState with ProcessQ = BatchedQueue.tail pcState.ProcessQ})
| AddChild child ->
return! loop({pcState with Children = Map.add child.ID child pcState.Children})
| RemoveChild id ->
return! loop({pcState with Children = Map.remove id pcState.Children})
| SetParent computer ->
return! loop({pcState with Parent = Some(computer)})
}

loop( {ProcessQ = Unchecked.defaultof<BatchedQueue.t>;
Parent = gateway;
Disk = new FileSystem(capacity, maxFileSize)
Children = Map.empty} ))

// The mailbox processor didn't start working properly 'till I added the line
// below to the Computer constructor, then there was no delay when
// the gateway received AddChild messages
let s = mbox.PostAndReply(GetState)

do match gateway with
| Some g -> g.AddChild this
| None -> ()

member x.GetState = mbox.PostAndReply(GetState)
member x.PrintID() = printfn "Computer ID: %d" id
member x.ID = id
member x.FileSystem = mbox.PostAndReply(GetState).Disk
member x.FileCount = mbox.PostAndReply(GetState).Disk.FileCount
member x.Gateway = mbox.PostAndReply(GetState).Parent
member x.Children =
let state = mbox.PostAndReply(GetState)
state.Children
member x.AddProcess proc = mbox.Post(AddProcess(proc))
...
member x.AddChild child =
mbox.Post(AddChild(child))

Thanks, Derek