FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003
COMPLETE SPECIFICATION (See Section 10 and Rule 13)
Title of invention:
METHOD AND SYSTEM FOR METAMODEL DRIVEN
ACCELERATION OF ACTOR-BASED SIMULATED APPLICATION
Applicant
Tata Consultancy Services Limited
A company Incorporated in India under the Companies Act, 1956
Having address:
Nirmal Building, 9th floor,
Nariman point, Mumbai 400021,
Maharashtra, India
Preamble to the description
The following specification particularly describes the invention and the manner in which it is to be performed.

TECHNICAL FIELD [001] The disclosure herein generally relates to the field of actor based simulation and more specifically, to a method and system for metamodel driven acceleration of actor-based simulated application.
BACKGROUND
[002] Actor based simulators provide a facility to simulate different systems ranging from enterprises processes, Information Technology (IT) systems, complex physical systems like boilers all the way to cities and even people. These simulators are employed to create digital twins of the respective system or application. These simulators expose a set of application programming interfaces (APIs) using which different actors involved in the simulation and the interaction between those actors can be defined and executed. The underlying APIs over which these simulations (e.g. digital twins) are written are common. These common APIs results in ease of use and reduces overall design time of simulation.
[003] In terms of the implementation and execution, all simulations are handled equally by the actor based simulators. However, individual simulation characteristics information which could be used from the point of view of performance (throughput, latency, time, and resources taken for simulation) remains un-exposed and unused.
SUMMARY
[004] Embodiments of the disclosure present technological improvements as solutions to one or more of the above-mentioned technical problems recognized by the inventors in conventional systems. For example, in one embodiment, a method and system for a metamodel driven acceleration of actor-based simulated application is provided.
[005] In one aspect, a processor-implemented method for a metamodel driven acceleration of actor-based simulated application is provided. The method includes one or more steps such as receiving a description, an execution log, and a configuration of a simulated application from a user, and parsing the received

description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application. Wherein, the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, fixed interaction among the set of actors, and changing interactions among the set of actors. Further, the processor-implemented method comprising mapping the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, and selecting a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
[006] In another aspect, a system for a metamodel driven acceleration of actor-based simulated application is provided. The system includes an input/output interface configured to receive a description, an execution log, and a configuration of an application to be simulated from a user, one or more hardware processors and at least one memory storing a plurality of instructions, wherein the one or more hardware processors are configured to execute the plurality of instructions stored in the at least one memory.
[007] Further, the system is configured to parse the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application. Wherein, the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, an interaction among the fixed set of actors, and an interaction among the changing set of actors. Furthermore, the system is configured to map the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, and composition of the set of actors to select a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
[008] In yet another aspect, one or more non-transitory machine-readable information storage mediums are provided comprising one or more instructions, which when executed by one or more hardware processors causes a method for a

metamodel driven acceleration of actor-based simulated application is provided. The method includes one or more steps such as receiving a description, an execution log, and a configuration of a simulated application from a user, and parsing the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application. Wherein, the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, fixed interaction among the set of actors, and changing interactions among the set of actors. Further, the processor-implemented method comprising mapping the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, and selecting a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
[009] It is to be understood that the foregoing general descriptions and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.
BRIEF DESCRIPTION OF THE DRAWINGS
[010] The accompanying drawings, which are incorporated in and constitute a part of this disclosure, illustrate exemplary embodiments and, together with the description, serve to explain the disclosed principles:
[011] FIG. 1 illustrates an exemplary system for a metamodel driven acceleration of actor-based simulated application, according to an embodiment of the present disclosure.
[012] FIG. 2 is a functional block diagram of the system for a metamodel driven acceleration of actor-based simulated application, according to an embodiment of the present disclosure.
[013] FIG. 3 is a schematic diagram to illustrate composition of one or more actors involved in interaction, according to an embodiment of the present disclosure.
[014] FIG. 4 is a flow diagram to illustrate a method for a metamodel

