Processing agent controller for operating in agent-based distributed simulation system

Abstract

The present invention provides a processing agent controller (104) for operation in an agent-based distributed simulation system (102) having a spatial partition of a simulation domain. The processing agent controller (104) is also configured to retrieve the desired information retrieved from the different partitions using a cache. The cache is filled according to the observed access mode.

Description

TECHNICAL FIELD

[0001] The present invention generally relates to an agent-based distributed simulation system, and more specifically, the present invention relates to a processing agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains. Furthermore, the present invention relates to a method for processing an agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains. BACKGROUND

[0002] Agent-based microscopic simulation is a simulation with discrete simulation entities / agents (e.g., cars). Microscopic traffic simulation is usually performed following the agent-based parallel discrete event simulation paradigm. Each simulation agent has custom and fine-grained attributes or states, as well as custom behavior models (e.g., models for car following and lane changing). These models define how the agent state evolves during simulation execution. Agents can be heterogeneous since their attribute sets and behavior models can not be uniform. A behavior model comprises a function (i.e., a computer-implemented function) that generates a new full agent state or a new partial agent state (i.e., partial attributes or values of all attributes) based on the current agent state and the states of other agents in the vicinity of the agent. Due to design considerations of the simulator, the behavior model is treated as a black box. That is, the specific logic used to update the agent state is unknown before the corresponding model is invoked, and the set of agents whose states are taken into account is also unknown. However, an agent can query whether a location in the simulation domain includes an agent whose state is to be taken into account for generating a new agent state.

[0003] A distributed simulation system is a simulation system that is performed by multiple computers collectively and consistently. These computers do not share any main memory but can communicate through a network. A simulation system with spatial domain decomposition / partitioning is a system that decomposes the simulation domain / space into disjoint subsets / partitions. In distributed execution, each computer is usually responsible for a subset / partition of the simulation domain (e.g., a portion of the road network), such that each location in the simulation domain can be uniquely mapped to exactly one partition. Each partition is further subdivided into smaller spatial elements / sectors (e.g., road segments), which are addressable by identifiers and can be processed in parallel. Each computer is responsible for maintaining and updating the states of all agents in its respective partition.

[0004] The simulation is typically executed in discrete time steps, and all computers in the distributed execution perform the simulation in lockstep. All computers / machines are synchronized so that the simulation is logically executed at the same simulation time. The simulation can only proceed when all partitions have processed and reached the same "step barrier." That is, at any time, all computers in the distributed execution are at the same time step of the simulation. In each simulation step, the state of each agent is updated in three different phases: (1) a perception phase, (2) a planning phase, (3) a control phase. In the perception phase, information needed by each agent's behavior models (e.g., information about nearby agents) is collected from the environment. In the planning phase, changes to the current state of the agent are determined based on the perceived information. For example, in the case of a traffic simulation, one behavior model can determine the acceleration to be applied to a vehicle given the circumstances, while another behavior model can change the fuel level state based on the acceleration. In the control phase, the computed updates to the agent's state are applied. For example, a driving agent perceives the surrounding agents and plans the optimal strategy based on the route and travel goals or other driving manner parameters (e.g., acceleration or braking, or initiating a lane change). Then, the behavior models are updated so that the agent's position and velocity are consistent with the modeled physics.

[0005] Throughout the simulation, the simulation time monotonically increases. Without loss of generality, the simulation time is a natural number (i.e., starting from 1), and the length of each simulation step is 1 (i.e., an arbitrary unit). The simulation space is subdivided into a set of non-overlapping partitions. That is, the union of all partitions is equal to the simulation space, and each location in the simulation space is contained in exactly one partition. In the distributed execution, without loss of generality, each computer is responsible for executing the simulation in its partition. The set of partitions is denoted as P = P1 U... UP M where P i , 1 < i < M, denotes the i-th partition in the total of M partitions. Without loss of generality, each computer participating in the execution of the simulation is responsible for exactly one partition, and there is a one-to-one correspondence between the partitions and the computers. Technically, each computer can be responsible for multiple partitions, as long as one computer is responsible for each partition.

[0006] Each partition of the simulation space is subdivided into sectors, which are individually addressable sectors. For example, in the case of a microscopic traffic simulation, the sectors can correspond to road segments or lane segments. The perception phase operates at the granularity of sectors when perceiving the state of nearby agents. That is, to perceive nearby agents, a query is made as to whether nearby sectors include other agents. A specialized API call can be used to retrieve the agents, including all relevant states of the agents located in a particular sector, needed in the perception phase.

[0007] In distributed execution, updating the state of an agent can require state information of agents in sectors that are located in different partitions managed by different computers. From the perspective of any computer, sectors located in a partition are managed by a different computer, i.e., remote sectors. If a sector is a remote sector, an API call to query the state of an agent in a given sector retrieves the information from the responsible computer. This remote interaction between different computers incurs communication cost, which negatively impacts the performance of the simulation system as a whole.

[0008] To update the state of an agent a at simulation time t, the set of sectors queried in the perception phase is denoted as the neighborhood set N(a, t). Since the behavior model is treated as a black box, the exact neighborhood set of an agent at a particular simulation time can be unknown before execution. However, the exact neighborhood set can be observed during execution. This can be achieved by intercepting API calls to retrieve agents located in a particular sector.

[0009] An existing traffic simulation scenario includes two partitions, four agents (e.g., cars), sectors located on the path of one agent, and the neighborhood set of the same agent. For a computer managing a partition p, the set of all remote sectors (i.e., covering all agents located in partition p) needed as the neighborhood union N p (t) at simulation time t. For example, for two agents a1, a2 located in a partition p with neighborhood sets N(a1, t) = {s1, s2}, N(a2, t) = {s3}, the neighborhood union N p (t) = {s1, s2, s3} is the set of all sectors needed to update the state of all agents (a1, a2) on this partition p.

[0010] Each computer maintains a cache with the state of remote sectors, including the state of agents in these sectors. Such a cache avoids querying the state of remote sectors multiple times in the same simulation step, which can improve simulation performance. Since the state of an agent can only change when the simulation proceeds from one time step to the next, all cache entries can be invalidated at the end of each simulation step to maintain cache consistency.

[0011] Existing approaches use virtual units that retrieve information for remote sectors (i.e., sectors that reside in partitions not owned by the current computer) in advance in bulk, rather than on demand during the perception phase of the agent state update, to reduce the resulting communication cost. Thus, when retrieving remote sectors prior to the agent state update, the communication latency required to interact with the remote computer occurs only once, rather than multiple times each time a remote sector is accessed. Furthermore, this bulk data transfer results in lower overall overhead (i.e., in terms of communication protocol, number of system calls, and other aspects) than transferring each sector individually. Once all the sectors needed are retrieved, the virtual units use the sectors to populate a cache with the information. During the agent state update, the cache can already have all the information needed, thus avoiding any remote interaction and the cost of generating the remote interaction.

