scala - Howto design a clock driven multi-agent simulation -

I want to make a multi-agent simulation model for the actual word creation process to evaluate some transmission rules. Simulation requires event logs to evaluate the time effect of dispatching rules compared to real creation event logs.

How can I include the 'current simulation time' in a multi-agent such message is going through deep simulation? Background:
The simulation of classical discrete phenomena (which handles time-progress well) can not be applied here, because the agent in the system represents relatively complex behavior and routing. As well as requirements for dispatching rules, they often need to be communicated, and this and other process complications exclude a centralized scheduling approach.

In manufacturing science, there are thousands of papers using multi-agent simulation to solve some manufacturing related problems. However, I have not yet found any paper that describes the internal workings or implementation details of these simulations in the required work.

Unfortunately, the process time limit is between 0.1s and 24 hours, as it is not possible to use at least the process time to move the system in discrete time. There is a possibility that my simulation will be used later to evaluate in a project so that simulations need to run as soon as possible - there is no option to run overnight simulation.

The size of the problem is about 500 resources and 1000 - 10000 product agents, most of them have ended and are not participating in any other communication or resource business.

As a result, the resulting new incidents can trigger an agent to do something before its original 'next time' event. For example, an agent is currently blocked on an hourly resource. However, another high priority agent needs an urgent need of that resource and the fist asks the agent to leave that resource.

In some sense, I want to send a classical message agent-simulation and a discrete hybrid. Event simulation.

I have regarded as an intermediary agent that is included in every message - a message router and time applicant who sends messages and timer around tick incidents, as well as the mediator agent keeps a list of next event bar for different agents. is. However, I think that should be a better way to solve my problem because the concept puts tremendous pressure on the arbitrator agent.

Update

A while, but it seems that I managed to create a mini framework and added the concept of DES and agent in one. I am sure that nothing is new to it but at least unique: if you are interested.

If it implies the parallel discrete-event simulation - you implement the arbitrator agent Is planning a discrete-incident simulator to be faced by using ('Every message contains', 'Messages and timers send around tick events'). You can make this scale in the shape of the desired problem by using more such simulators in parallel and then you can use a synchronization algorithm to maintain the functionality. (See, for example, for details) Of course, some important efforts are required for this, and you are really trying to exclude the first gradual algorithm.

A good way to increase the classical DES-view of logical processes (= agents) that communicate with each other through events, they describe discrete-event systems with other formal forms Can mix in some ideas used. Like In the developers, each unit can specify the duration, it will be in a certain position (e.g., the agent is blocking a resource), and will be interrupted only by incoming messages (and then change its position accordingly accordingly) , Such as resource-reducing agents).

BTW In what sense do you think agents are very complicated in dealing with discrete-incident simulation? If you consider each agent as a logical process, then it really does not matter how complex it is from the point of view of simulation - or am I going to do something wrong here?