Concurrent Programming Languages Research Papers (original) (raw)

since 1978 was dealing with problems of concurrency for cluster, parallel, distributed computers. every mobile hangs, every computer, including super-super delays and wait, making billions of circles of waiting the event to synchronise. I recently in my archives have found a lecture that was requested by BCS colleagues, as well as one big US Computer conference orgcommitee. Part of it was included in our second edition of the Software Design for Resilient Computer Systems. But Book is expensive and students can't buy. Thus this lecture notes worth to publish on Academia.

Main aim of this paper is to describe how to connect a microcontroller to LAN or Internet and use it as a web server. This paper offers a new approach to control home appliances from a remote terminal, with an option from a local server, using the Internet. This system is accomplished by personal computers, interface cards, microcontroller, along with window-type software and microcontroller control software. The system is designed to control home appliances' on/off, to regulate their output power, and to set their usage timing. The microcontroller which is used in this project is the Philips P89C51RD2BN microcontroller.

- by Adira Meempat
- •
- Computer Science, Concurrent Programming Languages, Microcontroller

Prediction has been successfully applied in sports like football and basketball. Although in certain aspects, this application has been of very small limits. It is very necessary to look into the application of Machine Learning in these instances and see if its application can yield better results in the analysis of soccer. Machine learning which an area of Intelligent Systems (IS) is will be used in this report to help provide solution to problems faced by bookmakers in aspect of predicting the results of the football league. Although, it is necessary to note that taking into account all the features that have great influence on the results of football league matches is a difficult fit but this study has been able to find most features that are significant. By making use of machine learning and database that is more precise, this research aims to proffer a solution that will help to make predictions more accurate and precise. Being aware of what the future holds is something that will be a lot easier by making use of this IS.

C\RFAX SUMMARY This paper describes a systematic concurrent workfiow n1anage1nent (WM) process for integrated product developnzent. WM consists of planning and scheduling teams' activities to suppo1t cooperative and concurrent works. This paper firsr explains process re-engineering, flowcharting and va1ious workfiow practices in concurrent engineering (CE) to come up with a general process for WM. The WM process is based on an infomiation infrastructure containing nzodels of product require1nenrs, enterpn"se organization and resources, including the workjlow activity. Finally, technologies supporti'ng WM such as work process tnodeling, peifonnance analyzing, process re-engineering straregies to redesign the process and activtiy 1nanagenzent-t-eal-tinie task's rnonitoring-are introduced.

Solutions to the exercises in Programming with Mathematica: An Introduction are given here. The exercises to every section are listed first, followed by the solutions. Solutions are provided both as a PDF file and in notebook form at... more

- by b0aza alnaim
- •
- Mathematics, Number Theory, Programming Languages, Concurrent Programming Languages

10th International Conference of Advanced Computer Science & Information
Technology (ACSIT 2022) will act as a major forum for the presentation of innovative ideas, approaches, developments, and research projects in the area advanced Computer Science and information technology. It will also serve to facilitate the exchange of information between researchers and industry professionals to discuss the latest issues and advancement in the area of advanced CS & IT. Core areas of advanced IT and multi-disciplinary and its applications will be covered during the conferences.

The Matrix multiplication algorithms are one of most popular solution used to show the functionalities of Parallel Algorithm, so, it became an important tool to solve hard problems in a reasonable time. The essence in the solutions of this problem are mainly focus on the pattern found to distribute the data on the matrix, so the process of the basic operations can be execute as most independent possible. Specifically, this document presents two solutions to the problem mentioned, the 1-D algorithm and 2-D algorithm. For each presented solutions it will be specified the characteristics and the set of results obtain with the tests. This paper proves that given enough parallel support to the environment of the algorithms, it will be obtain efficient and satisfactory results.

- by Sutrisno Br and +1
- •
- Computer Science, Concurrent Programming Languages, Information Technology, Programming

Explains features and benefits of Java for concurrent programming Covers both built-in concurrency primitives and higher-level utilities Gives examples of the use of Java features to develop concurrent applications Examines common concurrency pitfalls and strategies for avoiding them Explores performance issues in concurrent applications Consolidates learning through hands-on workshop sessions