[0012] Furthermore, the virtual unit approach relies on specifying exactly the remote sectors that can be needed during the agent state update. As described above, these remote sectors can then be prefetched and used to populate the cache. In simulations where the simulation domain is a metric space or has an intuitive notion of distance, the remote units needed can be specified by providing a distance that represents a range within the remote sectors around the computer's own partition. Furthermore, this range or explicit set of remote sectors must be configured according to the properties of the simulation.

[0013] Furthermore, statically specifying the set of remote sectors needed is equivalent to specifying the neighborhood union of each partition without considering the simulation time. That is, the neighborhood union of each partition is assumed to be the same throughout the simulation, as follows: 1 < p < M: N p (t1) = N p (t2).

[0014] Another problem in distributed simulation systems is that it is often not possible to know in advance the set of remote sectors needed to create virtual units, especially when the models are treated as black boxes. This results in over-provisioning within the visible range of remote sectors, which can impact performance and resource utilization. Furthermore, to ensure that the remote sectors have all the necessary information, these can be over-estimated, which increases the communication cost and the computational cost.

[0015] Another existing approach discloses a virtual unit approach for stencil operations in a matrix. The matrix (e.g., an 8x8 matrix) is decomposed into four sub-matrices (each 4x4 matrix). The matrix and the sub-matrices correspond to the full simulation domain and the partitions, respectively. A 3x3 stencil operation on one unit relies on the values of neighboring units (including diagonals). These neighboring units correspond to one neighborhood. The virtual unit for each partition is defined as all the neighboring units in the matrix that are in other partitions.

[0016] Another existing approach uses a cache in the computer hardware device. Caching is an established building block in computer hardware devices where accessing data residing on a separate storage device incurs a cost, which can degrade the overall performance. In this case, the cache is usually small but fast and used as a storage tier. The cache in the computer hardware device is usually used in conjunction with logic to prefetch data items so that the cache is populated before the data item is needed, making the data item readily available when needed without any additional overhead. This approach has similarities with the virtual cell approach in that the goal is to reduce the cost of retrieving data from a separate storage device.

[0017] Furthermore, the existing virtual cell approach relies on specifying what distal sectors can be needed to update the agent state for a given behavior model. This specification usually requires expert knowledge, but in some simulation scenarios, it can not be possible to derive the needed sectors before the simulation is executed. For example, if the set of needed sectors depends on the simulation state itself, then the set of needed sectors is unknown before the simulation is run. In the case of traffic simulation, if the agent model needs the state of the agent immediately ahead, then the set of needed sectors cannot be determined without knowing the location of the agent immediately ahead in advance.

[0018] One approach is to over-approximate the set of needed sectors. That is, assume that certain sectors are needed even if they are not. However, this does not limit the usability of the approach but can result in degraded performance because these sectors must be transmitted and processed, incurring communication and processing costs without any benefit. Another approach is to under-approximate the set of needed sectors, which results in degraded performance because the needed sectors can not be prefetched on demand and readily available in the cache. Thus, retrieving the needed sectors on demand incurs additional communication costs.

[0019] The static specification of the needed sectors is complex because the needed sectors can change throughout the simulation (e.g., in the case of traffic simulation, as the traffic patterns change throughout the day) or between partitions (e.g., in the case of traffic simulation, due to different regions exhibiting different traffic properties). Thus, it is difficult to specify the needed distal sectors, but it is essential for deriving performance benefits by employing the virtual cell approach. Furthermore, as mentioned above, in some simulation systems, it is not possible to statically specify the needed distal sectors by nature because it relies on information that is not available before the simulation is executed.

[0020] A drawback of existing virtual cell methods is that the virtual cells can over-approximate the neighborhood set, as the virtual cells are defined based on the maximum distance and require domain knowledge and configuration to perform such approximation. The exact neighborhood set can be unknown before evaluating the agent model. That is, at each simulation step, the agent model can choose which information to merge from which sectors to update the state. For example, the agent model can need the state information of the other agents that are closest. Since the model logic is treated as a black box, the exact neighborhood set is unknown before evaluating the model. Since the exact neighborhood set is unknown before evaluating the model, the virtual cells can be larger or smaller than required. If the virtual cells are larger than required, then communication cost is wasted due to not using certain information. If the virtual cells are smaller than required, then simulation performance is degraded because certain required information is not retrieved before performing the simulation step. Thus, these information must be retrieved while performing the simulation step, which results in additional communication cost.

[0021] Existing simulation systems, especially those related to scientific computing, use virtual cell methods that assume exact knowledge of the required information from other nodes. Another existing method is to use a CPU or memory cache that pre-fetches (i.e., implicit / transparent pre-fetching) in a pipelined CPU architecture or an out-of-order CPU architecture. When certain architectures have explicit support, the CPU or memory cache performs explicit pre-fetching. Pre-fetching can still result in additional overhead assuming the CPU or memory cache has exact knowledge of the information that can be required. However, in this case, the pre-fetching component needs to be configured and optimized or operate according to a standard configuration. Another problem in existing simulations is caching and cache optimization. Existing means address cache retention and deletion, and other issues related to memory access optimization, but existing means do not optimize the cache.

[0022] Therefore, there is a need to address the above technical problems / deficiencies in distributed simulation systems. SUMMARY

[0023] It is an object of the present invention to provide a processing agent controller for running in an agent-based distributed simulation system having spatial partitioning of simulation domains and to provide a method for processing an agent controller for running in an agent-based distributed simulation system having spatial partitioning of simulation domains while avoiding one or more of the drawbacks of the prior art methods.

[0024] This object is achieved by the features of the independent claims. Other implementations are evident from the dependent claims, the description and the figures.

[0025] The present invention provides a processing agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains, and a method for processing an agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains.

[0026] According to a first aspect, a processing agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains is provided. The processing agent controller is further configured to retrieve required information retrieved from different partitions using cache lookup. The cache is populated according to observed access patterns.

[0027] The processing agent controller improves the performance of the agent-based distributed simulation system with spatial partitioning of simulation domains. The processing agent controller does not require specific domain knowledge and utilizes observed access patterns to improve performance, thereby reducing communication costs. Compared to statically defined virtual units, the processing agent controller improves resource (e.g., network) usage efficiency. The processing agent controller does not reserve cache entries for more than one simulation step.

[0028] The processing agent controller does not require statically configuring the cache according to specific simulation expertise. The processing agent controller currently employs an adaptive and fully decentralized approach that can be optimized in large configurations with heterogeneous workloads without expert supervision. Because this approach only relies on locally available information on each machine. Therefore, no centralized coordination or storage is required. Furthermore, the present approach can be used in fully decentralized or centralized coordinated simulator designs, or a hybrid of fully decentralized and centralized coordinated simulator designs.

[0029] The processing agent controller is configured to perform distributed simulation, partitioning and controlling available computing resources / machines. The processing agent controller completely removes cache data after each simulation step, observes and predicts the amount of data that needs to be prefetched, so that all required information that can already be in the cache is locally available.

