toward an aspect-oriented simulation

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085)

TOWARD AN ASPECT-ORIENTED SIMULATION Meriem Chibani(1)- Brahim Belattar (2) and Abdelhabib Bourouis(3) (1) (3) Department of Mathematics and Computer Science University of Oum El Bouaghi, Oum El Bouaghi, 4000, Algeria (2) Department of Computer Science, University of Batna, Batna, 5000, Algeria [email protected] [email protected] [email protected] ABSTRACT Discrete event simulation (DES) projects implement several crosscutting concerns, such as event scheduling, event handling, and keeping track of a simulation’s state which tend to produce a tangling and scattering simulation code. This increases the complexity and reduces the maintainability which requires specific separation of concerns (SOC). The aspect oriented programming (AOP) paradigm puts a greater focus on crosscutting concerns than other language paradigms. It provides language mechanisms such as the prominent AspectJ, that explicitly capture crosscutting concerns in a modular way and thus achieving the benefits that results from improved modularity; code that is easier to design, implement, maintain, reuse and evolve. In this paper, we present the most benefits of using the aspect oriented programming paradigm in the simulation modeling field. Besides that, we identify the main crosscutting concerns for a discrete event simulator.

KEYWORDS Crosscutting concerns, separation of concerns, aspect oriented programming, discrete event simulation, AspectJ.

1INTRODUCTION Simulation is the imitation which involves the generation of an artificial history of the system to draw inferences concerning the main characteristics of the real system that is represented. It is

used to describe and analyze the behavior of the real system, thus it answers the questions what-if? [1]. Today, object-oriented simulation is considered one of the most sophisticated techniques that has been widely used in most engineering disciplines. This technique enables the modeler to focus on objects which is extremely important for thorough understanding of a system. Its roots go back to the simulation language SIMULA. Although the object oriented simulation provides a rich and intuitive paradigm for building models of real-world systems, it suffers from the inherent weakness of object-oriented programming (OOP) methodology which is the inability to modularize all concerns. The limitation of the OOP approach is its inability to localize concerns that do not naturally fit into a single program module, or even several closely related modules. Such concerns are defined crosscutting concerns as they cross-cut or span multiple (often unrelated) implementation modules. OOP code suffers from two phenomena’s (resulting from misalignment between requirements and code); tangling and scattering. Tangling occurs when multiple concerns are addressed in a single module (or class), making the module harder to understand and maintain. Scattering results occur when the implementation of a concern is spread over multiple modules, leading to the risk of inconsistencies at each point of use. The AOP paradigm puts a greater

1

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) focus on crosscutting concerns than OOP and other language paradigms. It provides language mechanisms that explicitly capture crosscutting concerns in a modular way and thus achieving the benefits that results from improved modularity; code that is easier to design, implement, maintain, reuse and evolve. AOP introduces the notion of aspect, a well-modularized crosscutting concern, and shows how we can take crosscutting concerns out of modules and place them in a centralized location [2]. Discrete event simulators implement a number of concerns, such as event scheduling, event handling, and keeping track of a simulation’s state which crosscut over multiple modules in the system. This increases the complexity and reduces the maintainability [3]. In this paper, we demonstrate the benefits of using the aspect oriented programming paradigm in discrete event simulation by discussing various precedent works and identifying the main crosscutting concerns that may affect the functional core of simulation systems. The rest of the paper is organized as follows. Section 2 recalls some basic notions about DES and AOP. Section 3 describes briefly the benefits of using the aspect oriented paradigm in DES. Section 4 discusses the main crosscutting concerns that may affect DES systems. Section 5 presents a motivation example and finally a conclusion with some directions to our future work is given in Section 6. 2BACKGROUND In this section, we recall some basic notions about discrete event simulation and the aspect oriented programming paradigm.

2.1 Discrete event simulation There are three types of simulations that are used according to time criterion: continuous, Monte-Carlo simulation and discrete-event simulation. The last one is used to model a system whose global state changes as a function of time, namely. Its global state is updated according to events occurrences. Each discrete event simulator requires at least some of the following components [4]: • Event scheduler: It manages the list of all pending events by activating or suspending associated routines at the appropriate time. Furthermore, it updates the global simulation time variable. • The global time variable: It records the current simulation time. It could be updated by the scheduler according to fixedincrement approach or eventdriven one. • Event processing: Each event has its own event-processing routines that represent what happens when the event occurs. These routines may change the global state or generate additional events that must be inserted into the event scheduler list. • Event generation mechanisms: There are three techniques to generate events: execution driven, trace driven and distribution driven. • Data recording and summarization routines: In addition to maintaining state variables, the simulator must also keep temporal measurements and events recordings. These values are used to calculate statistics

