The Barabasi-Albert model (BA) is designed to generate scale-free networks using the preferential attachment mechanism. In the preferential attachment (PA) model, new nodes are sequentially introduced to the network and they attach preferentially to existing nodes. PA is a classical model with a natural intuition, great explanatory power and a simple mechanism. Therefore, PA is widely-used for network generation. However the sequential mechanism used in the PA model makes it an inefficient algorithm. The existing parallel approaches, on the other hand, suffer from either changing the original model or explicit complex low-level synchronization mechanisms. In this paper we investigate a high-level Actor-based model of the parallel algorithm of network generation and its scalable multicore implementation in Haskell.
Generation of social networks using Preferential Attachment (PA) mechanism is proposed in the Barabasi-Albert model. In this mechanism, new nodes are introduced to the network sequentially and they attach to the existing nodes preferentially where the preference can be based on the degree of the existing nodes. PA is a classical model with a natural intuition, great explanatory power and interesting mathematical properties. Some of these properties only appear in large-scale networks. However generation of such extra-large networks can be challenging due to memory limitations. In this paper, we investigate a distributedmemory approach for PA-based network generation which is scalable and which avoids low-level synchronization mechanisms thanks to utilizing a powerful programming model and proper programming constructs.
Abstract. In this paper we present an API to support modeling applications with Actors based on the paradigm of the Abstract Behavioural Specification (ABS) language. With the introduction of JAVA 8, we expose this API through a JAVA library to allow for a high-level actorbased methodology for programming distributed systems which supports the programming to interfaces discipline. We validate this solution through a case study where we obtain significant performance improvements as well as illustrating the ease with which simple high and low-level optimizations can be obtained by examining topologies and communication within an application. Using this API we show it is much easier to observe drawbacks of shared data-structures and communications methods in the design phase of a distributed application and apply the necessary corrections in order to obtain better results.
SUMMARYCloud environments have become a standard method for enterprises to offer their applications by means of web-services, data management systems or simply renting out computing resources. In our previous work we presented how we can use a modeling language together with the new features of JAVA 8 to overcome certain drawbacks of data structures and synchronization mechanisms in parallel applications. We extend this solution into a design pattern that allows application-specific optimizations in a distributed setting. We validate this integration using our previous case study of the Prime Sieve of Eratosthenes and illustrate the performance improvements in terms of speed-up and memory consumption.
In this paper we introduce a new programming model of multi-threaded actors which feature the parallel processing of their messages. In this model an actor consists of a group of active objects which share a message queue. We provide a formal operational semantics, and a description of a Java-based implementation for the basic programming abstractions describing multi-threaded actors. Finally, we evaluate our proposal by means of an example application.Comment: In Proceedings ICE 2016, arXiv:1608.0313
Distributed systems and applications require large amounts of resources in terms of memory and computing power and are becoming a standard for large businesses and enterprises [12] within and outside the domain of Computer Science. A very important topic for distributed applications is Big Data management and more specifically the generation of large-scale social networks graphs where the number of nodes reaches very large numbers. Analysis of such networks is of importance in many areas, e.g., data mining, network sciences, physics, and social sciences [3]. The need for efficient and scalable methods of network generation is frequently mentioned in the literature [8], particularly for the preferential attachment process [1,13,14]. Barabasi-Albert model, which is based on preferential attachment (PA) [4], is one of the most commonly used models to produce artificial networks, because of its explanatory power, conceptual simplicity, and interesting mathematical properties [13]. Nevertheless the large number of nodes in such graphs may not fit in the memory on one machine. The need for efficient solutions which provide scalability also requires more computational resources as well as implementation considerations. As such, distribution and synchronization are two main challenges. In this chapter, we investigate as a case study a distributed solution for PA-based graph generation which avoids low level synchronization management, thanks to the notion of cooperative scheduling and futures.
Abstract. Many modern distributed software applications require a continuous interaction between their components exploiting streaming data from the server to the client. The Abstract Behavioral Specification (ABS) language has been developed for the modeling and analysis of distributed systems. In ABS, concurrent objects communicate by calling each other's methods asynchronously. Return values are communicated asynchronously too via the return statement and so-called futures. In this paper, we extend the basic ABS model of asynchronous method invocation and return in order to support the streaming of data. We introduce the notion of a "Future-based Data Stream" to extend the ABS. The application of this notion and its impact on performance are illustrated by means of a case study in the domain of social networks simulation.
Agent-oriented software products are becoming increasingly complicated, and the competitive market is forcing the producers to reduce time-to-market and increase the quality of the software produced. Therefore, developers have come to realize the need for more reliable and efficient agent-oriented software development processes (methodologies) which address the specific needs of each and every project. Software Process Lines provide a solution to this problem by using Process Line Engineering concepts for instantiating bespoke software processes.This research focuses on developing a software process line for Requirements Engineering (RE) in the context of agent-oriented software development. Our proposed Agent-Oriented Requirements Engineering Process Line (AOREPL) incorporates a core base which can be directly used for instantiating an Agent-Oriented Requirements Engineering (AORE) process; it also defines variation points and variant method chunks to be added to the core base in order to create variant AORE processes. We also propose a step-by-step process line engineering method which enables process engineers to define and instantiate diverse AORE process lines.
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations鈥揷itations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright 漏 2024 scite LLC. All rights reserved.
Made with 馃挋 for researchers
Part of the Research Solutions Family.