This article is an excerpt from the recently released book, Programming with Mathematica: An Introduction by Paul Wellin © 2013 [1]. The book, which follows on the well-known An Introduction to Mathematica Programming, provides an exampledriven primer on the foundations of the Mathematica programming language. Strings are used across many disciplines to represent filenames, data, and other objects: linguists working with text data study representation, classification, and patterns involved in audio and text usage; biologists dealing with genomic data as strings are interested in sequence structure and assembly and perform extensive statistical analysis of their data; programmers operate on string data for such tasks as text search, file manipulation, and text processing. Strings are so ubiquitous that almost every modern programming language has a string datatype and dozens of functions for operating on and with strings. StringQ@"The magic words are squeamish ossifrage."D True Strings are also used to represent file names that you import and export. Import@"ExampleDataêocelot.jpg"D Strings are used as arguments, option values, and as the output to many functions. GenomeData@"SNORD107"D GGTTCATGATGACACAGGACCTTGTCTGAACATAATGATTTCAAAATTTGAGCTTAAAAÖ ATGACACTCTGAAATC StringQ@%D True In this chapter we will introduce the tools available for working with strings in Mathematica. We will begin with a look at the structure and syntax of strings, then move on to a discussion of the many high-level functions that are optimized for string manipulation. String patterns follow on the discussion of patterns in Chapter 4 and we will introduce an alternative syntax (regular expressions) that provides a very compact mechanism for working with strings. The chapter closes with several applied examples drawn from computer science (checksums) as well as bioinformatics (working with DNA sequences) and also word games (anagrams, blanagrams). ‡ 9.1. Structure and Syntax Strings are expressions consisting of a number of characters enclosed in quotes. The characters can be anything you can type from your keyboard, including uppercase and lowercase letters, numbers, punctuation marks, and spaces. For example, here is the standard set of printable Ascii characters.

- by b0aza alnaim
- •
- Mathematics, Number Theory, Computer Science, Programming Languages

En este artículo se plantea una nueva paralelización del algoritmo de enjambre de partículas (PSO) haciendo uso de múltiples GPUs. Se plantean dos implementaciones basadas en la arquitectura CUDA de NVIDIA y la conexión P2P a través del puerto PCIe entre las GPUs.
Se evalúa la aceleración sobre dos GPUs comparando los resultados con la implementación secuencial y con una única GPU. Los resultados demuestran que usando el esquema clásico de PSO sobre un sistema multi-GPU la latencia de comunicación es alta, por tanto se usa una distribución en islas de procesamiento con el cual se logra una aceleración de hasta 32x respecto a la implementación secuencial.

ProCoS aims to improve dependability, reduce timescales and cut development costs of construction for embedded systems, particularly in real-time and safety-critical applications. It uses and develops the results of basic research into fundamental properties of interactive systems. It aims to provide a scienti fic basis for future standards of practice in the development of embedded systems, ensuring correctness of all stages in the development, from elicitation and analysis of requirements through design and implementation of programs down
to compilation and execution on veri fied hardware.

In recent years, the parallel computing community has shown increasing interest in leveraging cloud resources for executing parallel applications. Clouds exhibit several fundamental features of economic value, like on-demand resource provisioning and a pay-per-use model. Additionally, several cloud providers offer their resources with significant discounts; however, possessing limited availability. Such volatile resources are an auspicious opportunity to reduce the costs arising from computations , thus achieving higher cost efficiency. In this paper, we propose a cost model for quantifying the monetary costs of executing parallel applications in cloud environments, leveraging volatile resources. Using this cost model, one is able to determine a configuration of a cloud-based parallel system that minimizes the total costs of executing an application.

ProCoS aims to improve dependability, reduce timescales and cut development costs of construction for embedded systems, particularly in real-time and safety-critical applications. It uses and develops the results of basic research into fundamental properties of interactive systems. It aims to provide a scientific basis for future standards of practice in the development of embedded systems, ensuring correctness of all stages in the development, from elicitation and analysis of requirements through design and implementation of ...