[0030] Optionally, the processing agent controller is further configured to observe actual access patterns. The access patterns indicate which information is requested from which partition, and predict the information required to perform the next simulation step based on these observed access patterns. The processing agent controller utilizes the performance gain effect caused by performing communication in the simulation step, and reduces the latency of transferring data through the cache, thereby reducing communication congestion. Preloading data into the cache as part of performing an asynchronous simulation can reduce communication latency when performing the next simulation step, thereby improving simulation performance.

[0031] Optionally, the processing agent controller is further configured to perform two phases for each simulation step. The two phases include a cache warm-up phase and an agent state update phase. The cache warm-up phase is performed before the agent state update. In the cache warm-up phase, the cache is filled with information of the distant sectors predicted to be needed for the current simulation step.

[0032] Optionally, the processing agent controller is further configured to: (i) clear the cache; (ii) provide the predictor with observed accesses to the distant sectors, whereby the predictor is configured to process the access records to facilitate subsequent provision of a prediction of the neighborhood union for the current time step. The predictor decides which distant sectors to prefetch. The cache size is not predetermined, but is adapted to all distant sectors in the neighborhood union. The predictor exploits the continuity of the simulated agents to improve communication efficiency, and thus predict necessary data. The cache warm-up phase predicted by the predictor can minimize synchronous remote communication, and thus improve overall simulation performance.

[0033] Optionally, the processing agent controller is further configured to: for each partition p: (i) clear the cache of information of the distant sectors; (ii) pass the neighborhood union recorded in the previous simulation step (t-1) to the predictor; (iii) invoke the predictor to obtain a predicted neighborhood union (N_p^*(t)) for the current simulation step t; (iv) request information of each distant sector comprised in the predicted neighborhood union (N_p^*(t)) from the responsible remote machine; (v) fill the cache with the requested information of the distant sectors.

[0034] Optionally, the processing agent controller is further configured to perform the agent state update phase, which includes: in the simulation step t, for each partition p: (i) record each access to the distant sectors; (ii) determine that the accessed sector is available in the cache, then utilize the accessed sector in the cache; and (iii) determine that the accessed sector is not available in the cache, then retrieve the accessed sector from the responsible remote machine, add the accessed sector to the cache, and utilize the accessed sector.

[0035] Optionally, the processing agent controller is further configured to utilize the accessed sector: (i) to observe and record the exact neighborhood (N(a,t)) used by the model of the agent (a) at time t; and (ii) to calculate the neighborhood union (N_p(t)) after processing all agents at the time t, i.e. the union of the neighborhood sets of the all agents processed by the machine responsible for the partition p.

[0036] Optionally, the processing agent controller is further configured to input N_p(t) to the predictor before executing the next simulation step to predict the neighborhood union N*_p(t+1) of the next simulation step and to request and retrieve the agent states of all sectors in N*_p(t+1) from the responsible machine and to use this information to fill the cache.

[0037] Optionally, the predictor is configured to provide empty predictions. The predictor can be configured to provide predictions by statically predicting the neighborhood union to be all sectors within a maximum distance of the partition.

[0038] Optionally, the predictor is configured to exploit characteristics of the domain of the simulation. When agents move not randomly but exhibit locality, the position of an agent is close to the position in the next time step. The predictor can be configured to provide a set of recently visited distant sectors.

[0039] Optionally, the processing agent controller is further configured to, during the cache warm-up phase, asynchronously request and retrieve the distant sectors from the predicted neighborhood union so that state updates of agents that do not require distant sector information are processed before a reply is received from the remote machine.

[0040] According to a second aspect, a method for a processing agent controller is provided, the processing agent controller being configured to run in an agent-based distributed simulation system having spatial partitions of a simulation domain. The method comprises employing a cache to retrieve required information retrieved from different partitions. The cache is filled according to observed access patterns.

[0041] The method improves the performance of the agent-based distributed simulation system having spatial partitions of a simulation domain. The method does not require specific domain knowledge and exploits observed access patterns to improve performance, thereby reducing communication costs. The method improves resource (e.g. network) usage efficiency compared to statically defined virtual cells. The method does not reserve cache entries for more than one simulation step. The method does not require statically configuring the cache according to specific simulation expertise. The processing agent controller currently employed is adaptive and fully decentralized, which can be optimized in large configurations with heterogeneous workloads without expert supervision. Because the method only relies on locally available information on each machine. Therefore, no centralized coordination or storage is required.

[0042] According to a third aspect, a computer program product is provided, comprising program instructions for performing the above method when executed by one or more processors in a processing agent system.

[0043] Thus, unlike existing approaches, the processing agent controller improves the performance of an agent-based distributed simulation system with spatial partitioning of simulation domains. The processing agent controller does not require specific domain knowledge and leverages observed access patterns to improve performance, thereby reducing communication costs. The processing agent controller improves resource (e.g., network) usage efficiency compared to statically defined virtual units. The processing agent controller does not reserve cache entries for more than one simulation step. This approach does not require static configuration of caches based on specific simulation expertise. The processing agent controller is adaptive and fully decentralized, which can be optimized in large configurations with heterogeneous workloads without expert supervision. Because the processing agent controller only relies on locally available information on each machine. Thus, no centralized coordination or storage is required.

[0044] These and other aspects of the present application are apparent from the following detailed description. BRIEF DESCRIPTION OF DRAWINGS

[0045] Implementations of the present application are described below by way of example only with reference to the attached drawings, wherein:

[0046] Figure 1 A block diagram of a processing agent controller for use in an agent-based distributed simulation system with spatial partitioning of simulation domains is provided for implementations of the present application;

[0047] Figure 2 A schematic diagram of an agent-based distributed simulation system is provided for implementations of the present application;

[0048] Figure 3 A control flow diagram of a simulation performed by a processing agent controller is provided for implementations of the present application;

[0049] Figure 4 A control flow diagram of a cache warm-up phase performed by a processing agent controller is provided for implementations of the present application;

[0050] Figure 5 A control flow diagram of an agent state update phase performed by a processing agent controller is provided for implementations of the present application;

[0051] Figure 6 A control flow showing a cache warm-up phase and an agent state update phase performed by a processing agent controller prior to performing a next simulation step on an agent is provided for implementations of the present application;

[0052] Figure 7The control flow of performing a cache warm-up phase and an agent state update phase by a processing agent controller before performing a next simulation step for all agents is shown;

[0053] Figures 8A to 8F An exemplary diagram of a simulation performed by a processing agent controller is provided for implementations of the present invention;

[0054] Figure 9 A diagram of performance improvement of an agent-based distributed simulation system using a processing agent controller is provided for implementations of the present invention;

[0055] Figure 10 A block diagram of a method for a processing agent controller for running in an agent-based distributed simulation system having spatial partitioning of simulation domains is provided for implementations of the present invention;

[0056] Figure 11 A diagram of a computer system (e.g., an agent-based distributed simulation system) that can implement various architectures and functionalities of the previous various implementations. DETAILED DESCRIPTION

[0057] Implementations of the present invention provide a processing agent controller for running in an agent-based distributed simulation system having spatial partitioning of simulation domains, and a method for a processing agent controller for running in an agent-based distributed simulation system having spatial partitioning of simulation domains.