driven acceleration of actor-based simulated application, in accordance with an embodiment of the present disclosure.
DETAILED DESCRIPTION OF EMBODIMENTS [015] Exemplary embodiments are described with reference to the accompanying drawings. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. Wherever convenient, the same reference numbers are used throughout the drawings to refer to the same or like parts. While examples and features of disclosed principles are described herein, modifications, adaptations, and other implementations are possible without departing from the scope of the disclosed embodiments.
[016] An Enterprise Digital Twin (EDT) or a simulated application is a virtual, high fidelity representation of complex system of systems that is amenable to rigorous quantitative analysis through what-if and if-what scenario playing using real data to facilitate local optimality, global robustness, and continuous learning. The simulated application models an enterprise as a set of actors that interact with each other and respond to the events of interest taking place in the environment. Actors can exist at different levels of granularity i.e. an actor can be seen as a composition of a set of next-level actors. The actor observes the environment, makes sense of the observations, and performs actions so as to achieve its objectives. The action could be changing the local state of actor or sending a message to other actors. These actions can be stochastic to model uncertainty. The actor is capable of adapting its behavior in response to the changes in its environment. Essentially, the actor has a set of situation-specific behaviours, and it is able to switch from one behavior to another depending on the situation it finds itself in. The actor adapts its behaviour not only to achieve its objectives but also to ensure robustness of the overall system.
[017] It would be appreciated that the simulators allow for extensive logging for debugging and understanding purposes. An actor based model of concurrent computation wherein the actor, in response to a message that it receives can make local decisions, create more actors, send more messages, and determine

how to respond to the next message received. The actor may modify their own private state but can only affect each other through messages avoiding the need for any locks.
[018] Usually, the simulated application is a set of actors each comprising a message queue. The actors enqueue messages to another actors’ queue to whom they want to interact with. Further, the actors successively dequeue messages from their queue and handle them all in order of dequeuing. Herein, this approach of interacting using the message passing is used by all actor based simulators. For example, if COVID propagation is simulated, then people may emulate as actors who are interacting with each other. The interaction is accomplished as the message passing between actor objects. However, in a warehouse simulation, the actors emulate products, racks, forklift machines, human pickers etc. Depending on the application the bottleneck of performance may appear at a different module of the simulated application and requires different approach of handling.
[019] The embodiments herein provide a method and system for a metamodel driven acceleration of actor-based simulated application. Herein, exposing one or more characteristics of the simulated application in the form of a metamodel. This metamodel information can be used by the actor-based simulator to employ suitable accelerations for the simulated application. In terms of implementation and execution, all the applications are handled equally by the actor based simulator. However, individual application exposes acceleration opportunities unique to that application. Further, the system and method also employ different acceleration mechanisms and schemes suited for the acceleration of the simulated application to accelerate already designed and implemented actor based simulation technique.
[020] Referring now to the drawings, and more particularly to FIG. 1 through FIG. 4, where similar reference characters denote corresponding features consistently throughout the figures, there are shown preferred embodiments and these embodiments are described in the context of the following exemplary system and/or method.
[021] FIG. 1 illustrates an exemplary system (100) for a metamodel driven

acceleration of actor-based simulated application, in accordance with an example embodiment. Although the present disclosure is explained considering that the system (100) is implemented on a server, it may be understood that the system (100) may comprise one or more computing devices (102), such as a laptop computer, a desktop computer, a notebook, a workstation, a cloud-based computing environment and the like. It will be understood that the system (100) may be accessed through one or more input/output interfaces 104-1, 104-2... 104-N, collectively referred to as I/O interface (104). Examples of the I/O interface (104) may include, but are not limited to, a user interface, a portable computer, a personal digital assistant, a handheld device, a smartphone, a tablet computer, a workstation, and the like. The I/O interface (104) are communicatively coupled to the system (100) through a network (106).
[022] In an embodiment, the network (106) may be a wireless or a wired network, or a combination thereof. In an example, the network (106) can be implemented as a computer network, as one of the different types of networks, such as virtual private network (VPN), intranet, local area network (LAN), wide area network (WAN), the internet, and such. The network (106) may either be a dedicated network or a shared network, which represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), and Wireless Application Protocol (WAP), to communicate with each other. Further, the network (106) may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices. The network devices within the network (106) may interact with the system (100) through communication links.
[023] The system (100) supports various connectivity options such as BLUETOOTH®, USB, ZigBee, and other cellular services. The network environment enables connection of various components of the system (100) using any communication link including Internet, WAN, MAN, and so on. In an exemplary embodiment, the system (100) is implemented to operate as a stand-alone device. In another embodiment, the system (100) may be implemented to work as a