- by Martin Fränzle
- •
- Control Systems Engineering, Computer Science, Concurrency Theory, Compilers

Multicore architectures are becoming available in embedded systems. However, parallelizing sequential software is a challenging task. A structured approach is needed to exploit parallel opportunities. Therefore we propose a topdown approach based on a layered model of parallel design patterns. As a proof of concept this approach has been applied on a number of algorithms including the Fast Fourier Transformation.

In recent years, the cloud has become an attractive execution environment for parallel applications, which introduces novel opportunities for versatile optimizations. Particularly promising in this context is the elasticity characteristic of cloud environments. While elasticity is well established for client-server applications, it is a fundamentally new concept for parallel applications. However, existing elasticity mechanisms for client-server applications can be applied to parallel applications only to a limited extent. Efficient exploitation of elasticity for parallel applications requires novel mechanisms that take into account the particular runtime characteristics and resource requirements of this application type. To tackle this issue, we propose an elasticity description language. This language facilitates users to define elasticity policies, which specify the elasticity behavior at both cloud infrastructure level and application level. Elasticity at the application level is supported by an adequate programming and execution model, as well as abstractions that comply with the dynamic availability of resources. We present the underlying concepts and mechanisms, as well as the architecture and a prototypical implementation. Furthermore, we illustrate the capabilities of our approach through real-world scenarios.

UNITY is an abstract formalism for proving properties of concurrent systems, which typically are expressed using guarded assignments [Chandy and Misra 1988]. UNITY has been mechanized in higher-order logic using Isabelle, a proof assistant. Safety and progress primitives, their weak forms (for the substitution axiom) and the program composition operator (union) have been formalized. To give a feel for the concrete syntax, the paper presents a few extracts from the Isabelle definitions and proofs. It discusses a small example, two-process mutual exclusion. A mechanical theory of unions of programs supports a degree of compositional reasoning. Original work on extending program states is presented and then illustrated through a simple example involving an array of processes.

- by Lawrence Paulson
- •
- Concurrent Programming Languages, Isabelle

Complex software systems typically involve features like time, concurrency and probability, with probabilistic computations playing an increasing role. However, it is currently challenging to formalize languages incorporating all those features. Recently, the language PTSC has been proposed to integrate probability and timewith shared-variable concurrency (Zhu et al. (2006, 2009)), where the operational semantics has been explored and a set of

- by Huibiao Zhu
- •
- Algebra, Probability Theory, Computer Science, Parallel Computing

- by Jonathan Bowen
- •
- Algebra, Probability Theory, Computer Science, Concurrency Theory

Complex software systems typically involve features like time, concurrency and probability, where probabilistic computations play an increasing role. It is challenging to formalize languages comprising all these features. We have proposed a language, which integrates probability with time and shared-variable concurrency. We also explored its operational semantics, where a set of algebraic laws has been investigated via bisimulation. In this paper, we consider the inverse work, the derivation of operational semantics from algebraic semantics for our probabilistic language. This approach can be understood as the soundness investigation of operational semantics from the viewpoint of algebraic semantics. Firstly we present the algebraic laws for our probabilistic language. Every program can be expressed as either a guarded choice, or the summation of a set of processes which are deterministic initially. This can model the execution of a program. Secondly we investigate the derivation of an operational semantics from its algebraic semantics. A set of transition rules are derived from the given derivation strategy. Thirdly we explore the equivalence of the derived transition system and the derivation strategy. This indicates the completeness of our operational semantics from the viewpoint of algebraic semantics. Meanwhile, we also investigate the observation-oriented semantic model and its derivation from algebraic semantics.

- by Jonathan Bowen
- •
- Algebra, Probability Theory, Computer Science, Concurrency Theory