2

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) that summarize simulation results. For creating a discrete event simulator there are three main modeling worldviews adopted by the simulation community which are Process Interaction, Event Scheduling, and Activity Scanning [1]: • Process Interaction method: It has the greatest intuitive appeal. It consists of a collection of interacting processes. Each process models the life cycle of a system’s object, namely, a well ordered sequence of activities which are logically related. • Event scheduling method: It defines all relevant events and the related changes (actions) that must take place for each one. • Activity Scanning method: The third modeling structure defines all the activities that may be undertaken by the system‘s objects. Actions to achieve at the beginning and end of each activity, and the duration of each one.

• Aspectual decomposition: decomposes the requirements to identify crosscutting concerns. • Concern implementation: implements each concern separately. • Aspectual recomposition: specifies the recomposition rules and uses this information to compose the final system. It introduces two new elements to the set of standard tools used in the development of a software system which are aspect language and aspect weaver. The aspect language is the language used solely to program the aspects and differs from the basic language which programs the functional core of the application. The function of the aspect weaver is to weave the aspects and the functional code together. The output is a combination of the two languages which is the executable program. Actually, AspectJ is the de facto language. It is an aspect-oriented extension to Java where a number of new concepts are added as joinpoints, pointcuts, advices and aspects [2]. 3THE GOAL BEHIND THE USE OF AOP PARADIGM IN DES

2.2 Aspect oriented programming The aspect oriented programming paradigm introduced by Cristina Lopes and Gregor Kiczales in 1996 as one of the most powerful paradigm as generative programming, metaprogramming, reflective programming, compositional filtering, adaptive programming, subject-oriented programming, and intentional programming that emerged to cover the weakness of the object oriented paradigm to satisfy the separation of concerns principle (SOC) [5]. AOP involves three different development stages:

The AOP paradigm requires thinking about the system design and implementation, in a new way that provides a lot of benefits, as cleaner responsibilities of individual module, higher modularization, easier system evolution, late binding of design decisions, more code reuse, improved time-to-market, and reduced costs of feature implementation [6]. These benefits make this technology useful in several academic and industrial domains. In an effort to shed the light on different applications of this paradigm in the DES domain as discussed in [7], we conclude that the use of the latter is around two

3

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) main axes, the first is increasing system’s reusability and the second is developing large simulation software with less complexity. 3.1 Increasing the system reusability Several approaches are proposed to develop clear and reusable simulation systems. They adopt different philosophies as for instance, the separation between the model and the observational mechanisms, creation of generic systems and separation between models and scenarios. The multi-agent simulation system discussed in [8] and [9] consists of two types of agents: agents for the description of the simulation model and agents for observational mechanisms. This collection of independent agents is interacting with discrete events where every agent has a schedule that generates its plan of activities. The system is executed on Telemodeling framework which uses an object-oriented paradigm to define its multi-agent models and web technology to make ease to use modeling and simulation environment. The kernel of this framework is the programming language MAML1 (Multi-Agent Modeling Language) which has the capacity of the dissociation between the model and the observational mechanisms, thanks to the aspect oriented paradigm, from the design phases until the implementation phase, thereby increasing the maintainability of the system and decrease its complexity. MAML has the xmc compiler which generates Objective-C code from the MAML source code after weaving the model object and observation object. 1

MAML is a domain specific programming language that is designed to build computer simulation based on Swarm simulation package

In [10], the authors use the aspect oriented paradigm to develop a multiagent system dedicated to simulate physical phenomena. The MAFES system (Multi Agent Finite Environment System) consists of an environment in the form of the node matrix and a set of agents operating on these nodes where aspects are used to assign tasks to agents by adding appropriate functionality to perform their task. In addition, the aspects weave the appropriate resources and attributes to the environments nodes. MAFES contains three others type of aspects for control, visualization and storing simulation results. MAFES is implemented using the AspectJ language. The use of the AOP makes the system generic to build versions for specific requirements (it is enough to weave appropriate aspects). The authors experiment their system with two phenomena. The first is heat exchange and a motion phenomenon. The second is heat exchange and crystallization. Judicaël and Olivier [11] discuss the development of advanced simulation scenarios by means of new software engineering techniques using AOP paradigm and the Architecture Description Language (ADL) designed for the Fractal component model. These new techniques enforce the separation between models and scenarios which allows better reuse of components in both parts: reuse of a given model with various scenarios, or reuse of a given scenario with various models in order to save time, money and human effort. The authors use the Open Simulation Architecture (OSA) which is a discreteevent simulator, to illustrate the benefits of the previous techniques by simple use cases of network security studies. In addition to OSA there is another component-based instrumentation