[0058] In order for those skilled in the art to more easily understand the solutions of the present invention, the implementations of the present invention are described below in conjunction with the accompanying drawings.

[0059] The terms "first", "second", "third", and "fourth" (if any) in the summary of the invention, the claims, and the above drawings are used to distinguish similar objects, and are not necessarily used to describe a particular sequence or order. It should be understood that the terms used in this way are interchangeable under appropriate circumstances, for example, the implementations of the present invention described herein can be implemented in a sequence other than that shown or described herein. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units does not necessarily limit to the explicitly listed steps or units, but can include other steps or units not explicitly listed or inherent to such a process, method, product, or device.

[0060] Figure 1A block diagram of a processing agent controller 104 for running in an agent-based distributed simulation system 102 with spatial partitioning of simulation domains is provided. The processing agent controller 104 is also configured to retrieve required information from different partitions using a cache 106. The cache 106 is populated based on observed access patterns.

[0061] The processing agent controller 104 improves the performance of the agent-based distributed simulation system 102 with spatial partitioning of simulation domains. The processing agent controller 104 does not need to rely on specific domain knowledge and utilizes observed access patterns to improve performance, thereby reducing communication cost. The processing agent controller 104 improves resource (e.g., network) usage efficiency compared to statically defined virtual units. The processing agent controller 104 does not preserve observed access patterns for multiple simulation steps. The processing agent controller 104 does not need to statically configure the cache 106 based on specific simulation expertise.

[0062] Optionally, the processing agent controller 104 is also configured to observe actual access patterns. The access patterns indicate which information is requested from which partition and predict the information required to perform the next simulation step based on these observed access patterns.

[0063] Optionally, the processing agent controller 104 observes actual access patterns (i.e., information actually requested from other partitions) and uses these actual access patterns to predict the information required to perform the next simulation step, rather than statically defining the cache. Similar to the virtual unit approach, the processing agent controller 104 can request the information before performing the next simulation step. When performing the next simulation step, all information predicted to be required information can be readily available to the processing agent controller 104 without any additional communication cost. The processing agent controller 104 utilizes this approach (i.e., a dynamically adaptive virtual unit approach), the effectiveness of which depends on the accuracy of the prediction. For example, a false prediction can result in communication staleness by possibly using certain information, or a false prediction can result in having to remotely retrieve information when performing the simulation step by possibly not using certain information. Thus, false predictions can result in performance loss.

[0064] The processing agent controller 104 utilizes the performance gain from communication impact when performing simulation steps and reduces the latency of transferring data through the cache 106, thereby reducing communication congestion. Preloading data into the cache 106 as part of performing asynchronous simulations can reduce communication latency when performing the next simulation step, thereby improving simulation performance.

[0065] Optionally, the processing agent controller 104 is further configured to perform two phases in each simulation step. The two phases include a cache warm-up phase and an agent state update phase. The cache warm-up phase is performed before the agent state update. In the cache warm-up phase, the cache 106 fills up with information of the distant sectors that are predicted to be needed for the current simulation step.

[0066] In the agent-based distributed simulation system 102, it is not possible to specify exactly which distant sectors are needed in advance. For example, in the case of traffic simulation, the processing agent controller 104 uses an agent behavior model that needs to check the states of other agents that are immediately ahead. Finding the other agents that are immediately ahead can only need information of one distant sector (e.g., in the case of heavy traffic, the agents that are immediately ahead are very close) or need information of multiple distant sectors (e.g., in the case of light traffic, multiple distant sectors without agents can need to be checked before finding a sector with an agent). In this case, the set of distant sectors that are needed can not be provided (i.e., provided by distance or explicitly) before the simulation step is performed. The processing agent controller 104 solves these two problems without relying on the static configuration of the cache 106.

[0067] Optionally, the processing agent controller 104 is further configured to: (i) clear the cache 106; and (ii) provide the observed accesses to distant sectors to the predictor, whereby the predictor is configured to process the access records to facilitate the provision of the prediction of the neighborhood union for the current time step.

[0068] Optionally, the processing agent controller 104 relies on a black-box predictor that is adapted to predict the neighborhood union for the next simulation step when the neighborhood union is observed in the current and previous simulation steps. The processing agent controller 104 does not make any requirement on the internal function or accuracy of the predictor used. However, the time benefit of the cache warm-up phase can not outweigh the benefit of avoiding on-demand retrieval of distant sectors.

[0069] Optionally, the predictor determines which distant sectors to prefetch, but not based on the score and the score threshold. The cache size is not predetermined, but is suitable for all distant sectors in the neighborhood union. The predictor exploits the continuity of the agents in the simulation to improve the communication efficiency by predicting the necessary data. The cache warm-up phase predicted by the predictor can minimize the synchronous remote communication, thereby improving the overall simulation performance.

[0070] Optionally, the processing agent controller 104 is further configured to: for each partition p: (i) clear the cache 106 of information for remote sectors; (ii) pass the recorded neighborhood union at the previous simulation step (t - 1) to the predictor; (iii) invoke the predictor to obtain the predicted neighborhood union (N_p^*(t)) for the current simulation step t; (iv) request from the responsible remote machine the information for each remote sector contained in the predicted neighborhood union (N_p^*(t)); (v) populate the cache 106 with the requested information for remote sectors.

[0071] Optionally, the processing agent controller 104 is further configured to perform an agent state update phase. The agent state update phase comprises: at simulation step t, for each partition p: (i) record each access to a remote sector; (ii) determine that the accessed sector is available in the cache 106, then utilize the accessed sector in the cache; (iii) determine that the accessed sector is not available in the cache 106, then retrieve the accessed sector from the responsible remote machine, add the accessed sector to the cache 106, and utilize the accessed sector.

[0072] Optionally, the processing agent controller 104 is further configured to utilize the accessed sectors to observe and record the exact neighborhood (N(a, t)) used by the model of the agent (a) at time t. After processing all agents at time t, the processing agent controller 104 computes the neighborhood union (N_p(t)), i.e., the union of the neighborhood sets of all agents processed by the machine responsible for partition p.

[0073] Optionally, the processing agent controller 104 is further configured to: prior to executing the next simulation step, input N_p(t) to the predictor to predict the neighborhood union N*_p(t+1) for the next simulation step, and request and retrieve the agent state for all sectors in N*_p(t+1) from the responsible machine, and populate the cache 106 with this information.

[0074] Optionally, the predictor is configured to provide empty predictions. The accuracy of the execution of a simulation step is independent of the predictor used. The reason is that inaccurate predictions, even empty predictions, can affect performance but not the accuracy of the simulation step. In existing predictors, an empty prediction results in the cache 106 being effectively disabled, leading to the retrieval of all remote sectors in the neighborhood union when updating the agent state. Predicting the neighborhood union statically to all remote sectors within a maximum distance of its own partition results in the same behavior as a virtual cell with the same distance defined statically. However, the availability of a predictor in the simulation domain is superior to existing predictors, which is the potential performance advantage of using a predictor.