We have created CABERNET, a Controlled Nature Language (CNL) based approach to program creation. CABERNET allows programmers to use a simple outline-based syntax. This allows increased programmer efficiency and syntax flexibility. CNLs have successfully been used for writing requirements documents. We propose taking this approach well beyond this to fully functional programs. Through the use of heuristics and inference to analyze and determine the programmer's intent we are able to create fully functional mobile applications. The goal is for programs to be aligned with the way that the humans think rather than the way computers process information. Through the use of templates a CABERNET application can be processed to run on multiple run time environments. Because processing of a CABERNET program file results in native application program performance is maintained.

Spatial reasoning is a relevant topic in artificial intelligence with applications in geographical Information System, robotics, content-based image retrieval, traffic engineering. Additionally formal representation of knowledge allows the processing in a computer. Prolog is a programming language used in artificial intelligence that is useful to represent knowledge and perform a search, by asking questions in the knowledge base. Prolog can be used to develop a variety of applications like check the consistency or to perform any kind of reasoning. This article proposes the use of Prolog as a representation model and a reasoning engine to describe the topological relations between several objects in a geographic space, using the RCC model. The application of this simplifies the constructionprogram, allows us to focus on the spatial problem.

In this paper we propose a communication-centric approach to specifying and checking how multithreaded programs use shared memory to perform inter-thread communication. Our approach complements past efforts for improving the safety of multithreaded programs such as race detection and atomicity checking. Unlike prior work, we focus on what pieces of code are allowed to communicate with one another, as opposed to declaring what data items are shared or what code blocks should be atomic. We develop a language that supports composable specifications at multiple levels of abstraction and that allows libraries to specify whether or not shared-memory communication is exposed to clients. The precise meaning of a specification is given with a formal semantics we present. We have developed a dynamic-analysis tool for Java that observes program execution to see if it obeys a specification. We report results for using the tool on several benchmark programs to which we added specifications, concluding that our approach matches the modular structure of multithreaded applications and that our tool is performant enough for use in development and testing.

In this paper, we deal with optimizing the monetary costs of executing parallel applications in cloud-based environments. Specifically, we investigate on how scalability characteristics of parallel applications impact the total costs of computations. We focus on a specific class of irregularly structured problems , where the scalability typically depends on the input data. Consequently, dynamic optimization methods are required for minimizing the costs of computation. For quantifying the total monetary costs of individual parallel computations, the paper presents a cost model that considers the costs for the parallel infrastructure employed as well as the costs caused by delayed results. We discuss a method for dynamically finding the number of processors for which the total costs based on our cost model are minimal. Our extensive experimental evaluation gives detailed insights into the performance characteristics of our approach.

This chapter is some kind of summary of chapters 6,7 in terms of implementation of
principles described there at the level of run-time system.
Here we summarize new functions and features of run-time system that simply must be
implemented during design of fault tolerant and resilient systems.
A special attention was given to concurrency monitoring in presence of potential threats
and degradation. While it is clear which part of system software has to deal with this,
the whole problem of concurrency never was addressed proper - here we present our
attempt.

—This paper discusses a methodology used on an industrial hardware developement project to validate hardware protocol components. The idea is to use a high level model (HLM), written in a guarded-command language such as Murphi for model checking purposes, and then to use the HLM as a checker during dynamic (i.e. testing based-) validation of the RTL. Such a checker implicitly requires a notion of what it means for the RTL to implement the HLM. Due to RTL pipelining, event concurrency, and different execution semantics between the RTL and HLM, an appropriate notion is non-obvious and not resolved in the literature. In this paper we provide a novel solution we simply call behavioral refinement, and describe a methodology for creating corresponding dynamic checkers (called refinement checkers). Another novel aspect of our methodology is that all " ingredients " are specified using the popular System Verilog (SV) language; even the Murphi model itself is ultimately compiled into SV. Thus any off-the-shelf SV simulation engine can be employed. We report the successful use of our refinement checkers to catch bugs on a industrial hardware design project, and provide anecdotal recommendations from our experiences.

- by Flemming Andersen and +1
- •
- Concurrency Theory, Parallel Computing, Programming Languages, Compilers
- by Josh Lu
- •
- Concurrent Programming Languages