4

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) framework OSIF [12] that supports the separation between model and experimental frame using AOP paradigm which enables software reuse and evolution. Furthermore, it is based on several mature software engineering techniques and frameworks, such as COSMOS, Fractal and its ADL which makes OSIF a generic framework that could be integrated in any simulator (e.g. OSA). 3.2 Developing large simulation software It could be achieved by adding several crosscutting concerns to the system like distribution, synchronization, logging and so on, but in the same time, keeping its performance and clarity. Among the proposed systems, we mention the disaster prevention simulation system and the conduit simulator. In [13], the authors address a new aspect-oriented approach for disaster prevention simulation system (ABR2). The proposed approach separates the core functionality of the simulation application from simulation crosscutting concerns thanks to Horizontal decomposition (HD) method which relies on the AOP paradigm. The approach is implemented on AoSiF (Aspect oriented Simulation Framework) which is an extension of distributed simulation framework (DiSiF) [14]. It uses the resource paradigm, actor based workflow modeling, web services and Grid computing as implementation technology and Java Annotations for declarative programming in addition to AspectJ for the aspect-oriented implementation. To demonstrate the 2

ABR serves as an early warning system for emergency situations at nuclear power plants. It calculates the concentration of pollutants substances in the atmosphere

applicability of their approach, they implemented two crosscutting concerns, namely distribution and tool integration. In [15] the same authors with Alexandru complete the implementation of other crosscutting concerns: Job Execution and Fault-Tolerance in addition to tool integration concern. The approach affirms its efficiency in the term of increasing the reusability and the maintainability through experiments in the DAS-33 multi- cluster grid. In [16], the authors implement the conduit simulators which use the AOP paradigm based on Logic Metaprogramming (LMP) at the code level. The simulator implements its crosscutting concerns (synchronizing and order of execution, user interface (UI) and logging) in different aspectspecific languages (ASLs) and thanks to logic modules which encapsulate aspects and the implementation of ASLs. The simulator gains a modular aspect-weaver mechanism that offers the generality of a general-purpose aspect language without losing the ability and advantages of defining aspects in aspect-specific languages. The simulator uses the SOUL/Aop system which is a prototype aspect-weaver in Smalltalk. In the beginning, the use of the AOP paradigm in the discrete event simulation modeling domain was limited to the implementation level and with the apparition of AOSD technique, it spreads over the different steps of simulation software development: requirements, specification, design, and test levels. In [17], the aspect oriented paradigm is used at scenario-based requirements level where interactions model with 3

DAS-3, The Distributed ASCI Supercomputer 3, is a widearea distributed cluster designed by the Advanced School for Computing and Imaging (ASCI) in The Netherlands http://www.cs.vu.nl/das3

5

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) aspects in a way that they can be immediately validated using simulation methods. Scenarios are modeled as UML sequence diagrams (non-aspectual interactions) and interactions that crosscut other interactions are modeled as Interaction Pattern Specifications (IPSs) which describe a pattern of structure or behavior and they are defined in terms of roles. After the aspectual and non-aspectual interactions are composed by instantiating the aspects, the resulting set of interactions is translated automatically into a set of executable UML state machines. Whereas in [18], the composition is done at the state machine level. The authors used Error-handling crosscutting concern to illustrate their technique. In [19], the authors discuss a new approach for separation of functional (qualitative) behavior and quantitative performance constraints since the specification phase. Thanks to AOP, the aspects of a specification are written in different languages, the process algebra LOTOS for an abstract specification of functional behavior and the probabilistic temporal logic for quantitative aspects (performance constraints). The aspect weaving composes the two aspect specifications and the result of this composition is an automata-style global model which could be generated from the composition of a labeled transition system (derived from LOTOS). Event schedulers are derived from temporal logic formulae. Finally the global model could be used for performance analysis based simulation. In [20], Daesung and Kang propose a simulation based design level performance analysis method where the performance concern of the software application is separated from the functionality model since the design