[0075] The predictor can be used to provide predictions by statically predicting the neighborhood union as all sectors within the maximum distance of the partition. However, the processing agent controller 104 does not statically define the cache based on the maximum interference range between agents. The processing agent controller 104 does not need to configure the far sectors, nor the expertise required to configure the required far sectors. Furthermore, the processing agent controller 104 does not need to configure the maximum range based on the specific domain knowledge required. The processing agent controller 104 ensures that errors that can arise in the expertise do not affect the execution accuracy of the simulation step.

[0076] Optionally, the predictor is used to exploit the characteristics of the domain of the simulation. When agents move not randomly but exhibit locality, the current position of an agent is close to the position in the next time step. The predictor can exploit this property and can be used to provide a set of far sectors that were recently visited.

[0077] Optionally, the processing agent controller 104 is further configured to: during a cache warm-up phase, asynchronously request and retrieve far sectors from the predicted neighborhood union in order to process state updates of agents that do not require information of far sectors before receiving a reply from a remote machine. Optionally, the processing agent controller 104 asynchronously requests and retrieves far sectors from the predicted neighborhood union while executing the next simulation step. This requires making appropriate synchronization, i.e. the sector has been requested but has not been received when the state of the agent needs to be updated.

[0078] Optionally, the processing agent controller 104 for performing the distributed simulation partitions and controls the available computing resources / machines. The processing agent controller 104 completely removes the cache data in each simulation step, observes and predicts the amount of data that needs to be prefetched to ensure that all required information is available locally.

[0079] The method currently employed by the processing agent controller 104 is an adaptive and fully decentralized method that can be optimized in large configurations with heterogeneous workloads without the need for expert supervision, as it only relies on information that is locally available on each machine. Therefore, there is no need for centralized coordination or storage. Furthermore, the current method can be used in fully decentralized or centralized coordinated simulator designs, or hybrid designs thereof. The method currently employed by the processing agent controller 104 can be arbitrarily scaled according to the size of the simulation domain and is based on observations / predictions of the communication needs according to the specific simulation state.

[0080] Figure 2A schematic diagram of an agent-based distributed simulation system 200 is provided for an implementation of the present invention. A processing agent controller is used to run in the agent-based distributed simulation system 200. Each computer participating in the agent-based distributed simulation system 200 runs an instance of a simulation engine 202. Each instance of the simulation engine 202 is responsible for simulating one partition consisting of a subset of the simulation space (e.g., a road network). The agent-based distributed simulation system 200 includes a communication network 204. The communication network 204 uses a message passing interface (MPI) to enable communication between multiple instances of the simulation engine 202. In the agent-based distributed simulation system 200, the simulation space is subdivided into sectors (e.g., road segments). The state of the agents (208A-C) is updated in each simulation step with a granularity of spatial queues (206A-C). Each spatial queue corresponds to a sector and also acts as a container for the agents (208A-C) located in that sector. The agent-based distributed simulation system 200 uses a pool of processing threads 210 to process spatial queues / sectors (206A-C) and update the state of the contained agents (208A-C) in parallel.

[0081] The agent-based distributed simulation system 200 maintains a set of communication threads 212 for coordination and communication between computers (e.g., remote machines). The communication threads 212 are used both to process incoming MPI messages and to asynchronously perform related actions for interacting with other computers. In the agent-based distributed simulation system 200, most of the related functionality for interacting with other simulation instances is encapsulated in a remote state provider 214. The remote state provider 214 can implement logic that synchronizes the execution between simulation instances, such that all instances (i.e., logically) always execute the same simulation step, even within each step the same phase is executed. This synchronization is implemented using MPI primitives. To independently compute traffic-aware routes for the agents (208A-C) in each simulation instance, the remote state provider 214 includes a functionality that globally distributes traffic information and traffic light plans for each partition. To retrieve information for remote spatial queues (206A-C) / sectors, the remote state provider 214 provides an API that is used in the agent state update logic. Information for remote spatial queues (206A-C) is cached to avoid negative performance impact from redundant communication. Cached entries are invalidated / cleared at the beginning of each simulation step.

[0082] For example, if an agent 208A moves out of its current partition, the agent 208A migrates to the computer responsible for the partition to which the agent 208A moves. The way this is achieved is to serialize the complete state of the agent (including all behavior models and their respective states) and transmit it, and re-instantiate the agent 208A in the simulation engine 202 responsible for the partition to which the agent 208A moves.

[0083] The simulation engine 202 maximizes the impact of processing the agent controllers. For the simulation engine 202, discrete partitions of the space can be defined, such that neighborhoods and unions can be defined, and the involved interaction physics has a certain continuity, such that the predictor has a good chance of predicting future demands, and thus. As an example, where the simulation engine 202 is an agent-based micro-simulator (e.g., a traffic simulator, a crowd simulator, a bicycle simulator, etc.), weak scaling can be achieved by distributed partitioning and execution.

[0084] Optionally, the agent-based distributed simulation system 200 further comprises a remote state provider cache 216 and a simulation phase coordinator 218. Optionally, the agent-based distributed simulation system 200 further performs remote migration and teleportation processing.

[0085] Optionally, the processing the agent controllers relies on a communication means between computers (e.g., remote machines) in order to retrieve the required zoom-out sectors from the respective computers responsible for the zoom-out sectors. However, no specific requirements are made to the communication channel, framework, or abstraction. Since communication is an inherent requirement for performing distributed simulation at least when the simulation is performed in lockstep, the processing the agent controllers can employ the same communication means.

[0086] Figure 3A control flow graph for execution of a simulation by a processing agent controller is provided for the present implementation. The processing agent controller is configured to run in an agent-based distributed simulation system having spatial partitioning of simulation domains. The processing agent controller is further configured to retrieve required information from different partitions using a cache. The cache is populated based on observed access patterns. Optionally, the processing agent controller is further configured to perform two phases per simulation step. The two phases include a cache warm-up phase and an agent state update phase. The cache warm-up phase is performed before the agent state update. At step 302, the processing agent controller starts the simulation. At step 304, in the cache warm-up phase, the simulation populates the cache with information of tele sectors predicted to be required for the current step. At step 306, the processing agent controller performs the agent state update phase to update the agent state. At step 308, other simulation / system specific operations are performed in each simulation step, such as writing the full or partial simulation state to persistent storage for later analysis. At step 310, the processing agent controller checks if the simulation is complete, and if the simulation is not complete, it proceeds to step 304. At step 312, the simulation ends.

[0087] Optionally, the processing agent controller is further configured to: in the cache warm-up phase, asynchronously request and retrieve tele sectors from the predicted neighborhood union, so that the processing of the agent state update that does not require information of the tele sectors is performed before receiving a reply from the remote machine.