loosely coupled device to a smart computing environment. Further, the system (100) comprises at least one memory (110) with a plurality of instructions, one or more databases (112), and one or more hardware processors (108) which are communicatively coupled with the at least one memory (110) to execute a plurality of modules (114) therein. The plurality of modules (114) include an application executor module (116), an information extraction module (118), an interaction topology extraction module (120), and a composition extraction module (122). The plurality of modules (114) are configured to extract actors’ information, actor interaction topology and compositions of the set of actors. The plurality of modules (114) take application log as input and generates respective outputs. The output of the plurality of modules (114) tags the simulated application in any one of the category/types. The components and functionalities of the system (100) are described further in detail.
[024] The one or more I/O interfaces (104) are configured to receive a description, an execution log, and a configuration of a simulated application from a user. Herein, each simulated application includes a set of actors involved in interactions. The execution log contains information like interaction, initialization, and termination of the set of actors. Further, the execution log has entry and exit timestamp of each of the actor along with its unique identifier. Also, when at least one actor from the set of actors interacts with another, the unique identifier of sender and receiver, timestamp and message details are stored in the execution logs.
[025] Further, the system (100) is configured to parse the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application. The one or more characteristics of the simulated application includes a fixed set of actors, a changing set of actors, fixed interactions among actors in the set of actors, changing interactions among the set of actors.
[026] In one example for a fixed set of actors and their interactions among themselves, wherein simulating a factory machinery like large boilers. In such simulations the set of actors are boiler sensors, actuators, controllers etc. The number of actors remain fixed. Also, the interaction among the number of actors

also remain fixed such as a lever controller pushes or pulls the same part every time and a sensor send signals to same controllers every time. It would be appreciated that each simulated application is different from other. The pattern of interactions among the set of actors may vary in various simulated applications. For example, a star topology, a mesh topology, a ring topology etc. Similarly, life span of the set of actors may vary at any point of time in complete simulation timeframe.
[027] In another example for a changing set of actors and their interactions, wherein simulating a city’s public transport infrastructure assumes the set of actors like public buses, metro trains, road and rail infrastructure and the people operating and using them. In this simulation a first set of actors remain fixed (people, buses, roads), however a second set of actors are dynamic such as people using public transport may change, new bus routes may be introduced, traffic signals may be installed or removed etc.
[028] Referring FIG. 2, illustrates a functional block diagram (200) of the system (100) for a metamodel driven acceleration of actor-based simulated application, in accordance with an example embodiment.
[029] In one embodiment, wherein the simulated application can be characterized based on the one or more properties of the simulated application such as composition of the set of actors, number of actors, and interaction patten among the set of actors. Herein, the compositions of the set of actors can be defined by a location or a path and these compositions can be of fixed or changing nature. The set of actors can be same throughout life cycle of the simulated application or it may change at any stage of the life cycle.
[030] In another embodiment, wherein the information extraction module (118) of the system (100) reads execution log file and fetches birth and death timestamp of the set of actors along with its unique identifier. Further, the interaction topology extraction module (120) of the system (100) reads execution log file and fetches details of interaction among the set of actors, which includes sender and receiver actor’s unique identifier, message type, message unique identifier and timestamp of message. Herein, the topology of interaction is identified from fetched details.

[031] In yet another embodiment, wherein the composition extraction module (122) of the system (100) is configured to find composition of the set of actors of the simulated application. Further, the system (100) is configured to map the simulated application to a metamodel by using fetched birth and death timestamp of the set of actors along with its unique identifier, details of interaction among the set of actors, the topology of interaction and the composition of the set of actors. Herein, the mapping of the simulated application is required to derive nature of the simulated application. Once the nature of the simulated application is deuced from the metamodel, the possible accelerations can be determined. It would be appreciated that the certain acceleration approach is applicable based on the nature of the simulated application.
[032] Furthermore, the application executor module (116) of the system (100) configured to execute the simulation application and manages input/output. It is to be noted that based on the nature of the simulated application there may be a possible set of acceleration approaches which might already be discovered. These already discovered acceleration approaches may be applied to the current simulated application to achieve the acceleration. While performing this process of acceleration certain new acceleration approaches may also be discovered. Such newly discovered acceleration approaches may then be associated with the nature of the simulated application for which they were discovered and used in future based on the nature of simulated applications.
[033] Referring FIG. 3, a schematic diagram (300), illustrating composition of one or more actors involved in interaction, in accordance with an example embodiment. Herein, the metamodel captures the underlying activity happening in the simulated application. It would be appreciated that every simulation is composition of actors involved in interactions. Depending on the application, the composition can be fixed or changing, and interaction can be fixed or random.
[034] In one example, illustrating the information extraction module (118) and an interaction topology extraction module (120) of the system (100) by considering warehouse simulation application. When new picker actor is introduced