phase by the use of aspect oriented programming. Unlike the design of the software system which is modeled using UML class diagrams and sequence diagrams, the performance model is an XML-based representation derived from the UML performance profile. After code generation from the design model, the AspectJ weaver is introduced in order to formulate the simulation code. The authors experiment their approach using a distributed map viewer system. In [21] they argue that their approach is generic and could be used for analysis of other quality attributes of software systems as reliability and performance concerns. In [22], another approach for analyzing performance is proposed. Unlike the precedent approaches, it defines performance as a collection of aspects which include response time, probability, time between errors and so on metrics over aspect-oriented formal design analysis framework (FDAF). The authors focus on modeling the response time performance aspect and they have chosen real-time UML as the base notation which is translated into Architecture Description Language (ADL) Rapide. The authors use the simulation technique to evaluate response time for the DNS query processing subsystem by using Rapide’s analyzing tools. In [23, 24], the authors propose an aspect-oriented framework for agentoriented software that separates the performance concern at the design level using the aSideML language, which is a UML extension for representing aspects at different levels of abstraction. This framework provides separation of performance concerns among the different Agenthood properties (mobility, autonomy, adaptability, interaction, learning), functional and

6

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) non-functional aspects. The design model for scenario specific application concerns and Agenthood concerns has its own Java implementation code while the performance model has a separate AspectJ implementation. Later, these are all woven together using the AspectJ compiler. The framework architecture is composed of ten kinds of components: performance component, agent concerns, the agent platform component, workload and resources, IInformatioGathering (interface of the Performance component get the information from workload and resources components), IperformanceReporting (interface reports the information related to performance to learning agent property). In [25], Hui and Dorina approach studies the performance effects of concrete aspects (e.g. security features) on the overall system performance (in this paper the application is named the Document Exchange Server (DES)). The approach proceeds by adding performance annotations to both the primary and aspect models using the UML performance profile then instantiating the generic aspect model, thereby converting the aspect security model into a context-specific one, by following a set of binding rules provided by the designer which transforms the parametric annotations of the generic aspect model into concrete ones. The latter is composed with the primary model, according to a set of composition directives. The result is a composed annotated UML, which can be transformed automatically into a performance model (Layered Queuing Networks (LQN) in this case) by using the transformation techniques. The LQN model is analyzed with an existing solver.

In [26], an industrial strength ModelDriven Engineering engine, the Motorola WEAVR including the Telelogic TAU modeling and simulation environment is presented. WEAVR combines Aspect-Oriented Modeling and Automated Code Generation technologies. Where fully weave aspects passes at the modeling level. WEAVR uses translation-oriented style of UML 2.0 modeling and including a novel joinpoint model for transition oriented state machines. In [27] new verification method based on simulation is discussed. The method aims to automate the coverage analysis 4 using Aspect-Oriented programming. Aspects here are described as checkers acrossing the system for logging the state transition information over the time during the simulation. In this approach, the Unified Modeling Language (UML2) is used to describe SystemC models and AspectC++ language for aspects implementation. 4 MAIN CROSSCUTTING CONCERNS OF DISCRETE EVENT SIMULATOR Further the functional concerns of DES systems, there exist several nonfunctional concerns that cross applications modules as: • Keeping simulation track • Simulation termination criteria • Persistence: Restoring a Simulation Run • Resource Pooling Concern • Policy concerns • Graphical user interface • Thread scheduling and dispatching • Memory management 4

The coverage analysis is a measure used in software testing. It describes the degree to which the source code of a program has been tested.

7

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) •

• •

Synchronization and resource sharing Asynchronous event handling Steady state detection

5 MOTIVATION EXAMPLE Java PRocess Oriented SIMulation (JAPROSIM) is an open source and a free software simulation framework developed for educational and industrial proposes based on queering network theory, it is used for developing discrete event simulation models using a coroutine mechanism implementation [28]. Japrosim is distributed under GNU Lesser General Public License (LGPLv3) since 2008. Thanks to the efforts of A. Bourouis and B. Belattar, it is currently available under 1.4 version. It is divided into seven main packages which are: kernel, random, distributions, statistics, gui, animation, and utilities package. Although, there are a considerable number of research and development activities in progress in order to enhance this library and improve its capabilities like graphical animation, steady state detection, graphical modeling, explanation, and so on. However, Japrosim structure suffers from the OOP methodology weakness, where different concerns such as data management, error checking, GUI, synchronization, and so forth, cannot always be cleanly separated from each other. Therefore, these concerns are being so intertwined in the library functional core which is known as the "spaghetti" code problem. Several Japrosim classes are infected with the exception handling crosscutting concern for instance: scheduler, SimProcess, and SimApplet classes, thus, this concern pollutes Japrosim code and decreases its performance. In our