[0088] Figure 4 A control flow graph for execution of a cache warm-up phase by a processing agent controller is provided for the present implementation. The processing agent controller is further configured to perform two phases per simulation step, namely a cache warm-up phase and an agent state update phase. The cache warm-up phase is performed before the agent state update. In the cache warm-up phase, the cache is populated with information of tele sectors predicted to be required for the current simulation step. At step 402, the processing agent controller clears the cache of information of tele sectors. At step 404, the processing agent controller provides the predictor 412 with recorded / observed accesses to tele sectors. The predictor 412 is configured to process the recorded / observed accesses to facilitate later providing a prediction of the neighborhood union for the current time step. At step 406, the predictor 412 is invoked to obtain the predicted neighborhood union for the current time step, i.e., the set of tele sectors required. At step 408, the processing agent controller requests / retrieves information of each tele sector included in the predicted neighborhood union from the responsible remote machine (e.g., machine 2). At step 410, the processing agent controller populates the cache with the requested information of tele sectors.

[0089] Optionally, in the cache warm-up phase, the processing agent controller is used to: before each simulation step t, t>1, for each partition p: (i) clear the information of the distant sectors in the cache; (ii) pass the neighborhood union recorded in the previous simulation step (t–1) to the predictor 412; (iii) call the predictor 412 to obtain the predicted neighborhood union (N_p^*(t)) of the current simulation step t; (iv) request the information of each distant sector contained in the predicted neighborhood union (N_p^*(t)) from the responsible remote machine; (v) when the requested distant sector information is received, fill the cache with the requested distant sector information.

[0090] Figure 5 A control flow diagram for an implementation of the present invention in which the processing agent controller performs the agent state update phase. In step 502, during a simulation step t, t≥1, for each partition p, the processing agent controller records each access to a remote sector. In step 504, the processing agent controller determines whether the accessed sector is available in the cache. In step 506, if the accessed sector is available in the cache, the processing agent controller utilizes / retrieves the accessed sector in the cache and returns the accessed sector to the agent state update logic. In step 508, if the accessed sector is not available in the cache, the processing agent controller retrieves the accessed sector from the responsible remote machine. In step 510, the processing agent controller adds the accessed sector to the cache and utilizes / retrieves the accessed sector and returns the accessed sector to the agent state update logic.

[0091] Optionally, the processing agent controller is further configured to observe and record the exact neighborhood (N(a,t)) used by the model of agent (a) at time t using the visited sectors. After processing all agents at time t, the processing agent controller is further configured to compute the neighborhood union (N_p(t)), which is the union of the neighborhood sets of all agents processed by the machine responsible for partition p.

[0092] Optionally, a predictor is used to exploit the characteristics of the simulated domain. When the agent's movements are not random but exhibit locality, the agent's position is close to its position in the next time step.

[0093] Figure 6The control flow is shown to describe the pre-execution steps / cache warm-up phase and the agent state update phase performed by the processing agent controller before executing the next simulation step for the agent. The control flow describes the pre-execution steps / cache warm-up phase in steps 602 to 610, where the remote machine (e.g., machine 2)’s far-out sectors are retrieved. In step 602, the processing agent controller clears the cache 624 of the far-out sectors’ information. In step 604, the processing agent controller provides the recorded / observed accesses to the far-out sectors to the predictor 622. The predictor 622 is used to process the recorded / observed accesses to facilitate the later provision of the prediction of the neighborhood union for the current time step. In step 606, the predictor 622 is invoked to obtain the predicted neighborhood union for the current time step, i.e., the set of far-out sectors required. In step 608, the processing agent controller requests / retrieves the information of each far-out sector included in the predicted neighborhood union from the responsible remote machine (e.g., machine 2). In step 610, the processing agent controller populates the cache 624 with the requested far-out sectors’ information.

[0094] Optionally, the processing agent controller is further configured to input N_p(t) to the predictor 622 to predict the neighborhood union N*_p(t+1) for the next simulation step, and request and retrieve the agent states of all sectors in N*_p(t+1) from the responsible machines, and populate the cache 624 with this information, before executing the next simulation step.

[0095] The control flow describes the agent state update phase / simulation step computation in steps 612 to 620. In step 612, during the simulation step t, t≥1, the processing agent controller records each access to a far-out sector for each partition p. In step 614, the processing agent controller determines whether the accessed sector is available in the cache 624. In step 616, if the accessed sector is available in the cache 624, the processing agent controller utilizes / retrieves the accessed sector from the cache and returns the accessed sector to the agent state update logic. In step 618, if the accessed sector is not available in the cache 624, the processing agent controller retrieves the accessed sector from the responsible remote machine. In step 620, the processing agent controller adds the accessed sector to the cache 624 and utilizes / retrieves the accessed sector and returns the accessed sector to the agent state update logic.

[0096] Optionally, the processing agent controller is further configured to utilize the accessed sectors to observe and record the exact neighborhood (N(a, t)) used by the model of the agent (a) at time t. After processing all agents at time t, the processing agent controller is further configured to compute the neighborhood union (N_p(t)), i.e., the union of the neighborhoods of all agents processed by the machine responsible for the partition p.

[0097] Optionally, the predictor 622 is configured to provide empty prediction. Based on the static prediction of the neighborhood union, the predictor 622 can be configured to provide the prediction by statically predicting the neighborhood union to be all sectors within the maximum distance of the partition. Optionally, the predictor 622 is configured to utilize the characteristics of the simulated domain. When the agent moves are not random but exhibit locality, the agent's location is close to the location in the next time step. The predictor 622 can be configured to provide a set of distant sectors that were recently visited.

[0098] Figure 7 The control flow of performing the cache warm-up phase and the agent state update phase by the processing agent controller before performing the next simulation step for all agents is shown. Optionally, the processing agent controller is further configured to perform the two phases, i.e., the cache warm-up phase and the agent state update phase, for each simulation step. The cache warm-up phase is performed before the agent state update. The cache warm-up phase is performed in steps 702-710. In step 702, the processing agent controller clears the information 724 of the distant sectors in the cache. In step 704, the processing agent controller provides the recorded / observed accesses to the distant sectors to the predictor 722. The predictor 722 is configured to process the recorded / observed accesses to facilitate the subsequent provision of the prediction of the neighborhood union for the current time step. In step 706, the predictor 722 is invoked to obtain the predicted neighborhood union for the current time step, i.e., the set of distant sectors required. In step 708, the processing agent controller requests / retrieves the information of each distant sector contained in the predicted neighborhood union from the responsible remote machine (e.g., machine 2). In step 710, the processing agent controller fills the cache 724 with the information of the requested distant sectors.

[0099] Optionally, the processing agent controller is further configured to: before performing the next simulation step, input N_p(t) to the predictor 722 to predict the neighborhood union N*_p(t+1) for the next simulation step, and request and retrieve the agent states of all sectors in N*_p(t+1) from the responsible machine, and use this information to fill the cache 724.

[0100] In steps 712-720, the agent state update phase is performed for all agents of each partition p. In step 712, during the simulation step t: for each partition p, the processing agent controller records each access of a remote sector. In step 714, the processing agent controller determines if the accessed sector is available in the cache 724. In step 716, if the accessed sector is available in the cache 724, the processing agent controller utilizes / retrieves the accessed sector from the cache and returns the accessed sector to the agent state update logic. In step 718, if the accessed sector is not available in the cache 724, the processing agent controller retrieves the accessed sector from the responsible remote machine. In step 720, the processing agent controller adds the accessed sector to the cache 724 and utilizes / retrieves the accessed sector and returns the accessed sector to the agent state update logic.