This paper discusses a methodology used on an industrial hardware development project to validate various cache-coherence protocol components. The idea is to use a high level model (HLM) written in Murphi for model checking purposes, and then to use the HLM as a checker during dynamic (i.e. simulation based-) validation of the RTL. Such a checker requires a formal notion of what it means for the RTL to implement the HLM. Due to RTL pipelining, concurrency, and different RTL/HLM semantics, an appropriate notion is nonobvious. We employ a notion we call behavioral refinement, and describe a methodology for creating refinement checkers. A novel aspect of our methodology is that all "ingredients" are specified using System Verilog (SV): even the Murphi model itself is compiled into SV. Thus any off-the-shelf SV simulation engine can be used. We report the successful use of our refinement checkers to catch bugs in a real project at Intel and give an example illustrating our methodology.

- by Flemming Andersen
- •
- Concurrency Theory, Parallel Computing, Programming Languages, Compilers

Abstract. We present a parametric tool for the analysis of distributed concurrent systems. Processes axe internally represented as proved tran-sition systems. Actually, we use a fragment of them, in which only one transition exits from a... more

ProCoS aims to improve dependability, reduce timescales and cut development costs of construction for embedded systems, particularly in real-time and safety-critical applications. It uses and develops the results of basic research into fundamental properties of interactive systems. It aims to provide a scientific basis for future standards of practice in the development of embedded systems, ensuring correctness of all stages in the development, from elicitation and analysis of requirements through design and implementation of ...

Complex sfotware systems typically involve features like time, concurrency and probability, and probabilistic computations are playing an increasing role. However it is currently challenging to formalize languages incorporating all those features. Recently the language PTSC has been proposed to integrate probability and time with shared-variable concurrency , where the operational semantics has been explored and a set of algebraic laws has been investigated via bisimulation. This paper investigates the link between the operational and algebraic semantics of PTSC, highlighting both its theoretical and practical aspects.

- by Shengchao Qin
- •
- Algebra, Probability Theory, Computer Science, Parallel Computing

We address the problem of message authentication using the -calculus, which has been given an operational semantics in [2] that provides each sequential process of a system with its own local space of names. We exploit here that semantics and its localized names to guarantee by construction that a message has been generated by a given entity. Therefore, our proposal can be seen as a reference for the analysis of "real" protocols. As an example, we study the way authentication is ensured by encrypting messages in the ×Ô -calculus .

- by Pierpaolo Degano and +1
- •
- Calculus, Concurrent Programming Languages, Semantics, Cryptography

Programming languages naturally play an essential role in the software development process. Finding more powerful and better suited language has been the aim of language designers ever since the dawn of computer programming. For instance, the most recent research in concurrent logic programming paradigm is directed towards concurrent constraints framework where the development of the AKL (Agents Kernel Language) language is significant. AKL+ is a natural development which is derived from the fusion of concurrent constraint logic programming and objectoriented programming paradigms. The result is more than a sum of its parts since many of the inadequacies of one programming paradigm are compensated for by features of the other. This paper is going to describe the AKL+ language. The schemes for developing an efficient implementation is discussed. The AKL+ language has been implemented on UNIX-based workstations and they are parts of the official release of the AKL system, AGENTS, developed at SICS (Swedish Institute of Computer Science).

- by Salwa Gamal and +2
- •
- Object Oriented Programming, Concurrent Programming Languages, Logic Programming

Mobile agents, i.e. pieces of programs that can be sent around networks of computers, are starting to appear on the Internet. Such programs may be seen as an enrichment of traditional distributed computing. Since mobile agents may carry communication links with them as they move across the network, they create very dynamic interconnection structures that can be extremely complex to analyse. In this paper we analyse a fragment of a system based on the mobile agent principle written in the Facile programming language. We propose a Structural Operational Semantics (SOS) for Facile, giving a proved transition system that records encodings of the derivation trees of transitions in their labels. This information allows us to easily recover non-interleaving semantics for Facile by looking only at the labels of transitions. We use the new Facile semantics to debug an agent based system. This example is a scaled down version of a system demonstrated at the European IT Conference Exhibition in Brussels, 1995.