case we propose the exception AspectJ aspect for exceptions handling. It includes several advices, each one process a specific exception type as FileNotFoundException, InterruptedException, UnsupportedEncodingException, and IOException as shown in Figure 1.

Figure1. Exception handling Aspect.

Figure2. Affected Japrosim classes with Exception handling aspect.

After the weaving, the exception handling aspect combines with Japrosim functional core as shown in Figure 2

8

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) obtained using the AspectJ Aspect Visualiser5. 6

CONCLUSION

The implementation of the aspect oriented programming paradigm in the simulation modeling domain is considered as a promising research area where that provides many benefits among them: • Reducing software simulation systems complexity by separating the code in various sections (modularity), the complexity is reduced. • Improving software simulation quality at different points of view (maintenance, test, and reuse). In our future work, we aim to propose AOP solutions for separating the crosscutting concerns such as GUI, thread scheduling and dispatching, and asynchronous event handling from the functional core of discrete event simulation systems and developing an AOP Japrosim framework. 7

REFERENCES

1. Banks, J.: Handbook of Simulation. Principles, Methodology, Advances, Applications, and Practice. WileyInterscience (1998). 2. Tsang, S. L.: An Evaluation of AOP for Javabased Real-time Systems development. MSc Thesis. University of Dublin (2003). 3. Aksu, A. U., Belet, F., Özdemir, B.: Developing Aspects for a Discrete Event Simulation System. In: Proc. Third Turkish Aspect-Oriented Software Development Workshop, pp. 84--93, Bilkent University, Ankara, Turkey (2008). 4. Lilja, J. D.: Measuring Computer Performance: A Practitioner's Guide, Cambridge University Press, Cambridge (2000). 5

Aspect Visualiser is a part of AspectJ Development Tools (AJDT). It is used to visualize how aspects affecting classes in an AspectJ project.

5. Laddad, R.: AspectJ in Action: Enterprise AOP with Spring Applications. Second Edition, Manning Publications, Greenwich, USA (2009). 6. Laddad, R.: AspectJ in Action Practical Aspect-Oriented Programming. Manning Publications, (2003). 7. Chibani, M., Belattar, B., Bourouis, A.: The Use Of The Aspect Oriented Programming (AOP) Paradigm In Discrete Event Simulation Domain: Overview And Perspectives. In: Proc. The Third International Conference on Digital Information Processing and Communications (ICDIPC2013), SDIWC - Digital Library, pp. 653—660, Dubai (2013). 8. Gulyás, L., Kozsik, T.: The use of aspectoriented programming in scientific simulations. In: Jaan Penjam, editor, Software Technology, Fenno-Ugric Symposium (FUSST'99), pp. 17--28, Tallinn, Estonia (1999). 9. Gulyás, L., Kozsik, T., Corliss, J.B: The Multi-Agent Modelling Language and the Model Design Interface. In: Proc. 4th International Conference on Applied Informatics (ICAI'99), Emőd Kovács and Zoltán Winkler, editors, pp. 43--50, EgerNoszvaj, Hungary (1999). 10. Bieniasz, S., Ciszewski S., Śnieżyśki B.: Multi-agent Simulation of Physical Phenomena by Means of Aspect Programming. In: Proc. The 6th international conference on Computational Science. Vassil N. Alexandrov (eds.) ICCS 2006. LNCS, vol. 3993, pp. 759—766, SpringerVerlag, Heidelberg (2006). 11. Ribault, J., Dalle, O.: Enabling advanced simulation scenarios with new software engineering techniques. In: 20th European Modeling and Simulation Symposium (EMSS 2008), Briatico, Italy (2008). 12. Ribault, J., Dalle, O., Conan, D., Leriche, S.: OSIF: A Framework To Instrument, Validate, and Analyze Simulations. In: Proc. L. Felipe Perrone, Giovanni Stea, Jason Liu, Adelinde Uhrmacher, Manuel Villèn-Altamirano. (eds.) 3rd International Conference on Simulation Tools and Techniques, SIMUTools '10, pp. 56--56, Malaga, Spain (2010). 13. Ionescu, T.B., Piater, A., Scheuermann, W., Laurien, E.: An Aspect-Oriented Approach for the Development of Complex Simulation Software. Journal of Object Technology, Vol. 9, no. 1 (January 2010), pp. 161--181,

9