[0101] Optionally, the processing agent controller is further configured to utilize the accessed sectors to observe and record the exact neighborhood (N(a, t)) used by the model of all agents (a) at time t. After processing all agents at time t, the processing agent controller is configured to compute the neighborhood union (N_p(t)), i.e., the union of the neighborhood sets of all agents processed by the machine responsible for partition p.

[0102] Figures 8A to 8F An exemplary illustration of the simulation performed by the processing agent controller is provided for an implementation of the present invention. The processing agent controller is configured to run in an agent-based distributed simulation system having spatial partitioning of the simulation domain. Figures 8A to 8F A simple traffic simulation scenario is depicted, including two partitions (e.g., machine 1 802 and machine 2 804) enclosed by a black dashed line, three agents (808A-C) depicted as car icons, remote sectors (e.g., sector 43-48) on the path 810 of agent 2 808B, and the neighborhood union of agent 2 808B being sector 43, sector 44, and sector 45. The processing agent controller is configured to retrieve the required information from different partitions (e.g., machine 2 804) in a cache 806. The cache 806 is populated according to observed access patterns. Optionally, the processing agent controller is further configured to observe actual access patterns. The access patterns indicate which information is requested from which partition, and the required information for performing the next simulation step is predicted based on these observed access patterns.

[0103] Optionally, the processing agent controller is further configured to perform two phases per simulation step, a cache warm-up phase and an agent state update phase. The cache warm-up phase is performed prior to the agent state update. In the cache warm-up phase, the cache 806 is populated with information of remote sectors predicted to be required for the current simulation step.

[0104] Figure 8A An exemplary execution step 1 performed by the processing agent controller is depicted. In execution step 1, the processing agent controller is used to clear the cache 806 of information for the remote sectors (e.g., sectors 43 through 48) for partition p (e.g., machine 1 802). If there are no remote sectors in the cache 806, the processing agent controller of machine 1 802 requests information for the required remote sectors for partition p (e.g., machine 1 802) from machine 2 804 for the current simulation step t = 1.

[0105] Figure 8B An exemplary execution step 2 performed by the processing agent controller is depicted. In execution step 2, during simulation step t = 1, the processing agent controller records each access to the remote sectors (i.e., sectors 43, 44, 45) for partition p (e.g., machine 1 802).

[0106] Figure 8C An exemplary execution step 3 performed by the processing agent controller is depicted. In execution step 3, the processing agent controller provides the recorded / observed accesses to the remote sectors to the predictor. The predictor is used to process the recorded / observed accesses to facilitate the subsequent provision of a prediction of the neighborhood union for the current simulation step t = 1. The predictor is invoked to obtain the predicted neighborhood union for the current simulation step t = 1, i.e., the set of required remote sectors. The processing agent controller of machine 1 802 requests / retrieves information for each remote sector contained in the predicted neighborhood union from the responsible remote machine (e.g., machine 2).

[0107] Figure 8D An exemplary execution step 4 performed by the processing agent controller is depicted. In execution step 4, for the current simulation step t = 1, the processing agent controller populates the cache 806 with the information for the requested remote sectors.

[0108] Figure 8E An exemplary execution step 5 performed by the processing agent controller is depicted. In execution step 5, during simulation step t = 2, for partition p (e.g., machine 1 802), the processing agent controller records each access to the remote sectors (i.e., sector 46) and determines if the accessed sector (i.e., sector 46) is available in the cache 806. If the accessed sector (i.e., sector 46) is available in the cache 806, the processing agent controller utilizes / retrieves the accessed sector (i.e., sector 46) from the cache and returns the accessed sector (i.e., sector 46) to the agent state update logic. If the accessed sector (i.e., sector 46) is not available in the cache 806, the processing agent controller retrieves the accessed sector (i.e., sector 46) from the responsible remote machine (i.e., machine 2 804).

[0109] Figure 8FAn example execution step 6 performed by the processing agent controller is depicted. During execution step 6, during simulation step t = 2, for a partition p (e.g., machine 1 802), the processing agent controller adds the accessed sector (i.e., sector 46) to the cache 806 and utilizes / retrieves the accessed sector (i.e., sector 46) and returns the accessed sector (i.e., sector 46) to the agent state update logic.

[0110] Figure 9 A graph illustrating performance improvement of an agent-based distributed simulation system using a processing agent controller is provided for an implementation of the present invention. The graph shows that the performance of an agent-based distributed simulation system 902 using a processing agent controller is higher than the performance of an agent-based distributed simulation system 904 with statically defined virtual units. The lower values in the graph correspond to higher performance (i.e., about 20% performance gain). The agent-based distributed simulation system improves the overall performance of an agent-based distributed simulation system with spatial partitioning and improves resource usage efficiency (e.g., network) compared to statically defined virtual units if the neighborhood union is predictable. The agent-based distributed simulation system with a processing agent controller does not require specific domain knowledge or adjustment of parameters of the simulation scenario compared to statically defined virtual units. Statically defined virtual units require a priori knowledge. The agent-based distributed simulation system with a processing agent controller can use any generic black-box predictor or a predictor that utilizes specific domain simulation characteristics.

[0111] Figure 10 A block diagram of a method for a processing agent controller for running in an agent-based distributed simulation system with spatial partitioning of simulation domains is provided for an implementation of the present invention. At step 1002, a cache is employed to retrieve required information retrieved from different partitions. The cache is populated according to observed access patterns.

[0112] The method improves the performance of an agent-based distributed simulation system with spatial partitioning of simulation domains. The method does not require specific domain knowledge and utilizes observed access patterns to improve performance, thereby reducing communication cost. The method improves resource (e.g., network) usage efficiency compared to statically defined virtual units. The method does not preserve observed access patterns for more than one simulation step. The method does not require statically configuring the cache according to specific simulation expertise. The processing agent controller currently employs an adaptive and fully decentralized approach that can be optimized in large configurations with heterogeneous workloads without expert supervision. Because the method only relies on locally available information on each machine. Therefore, no centralized coordination or storage is required.

[0113] In one embodiment, a computer program product includes program instructions. The program instructions are for performing the above-described method when executed by one or more processors in a processing agent system.

[0114] Figure 11 A diagram of a computer system (e.g., an agent-based distributed simulation system) that can implement various architectures and functionalities of the various implementations described previously. As shown, the computer system 1100 includes at least one processor 1104 connected to a bus 1102. The computer system 1100 can be implemented using any suitable protocol, such as Peripheral Component Interconnect (PCI), PCI-Express, Accelerated Graphics Port (AGP), Hyper Transport, or any other bus or point-to-point communication protocol. The computer system 1100 also includes a memory 1106.