in the system (100), the unique identifier (‘picker-ABC0001’) and timestamp (10:08:52.664) can be fetched by the actor information extraction module from the execution log. When any actor (‘Forklift-ABC991’) gets added in queue of staging area (‘StageArea-ABC-556’), these two unique identifiers of sender and receiver along with message id (‘JoinQueue’) and the timestamp will be fetched by the interaction topology extraction module (120) from the execution log file.
[035] In another example, illustrating a simulation involving telecom operator, wherein the set of actors are the enterprise and the subscribers. Further, the enterprise includes actors like billing actor, customer care actor. The subscriber actor can interact with customer care actor to get billing information which further involves a customer care actor to interact with billing actor and get the subscriber actor’s billing details. Depending on the scenario being simulated more actors can be involved such as in simulation involving capacity planning the actors like cell towers, switching stations etc. can also be introduced.
[036] In yet another example illustrating a COVID simulation wherein a healthy person comes in contact with a COVID infected person (actor interaction) and gets infected with a certain probability. The interaction among the actor representing the healthy person and actor representing an unhealthy person can happen in places like public transport buses, buildings, office spaces, schools, colleges, etc. each of which is itself represented as actor. The simulation also includes hospitals and doctors as actors which interact with actors representing infected people and make them healthy again with a certain probability.
[037] Referring FIG. 4, to illustrate a processor-implemented method (400) a metamodel driven acceleration of actor-based simulated application.
[038] Initially, at the step (402), receiving, via an input/output interface, a description, an execution log, and a configuration of a simulated application from a user, wherein the simulated application includes a set of actors.
[039] At the next step (404), parsing the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application. Wherein the one or more characteristics of the simulated application include a fixed set of actors, a changing

set of actors, an interaction among the fixed set of actors, and an interaction among the changing set of actors.
[040] At the next step (406), mapping the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application. Wherein the nature of the simulated application includes interaction pattern among the set of actors, and composition of the set of actors.
[041] At the next step (408), selecting a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
[042] The written description describes the subject matter herein to enable any person skilled in the art to make and use the embodiments. The scope of the subject matter embodiments is defined by the claims and may include other modifications that occur to those skilled in the art. Such other modifications are intended to be within the scope of the claims if they have similar elements that do not differ from the literal language of the claims or if they include equivalent elements with insubstantial differences from the literal language of the claims.
[043] The embodiments of present disclosure herein address unresolved problem of an automated way of finding the potential acceleration approach for a given simulated application. Embodiments herein provide a method and system for a metamodel driven acceleration of the simulated application. It brings a structure and automation in the way that the potential acceleration approaches for the simulation applications are identified. The disclosure also provides a way in which the discovered acceleration approaches can be categorized and reused for future applications. Once discovered a new acceleration approach becomes part of the system.
[044] It is to be understood that the scope of the protection is extended to such a program and in addition to a computer-readable means having a message therein; such computer-readable storage means contain program-code means for implementation of one or more steps of the method, when the program runs on a server or mobile device or any suitable programmable device. The hardware device

can be any kind of device which can be programmed including e.g., any kind of computer like a server or a personal computer, or the like, or any combination thereof. The device may also include means which could be e.g., hardware means like e.g., an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or a combination of hardware and software means, e.g., an ASIC and an FPGA, or at least one microprocessor and at least one memory with software modules located therein. Thus, the means can include both hardware means, and software means. The method embodiments described herein could be implemented in hardware and software. The device may also include software means. Alternatively, the embodiments may be implemented on different hardware devices, e.g., using a plurality of CPUs.
[045] The embodiments herein can comprise hardware and software elements. The embodiments that are implemented in software include but are not limited to, firmware, resident software, microcode, etc. The functions performed by various modules described herein may be implemented in other modules or combinations of other modules. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can comprise, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
[046] The illustrated steps are set out to explain the exemplary embodiments shown, and it should be anticipated that ongoing technological development will change the manner in which particular functions are performed. These examples are presented herein for purposes of illustration, and not limitation. Further, the boundaries of the functional building blocks have been arbitrarily defined herein for the convenience of the description. Alternative boundaries can be defined so long as the specified functions and relationships thereof are appropriately performed. Alternatives (including equivalents, extensions, variations, deviations, etc., of those described herein) will be apparent to persons skilled in the relevant art(s) based on the teachings contained herein. Such alternatives fall within the scope of the disclosed embodiments. Also, the words “comprising,” “having,” “containing,” and “including,” and other similar forms are

intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms “a,” “an,” and “the” include plural references unless the context clearly dictates otherwise.
[047] Furthermore, one or more computer-readable storage media may be utilized in implementing embodiments consistent with the present disclosure. A computer-readable storage medium refers to any type of physical memory on which information or data readable by a processor may be stored. Thus, a computer-readable storage medium may store instructions for execution by one or more processors, including instructions for causing the processor(s) to perform steps or stages consistent with the embodiments described herein. The term “computer-readable medium” should be understood to include tangible items and exclude carrier waves and transient signals, i.e., be non-transitory. Examples include random access memory (RAM), read-only memory (ROM), volatile memory, nonvolatile memory, hard drives, CD ROMs, DVDs, flash drives, disks, and any other known physical storage media.
[048] It is intended that the disclosure and examples be considered as exemplary only, with a true scope of disclosed embodiments being indicated by the following claims.

We Claim:
1. A processor-implemented method (400) for a metamodel driven
acceleration of actor-based simulated application comprising steps of:
receiving (402), via an input/output interface, a description, an execution log, and a configuration of a simulated application from a user, wherein the simulated application includes a set of actors;
parsing (404), via one or more hardware processors, the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application;
mapping (406), via the one or more hardware processors, the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, wherein the nature of the simulated application includes interaction pattern among the set of actors, and composition of the set of actors; and
selecting (408), via the one or more hardware processors, a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
2. The processor-implemented method (400) of claim 1, further comprising:
fetching a birth and a death timestamp of each of the set of actors along with corresponding unique identifiers;
extracting details of interactions among the fixed set of actors and the changing set of actors, wherein the details of interactions include unique identifiers of a sender and a receiver actor, a message type, and a birth timestamp of the message; and
identifying a topology of the interactions among the fixed set of actors and the changing set of actors based on the extracted details of the interactions.

3. The processor-implemented method (400) of claim 1, wherein the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, fixed interaction among the set of actors, and changing interactions among the set of actors.
4. The processor-implemented method (400) of claim 1, wherein the simulated application is modelled as a composition of the set of actors involved in the interactions.
5. The processor-implemented method (400) of claim 1, wherein the predefined metamodel captures underlying one or more activities happening in the simulated application.
6. A system (100) for a metamodel driven acceleration of actor-based simulated application comprising:
an input/output interface (104) to receive a description, an execution log, and a configuration of an application to be simulated from a user, wherein each simulation includes one or more actors involved in interactions;
one or more hardware processors (108);
a memory (110) in communication with the one or more hardware
processors (108), wherein the one or more hardware processors (108) are
configured to execute programmed instructions stored in the memory, to:
parse the received description, the execution log, and the
configuration of the simulated application to determine one or more
characteristics of the simulated application;
map the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, wherein the nature of the simulated application includes interaction pattern among the set of actors, and composition of the set of actors; and

select a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
7. The system (100) of claim 6, further comprising:
fetching a birth and a death timestamp of each of the set of actors along with corresponding unique identifiers;
extracting details of interactions among the fixed set of actors and the changing set of actors, wherein the details of interactions include unique identifiers of a sender and a receiver actor, a message type, and a birth timestamp of the message; and
identifying a topology of the interactions among the fixed set of actors and the changing set of actors based on the extracted details of the interactions.
8. The system (100) of claim 6, wherein the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, an interaction among the fixed set of actors, and an interaction among the changing set of actors.
9. A non-transitory computer readable medium storing one or more instructions which when executed by one or more processors on a system, cause the one or more processors to perform method comprising:
receiving, via an input/output interface, a description, an execution log, and a configuration of a simulated application from a user, wherein the simulated application includes a set of actors;
parsing, via one or more hardware processors, the received description, the execution log, and the configuration of the simulated application to determine one or more characteristics of the simulated application, wherein the one or more characteristics of the simulated application include a fixed set of actors, a changing set of actors, fixed

interactions among the set of actors, and changing interaction among the set of actors;
mapping, via the one or more hardware processors, the one or more determined characteristics of the simulated application to a predefined metamodel to determine a nature of the simulated application, wherein the nature of the simulated application includes interaction pattern among the set of actors, and composition of the set of actors; and
selecting, via the one or more hardware processors, a set of accelerations based on the determined nature of the simulated application to minimize simulation time, resource required, and manual intervention.
10. The non-transitory computer readable medium of claim 9, further comprising:
fetching a birth and a death timestamp of each of the set of actors along with corresponding unique identifiers;
extracting details of interactions among the fixed set of actors and the changing set of actors, wherein the details of interactions include unique identifiers of a sender and a receiver actor, a message type, and a birth timestamp of the message; and
identifying a topology of the interactions among the fixed set of actors and the changing set of actors based on the extracted details of the interactions.