International Journal of New Computer Architectures and their Applications (IJNCAA) 3(1): 1-10 The Society of Digital Information and Wireless Communications (SDIWC) 2013 (ISSN: 2220-9085) doi:10.5381/jot.2010.9.1.a4. (2010). 14. Piater A., Ionescu T.B., Scheuermann, W.: A Distributed Simulation Framework for Mission Critical Systems in Nuclear Engineering and Radiological Protection, International Journal of Computers Communications & Control, ISSN 18419836, vol. 3, no. 1, pp. 448—453. (2008). 15. Ionescu, T.B., Piater, A., Scheuermann, W., Laurien, E., Iosup, A.: An Aspect-Oriented Approach for Disaster Prevention Simulation Workflows on Supercomputers. In: Proc. 13th IEEE/ACM International Symposium on Distributed Simulation and Real Time Applications, pp. 21--30, IEEE Computer Society (2009). 16. Brichau, J., Mens, K., Volder, K. D.: Building Composable Aspect-specific Languages with Logic Metaprogramming. In: Proc. The 1st ACM SIGPLAN/SIGSOFT conference on Generative Programming and Component Engineering GPCE’02, Vol. 2487, pp. 110—127, Springer-Verlag, London (2002). 17. Araújo, J., Whittle, J., Kim, D.K.: Modeling and Composing Scenario-Based Requirements with Aspects. In: Proc. The 12th IEEE International Conference on Requirements Engineering RE '04, pp. 58-97. IEEE Computer Society Washington, DC, USA (2004). 18. Whittle, J., Araújo, J., Kim, D.K.: Modeling and Validating Interaction Aspects in UML. In: Proc. 4th AOSD Modeling With UML Workshop, 6th International Conference on the Unified Modeling Language (UML2003), San Francisco, USA, ACM (2003). 19. Blair, L., Blair, G., Andersen, A.: Separating Functional Behaviour and Performance Constraints: Aspect Oriented Specification. Internal Report No. MPG-98-07, http://www.comp.lancs.ac.uk/computing/user s/lb/vqos.html (1998). 20. Park, D., Kang, S.: Design Phase Analysis of Software Performance Using AspectOriented Programming. In: Proc. 5th International Workshop on Aspect-Oriented Modeling in conjunction with the 7th International Conference on the UML, Lisbon, Portugal (2004). 21. Park, D., Kang, S., Lee, J.: Design Phase Analysis of Software Qualities Using AspectOriented Programming. In: Proc. Seventh International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed

Computing (SNPD 2006), pp. 29--34, IEEE, Computer Society, Las Vegas, Nevada, USA (2006). 22. Cooper, K., Dai, L., Deng, Y.: Modeling Performance as an Aspect: a UML Based. Approach. In: Proc. The 4th AOSD Modeling With UML Workshop, San Francisco, California, USA (2003). 23. Mehmood, T., Ashraf, N., S.Tauseef-urRehman. : Framework for Separating Performance Concerns and Improved Modularity in Multi agent systems (MAS) using Aspect Oriented Programming (AOP). In: Proc. Workshop Of Software Engineering Properties of Languages and Aspect Technologies in conjunction with the Fourth International Conference on Aspect-Oriented Software Development (AOSD2005), Hamid R. Arabnia and Hassan Reza (eds), Vol. 2, pp. 754--757, Las Vegas, Nevada, USA (2005). 24. Mehmood, T., Ashraf, N., Rasheed, K., S. Tauseef-ur-Rehman: Framework for Modeling Performance in Multi Agent Systems (MAS) using Aspect Oriented Programming (AOP). In: Proc. The Sixth Australasian Workshop on Software and System Architectures (AWSA 2005), pp. 40-45, Brisbane (2005). 25. Shen, H., C. Petriu, D.: Performance Analysis of UML Models Using AspectOriented Modeling Techniques. In: Proc of the 8th international conference on Model Driven Engineering Languages and Systems MoDELS’05, pp. 156--170. Springer-Verlag, Berlin (2005). 26. Cottenier, T.: Aspect-Oriented Modeling and simulation, tutorial available at: http://www.iit.edu/concur/weavr/documentati on.html. 27. Chen, Y., Qiu, W., Zhou, B., Peng, C.: An Automatic Test Coverage Analysis for SystemC Description Using Aspect-Oriented Programming. In: Proc. The 8th International Conference on Computer Supported Cooperative Work in Design, vol. 2, pp. 632 -- 636, IEEE, Xiamen, China (2004). 28. Bourouis, A., Belattar, B.: JAPROSIM: A Java Framework for Discrete Event Simulation. Journal of Object Technology, vol. 7, no. 1, pp. 103--119. (2008).

10