[0115] Control logic (software) and data are stored in the memory 1106, which can be a random-access memory (RAM). In the present disclosure, a single semiconductor platform can refer to a sole unitary integrated circuit or chipset as having a single semiconductor platform that either contains only a single integrated circuit or chipset, or that contains multiple integrated circuits or chipsets depending upon the needs of the user. It should be noted that the term integrated circuit (IC) as used herein does not limit the element to a single chip, but rather can refer to any element that performs similar functions and / or operations as a single integrated circuit or chipset. Moreover, it should be noted that the term

[0116] The computer system 1100 can also include secondary storage 1110. The secondary storage 1110 includes a hard disk drive and a removable storage drive, such as a floppy disk drive, a magnetic tape drive, a compact disk drive, a digital versatile disk (DVD) drive, a recording device, or a universal serial bus (USB) flash memory. The removable storage drive reads from and / or writes to a removable storage unit in a well-known manner.

[0117] Computer programs or computer control logic algorithms can be stored in at least one of the memory 1106 and the secondary storage 1110. Such computer programs, when executed, enable the computer system 1100 to perform various functions as described herein. The memory 1106, the secondary storage 1110, and any other storage are computer-readable media.

[0118] In one implementation, the architecture and functionality of the previously described various figures can be implemented within a processor 1104, a graphics processor coupled to a communication interface 1112, an integrated circuit (not shown) and chipset (i.e., a set of integrated circuits designed to work and sold as a unit) capable of having at least portions of the processor 1104 and graphics processor, both of which are in communication with each other and with various other components over one or more communication buses and can have at least a portion of their functionality implemented with at least one software module and at least a portion of their functionality implemented at least in hardware.

[0119] Furthermore, the architecture and functionality of the previously described various figures can be implemented in the context of a general computer system, a circuit board system, a game console system specifically made for entertainment purposes, a system specifically made for a particular application. For example, the computer system 1100 can take the form of a desktop computer, laptop computer, server, workstation, game console, embedded system, etc.

[0120] Furthermore, the computer system 1100 can take the form of various other devices including, but not limited to, a personal digital assistant (PDA) device, a mobile phone device, a smart phone, a television, etc. Additionally, while not shown, the computer system 1100 can be coupled to a network (e.g., telecommunications network, local area network (LAN), wireless network, wide area network (WAN) such as the Internet, point-to-point network, cable network, etc.) through the I / O interface 1108, for communications purposes.

[0121] It should be appreciated that the arrangement of components shown in the described figures is exemplary, and that other arrangements are possible. It should also be appreciated that the various system components (and devices) defined by the claims, described below, and shown in the various block diagrams represent components in some of the systems configured in accordance with the subject matter disclosed herein. For example, one or more of these system components (and devices) can be implemented in whole or in part by at least some of the components shown in the arrangements shown in the described figures.

[0122] Furthermore, while at least one of these components is implemented at least partially as an electronic hardware component, and thereby constitutes a machine, other components can be implemented in software, which firmware includes when in an execution environment, constitutes a machine, hardware, or a combination of software and hardware.

[0123] While the present application and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the application as defined by the appended claims.

Claims

1. A processing agent controller (104) characterized by, The processing agent controller (104) is configured to run in an agent-based distributed simulation system (102, 200) with spatial partitioning of the simulation domain, and the processing agent controller is further configured to employ a cache (106, 624, 724, 806) to retrieve required information retrieved from different partitions, wherein the cache is populated according to observed access patterns.

2. The process agent controller of claim 1, wherein, The processing agent controller is further configured to observe actual access patterns, wherein an access pattern indicates which information is requested from which partition, and to predict information required to perform the next simulation step based on these observed access patterns.

3. The process agent controller of claim 1 or 2, wherein, The processing agent controller is further configured to perform two phases per simulation step: a cache warm-up phase and an agent state update phase, wherein the cache warm-up phase is performed before the agent state update, wherein in the cache warm-up phase the cache is populated with information of distant sectors predicted to be required for the current simulation step.

4. The process agent controller of claim 3, wherein, The processing agent controller is further configured to: clear the cache; provide the observed accesses to distant sectors to a predictor (412, 622, 722), whereby the predictor is configured to process the access records to facilitate a subsequent provision of a prediction of the neighborhood union for the current time step.

5. The process agent controller of claim 3 or 4, wherein, The processing agent controller is further configured to: for each partition p: clear the cache of information of distant sectors; pass the neighborhood union recorded in the last simulation step (t-1) to the predictor; invoke the predictor to obtain the predicted neighborhood union (N_p^*(t)) for the current simulation step t; request information of each distant sector comprised in the predicted neighborhood union (N_p^*(t)) from the responsible remote machine; populate the cache with the requested information of distant sectors.

6. The process agent controller of any one of claims 3 to 5, wherein, The processing agent controller is further configured to perform the agent state update phase, which comprises, in the simulation step t, for each partition p: record each access to a distant sector; determine whether the accessed sector is available in the cache, then utilize the accessed sector in the cache; determine whether the accessed sector is not available in the cache, then retrieve the accessed sector from the responsible remote machine, add the accessed sector to the cache, utilize the accessed sector.

7. The process agent controller of any one of claims 3 to 6, wherein, The processing agent controller is further configured to utilize the accessed sector to perform the following operations: observe and record the exact neighborhood (N(a,t)) used by a model of an agent (a) (208A, 808A) at time t; after processing all agents (208A to 208C, 808A to 808C) at time t, compute the neighborhood union (N_p(t)), i.e. the union of the neighborhoods of all agents processed by the machine of the responsible partition p.

8. The process agent controller of any one of claims 3 to 7, wherein, The processing agent controller is further configured to input N_p(t) into the predictor to predict the neighborhood union N*_p(t+1) for the next simulation step before performing the next simulation step; request and retrieve from the responsible machine the agent state of all sectors in N*_p(t+1) and use this information to populate the cache.

9. The process agent controller of any one of claims 3 to 8, wherein, The predictor is configured to provide empty predictions.

10. The process agent controller of any one of claims 3 to 9, wherein, The predictor is configured to provide predictions by statically predicting the neighborhood union to all sectors within a maximum distance of the partition.

11. The process agent controller of any one of claims 3 to 8, wherein, The predictor is configured to exploit the characteristics of the simulated domain, wherein when agents move non-randomly but exhibit locality, the position of an agent is close to the position in the next time step.

12. The process agent controller of any one of claims 3 to 8, wherein, The predictor is configured to provide a set of recently accessed distant sectors.

13. The process agent controller of any of the preceding claims, wherein, The processing agent controller is further configured to, during the cache warm-up phase, asynchronously request and retrieve distant sectors from the predicted neighborhood union so as to process state updates of agents that do not require information of distant sectors before receiving a reply from the remote machine.

14. A method for processing an agent controller, the method comprising: The processing agent controller is configured to operate in an agent-based distributed simulation system having spatial partitions of the simulated domain, the method comprising employing a cache to retrieve required information retrieved from different partitions, wherein the cache is populated according to observed access patterns.

15. A computer program product, characterised in that, program instructions for execution by one or more processors in a processing agent system to perform the method of claim 14.

Images