Search

An alternator is a network of concurrent nodes, which satisfies the following conditions: (i) if one node enters its critical section, no neighboring nodes could enter their critical sections at the same computing phase; (ii) along any infinite computing phases, each node enters its critical section infinitely often. An alternator is said to exhibit strong fairness if condition (ii) is changed to: between any two consecutive critical steps of a node, all neighbors enter their critical sections exactly once. In this paper, we propose a state-optimal alternator algorithm for uniform rings with n nodes, where n is any positive integer greater than one. The proposed algorithm operates correctly for synchronous mode. Every node maintains only a two-state variable. The proposed algorithm has the snap property that the system always satisfies condition (i) of the alternator even if some transient fault occurs. The stabilization time of the proposed alternator algorithm is O(n) phases. After stabilization, the system satisfies the strong fairness property and achieves the maximal performance. We say that an alternator achieves the maximal performance if a node is allowed to enter its critical section when both its neighbors do not enter their critical sections. In the worst case, the proposed algorithm allows each node to enter its critical section every three phases. [ABSTRACT FROM AUTHOR]

This paper is the 2nd in a series of planned papers that provide 1st bijective proofs of alternating sign matrix (ASM) results. Based on the main result from the 1st paper, we construct a bijective proof of the enumeration formula for ASMs and of the fact that ASMs are equinumerous with descending plane partitions. We are also able to refine these bijections by including the position of the unique |$1$| in the top row of the matrix. Our constructions rely on signed sets and related notions. The starting point for these constructions were known "computational" proofs, but the combinatorial point of view led to several drastic modifications. We also provide computer code where all of our constructions have been implemented. [ABSTRACT FROM AUTHOR]

The article presents several abstracts related to computer programming including "Non-deterministic Multiple-valued Structures," "Characterizations of some Preferential Paraconsistent Consequence Relation," and "Programming and Verifying Subgame-perfect Mechanism."

The Independent Choice Logic (ICL), proposed by Poole, is a language for expressing probabilistic information in logic programming that adopts a distribution semantics: an ICL theory defines a distribution over a set of normal logic programs. The probability of a query is then given by the sum of the probabilities of the programs where the query is true. [ABSTRACT FROM PUBLISHER]

Turing, in his immortal 1936 paper, observed that '[human] computing is normally done by writing... symbols on [twodimensional] paper', but noted that use of a second dimension 'is always avoidable' and that 'the two-dimensional character of paper is no essential of computation'. We propose to promote two-dimensional models of computation and exploit the naturalness of two-dimensional representations of data. In particular, programs for a two-dimensional Turing machine can be recorded most naturally on its own two-dimensional input-output grid in such a transparent fashion that schoolchildren would have no difficulty comprehending their behaviour. This two-dimensional rendering allows, furthermore, for a most perspicacious rendering of Turing's universal machine. [ABSTRACT FROM AUTHOR]

The analysis of a queue that serves batches of customers with a novel service policy is presented in this paper, showing that a closed steady-state distribution of the number of customers in the queue can be derived for a very general setting of its parameters. Two output processes are flowing out of this queue depending on the fact that single customers are removed from the queue upon completion of a service, or bulks of customers of a fixed size are departing from the queue at the completion of the service's. Based on the expression of the steady-state distribution which assumes a Poisson arrival process, specific parameter configurations are identified that make the queue quasi-reversible, depending on the output process of interest. Since quasi-reversible queues are very important in the context of product form queueing networks, these results have relevant impacts on their own as well as when considered as the basis for possible computationally efficient approximations. Comparisons among the results obtained for different parameter settings are provided using both stochastic order arguments and numerical experiments. Future research directions are proposed considering also the many practical applications of this model ranging from flexible manufacturing, to logistics, to transportation systems. [ABSTRACT FROM PUBLISHER]

The Capsule Reviews are intended to provide a short succinct review of each paper in the issue in order to bring to a wider readership. The Capsule Reviews were compiled by Fairouz Kamareddine. Professor Kamareddine is an Associate Editor of The Computer Journal and is based in the Department of Mathematical and Computer Sciences at Heriot-Watt University, Edinburgh, UK. [ABSTRACT FROM AUTHOR]

Conventional approaches towards energy-system modelling and operation are based upon the system design and performance optimization. In system-design optimization, the thermal or mechanical characteristics of the systems providing for the heat or electricity demands were derived separately without integration with the energy source and without interaction with demand, which results in low-efficiency energy performance. This paper presents a key review on the integration of biomass-powered combined heat and power (BCHP) systems in district-heating systems as well as coupling with thermal-energy storage. In BCHP design, the appropriate sizing of the associated components as part of the district-heating system is very important to provide the optimal dispatch strategy as well as minimized cost and environmental impact while it co-operates with thermal-energy storage. Future strategies for the feasibility, evaluation and integration of biomass-powered energy systems in the context of district systems are also studied. [ABSTRACT FROM AUTHOR]

In static models of the adoption of new technologies, a firm generally adopts complementary technologies simultaneously. This paper presents a dynamic model in which, taking into account the potential time paths of costs and benefits, it may be more prudent to adopt complementary technologies partially or sequentially. [ABSTRACT FROM AUTHOR]

Safety critical number-entry tasks, such as programming syringe pumps, are common occurrences in healthcare settings. However, humans are prone to error and healthcare staff must often work in distracting and high stress environments. Previous work has developed a potential intervention that could reduce errors using a phenomenon called the Perceptual Interference Effect (PIE). In this paper, the numbers to be entered are presented in a hard-to-read form and experimental studies showed that this reduced the errors that people made. The aim of this paper is to investigate the robustness of this effect in the context of a distracting environment and therefore to begin to move towards investigating its efficacy in real-world settings. We report on an experiment, which uses auditory distractors alongside the PIE effect to investigate the effect on number-entry errors. The results are promising: the number of errors is significantly reduced by PIE and the rate of making errors is reduced though significance is marginal. Nonetheless, the results are suggestive that the PIE could work even in distracting circumstances though the isolation of this phenomenon in experimental studies is challenging. We explore the implications for future studies into this effect for eventual application in real-world contexts. [ABSTRACT FROM AUTHOR]

This paper outlines typical terminology for modeling and highlights key historical and forthcoming aspects of mathematical modeling. Mathematical models (MM) are mental conceptualizations, enclosed in a virtual domain, whose purpose is to translate real-life situations into mathematical formulations to describe existing patterns or forecast future behaviors in real-life situations. The appropriateness of the virtual representation of real-life situations through MM depends on the modeler's ability to synthesize essential concepts and associate their interrelationships with measured data. The development of MM paralleled the evolution of digital computing. The scientific community has only slightly accepted and used MM, in part because scientists are trained in experimental research and not systems thinking. The scientific advancements in ruminant production have been tangible but incipient because we are still learning how to connect experimental research data and concepts through MM, a process that is still obscure to many scientists. Our inability to ask the right questions and to define the boundaries of our problem when developing models might have limited the breadth and depth of MM in agriculture. Artificial intelligence (AI) has been developed in tandem with the need to analyze big data using high-performance computing. However, the emergence of AI, a computational technology that is data-intensive and requires less systems thinking of how things are interrelated, may further reduce the interest in mechanistic, conceptual MM. Artificial intelligence might provide, however, a paradigm shift in MM, including nutrition modeling, by creating novel opportunities to understand the underlying mechanisms when integrating large amounts of quantifiable data. Associating AI with mechanistic models may eventually lead to the development of hybrid mechanistic machine-learning modeling. Modelers must learn how to integrate powerful data-driven tools and knowledge-driven approaches into functional models that are sustainable and resilient. The successful future of MM might rely on the development of redesigned models that can integrate existing technological advancements in data analytics to take advantage of accumulated scientific knowledge. However, the next evolution may require the creation of novel technologies for data gathering and analyses and the rethinking of innovative MM concepts rather than spending resources in collecting futile data or amending old technologies. [ABSTRACT FROM AUTHOR]

Distributed storage systems that deploy erasure codes can provide better features such as lower storage overhead and higher data reliability. In this paper, we focus on fractional repetition (FR) codes, which are a class of storage codes characterized by the features of uncoded exact repair and minimum repair bandwidth. We study the duality of FR codes and investigate the relationship between the supported file size of an FR code and its dual code. Based on the established relationship, we derive an improved dual bound on the supported file size of FR codes. We further show that FR codes constructed from t -designs are optimal when the size of the stored file is sufficiently large. Moreover, we present the tensor product technique for combining FR codes and elaborate on the file size hierarchy of resulting codes. [ABSTRACT FROM AUTHOR]

Motivation Pairwise sequence alignment is undoubtedly a central tool in many bioinformatics analyses. In this paper, we present a generically accelerated module for pairwise sequence alignments applicable for a broad range of applications. In our module, we unified the standard dynamic programming kernel used for pairwise sequence alignments and extended it with a generalized inter-sequence vectorization layout, such that many alignments can be computed simultaneously by exploiting SIMD (single instruction multiple data) instructions of modern processors. We then extended the module by adding two layers of thread-level parallelization, where we (a) distribute many independent alignments on multiple threads and (b) inherently parallelize a single alignment computation using a work stealing approach producing a dynamic wavefront progressing along the minor diagonal. Results We evaluated our alignment vectorization and parallelization on different processors, including the newest Intel® Xeon® (Skylake) and Intel® Xeon PhiTM (KNL) processors, and use cases. The instruction set AVX512-BW (Byte and Word), available on Skylake processors, can genuinely improve the performance of vectorized alignments. We could run single alignments 1600 times faster on the Xeon PhiTM and 1400 times faster on the Xeon® than executing them with our previous sequential alignment module. Availability and implementation The module is programmed in C++ using the SeqAn (Reinert et al. 2017) library and distributed with version 2.4 under the BSD license. We support SSE4, AVX2, AVX512 instructions and included UME: SIMD, a SIMD-instruction wrapper library, to extend our module for further instruction sets. We thoroughly test all alignment components with all major C++ compilers on various platforms. Supplementary information Supplementary data are available at Bioinformatics online. [ABSTRACT FROM AUTHOR]

In this paper, the performance of a grid resource is modeled and evaluated using stochastic reward nets (SRNs), wherein the failure–repair behavior of its processors is taken into account. The proposed SRN is used to compute the blocking probability and service time of a resource for two different types of tasks: grid and local tasks. After modeling a grid resource and evaluating the performability measures, an algorithm is presented to find the probability mass function (pmf) of the service time of the grid resource for a program which is composed of grid tasks. The proposed algorithm exploits the universal generating function to find the pmf of service time of a single grid resource for a given program. Therefore, it can be used to compute the pmf of the service time of entire grid environment for a workflow with several dependent programs. Each possible scheduling of programs on grid resources may result in different service times and successful execution probabilities. Due to this fact, a genetic-based scheduling algorithm is proposed to appropriately dispatch programs of a workflow application to the resources distributed within a grid computing environment. Numerical results obtained by applying the proposed SRN model, the algorithm to find the pmf of grid service time, and the genetic-based scheduling algorithm to a comprehensive case study demonstrate the applicability of the proposed approach to real systems. [ABSTRACT FROM AUTHOR]

There are two types of dynamic elements in a pervasive system: the first is where a context varies with shifting environments, and the second is where variables are defined by the dynamic requirements of an application. This makes improving adaptability to dynamic change an important topic in pervasive systems research. Currently, most of the efforts targeting improvements in adaptability focus on context-related issues, other variables being simply encoded in the program directly. This ignores the dynamic complexity of a pervasive system, resulting in poor system adaptability. In this paper, we propose a rule-based method in which the two types of change are separated from the program code. The changes are then stored and processed by means of corresponding rules. In our new method when a change occurs, the system needs only to modify the rules rather than the program code. This makes a pervasive system more robust in its adaptability to dynamic change. Experiments and examples are provided to evaluate the feasibility of the proposed method. [ABSTRACT FROM PUBLISHER]

Variable neighbourhood search (VNS) is a modern metaheuristic based on systematic changes of the neighbourhood structure within a search to solve optimization problems. The aim of this paper is to propose and analyse a VNS algorithm to solve scheduling problems with parallel machines and sequence- dependent setup times, which are of great importance on the industrial context. Three versions of a greedy randomized adaptive search procedure algorithm are used to compare with the proposed VNS algorithm to highlight its advantages in terms of generality, quality and speed for large instances. [ABSTRACT FROM AUTHOR]

This article concentrates on the issue of front-end representation in an electronic genetic edition of modern manuscript material that has been transcribed using XML/TEI and, in particular, on the use to this end of XSLT within the Java XML publishing framework. The point of departure is a quote from the French genetic critic Louis Hay on genetic paper-editions in 1987: ‘It is well known that the typographic transliteration of complex manuscripts often allows only approximate solutions’ (Hay, 1987, p. 121). Can the new approach of Humanities Computing provide full solutions instead of approximate ones, or will a full solution always remain unattainable? The author argues that all the electronic editors can do is make the approximate nature of the representation explicit to users by providing more than one visualization, and by presenting users with a tool that allows them to construct their own visualization. [ABSTRACT FROM AUTHOR]

This paper develops a new theory and model for information and sensor validation. The model represents relationships between variables using Bayesian networks and utilizes probabilistic propagation to estimate the expected values of variables. If the estimated value of a variable differs from the actual value, an apparent fault is detected. The fault is only apparent since it may be that the estimated value is itself based on faulty data. The theory extends our understanding of when it is possible to isolate real faults from potential faults and supports the development of an algorithm that is capable of isolating real faults without deferring the problem to the use of expert provided domain-specific rules. To enable practical adoption for real-time processes, an any time version of the algorithm is developed, that, unlike most other algorithms, is capable of returning improving assessments of the validity of the sensors as it accumulates more evidence with time. The developed model is tested by applying it to the validation of temperature sensors during the start-up phase of a gas turbine when conditions are not stable; a problem that is known to be challenging. The paper concludes with a discussion of the practical applicability and scalability of the model. [ABSTRACT FROM AUTHOR]

The paper presents the outcome of the pilot phase of a major project which aims to build a digital resource for the study of historical Chinese texts with a view to facilitating linguistic analysis of the language, particularly from a diachronic point of view. The approach to general problems for a diachronic corpus is discussed. Details of the tag set and the tagging system devised are given. The development of a sophisticated automatic mark-up scheme for Chinese texts from widely different time periods and genres is indicated. [ABSTRACT FROM AUTHOR]

This paper examines the limitations of Turing Machines as a complete model of computation, and presents several models that extend Turing Machines. Dynamic interaction of clients and servers on the Internet, an infinite adaptation from evolutionary computation, and robots sensing and acting are some examples of areas that cannot be properly described using Turing Machines and algorithms. They require new models of computation going beyond Turing Machines. We refer to such new models as superTuring models of computation. Three superTuring models of computation, namely Interaction Machines, the π calculus and the $-calculus are presented and explained, focussing on why they are better for the solution of computational problems. We expect that superTuring computation will become the central programming paradigm in the future. [ABSTRACT FROM AUTHOR]

Symbolic transition systems separate data from process behaviour by allowing the data to be uninstantiated. Designing an HML-like modal logic for these transition systems is interesting because of the subtle interplay between the quantifiers for the data and the modal operators (quantifiers on transitions). This paper presents the syntax and semantics of such a logic and discusses the design issues involved in its construction. The logic has been shown to be adequate with respect to strong early bisimulation over symbolic transition systems derived from Full LOTOS. We define what is meant by adequacy and discuss how we can reason about it with the aid of a mechanized theorem prover. [ABSTRACT FROM PUBLISHER]

This paper describes an algorithm and associated tool for checking a network of communicating processes, defined using the algebraic language of CSP, against a set-theoretic specification, expressed in terms of event traces and refusal sets. [ABSTRACT FROM PUBLISHER]

Rapid, reliable and energy-efficient programing code dissemination is a challenging issue and offers a programmable and flexible network architecture for software-defined wireless networks (SDWNs). However, many schemes for programing codes in large-scale network incur a longer dissemination convergence time (DCT) and lower energy efficient in loss nature of wireless channels. In this paper, an adaptive broadcast dissemination (ABD) scheme is proposed to achieve low DCT and high network lifetime for SDWNs. An ABD scheme makes full use of energy left of nodes in areas far from the sink. In an ABD scheme, codes are broadcast constantly few times by nodes near the sink to save energy, and many times by nodes in areas far from the sink to rapidly spread software codes. Thus, an ABD scheme can reduce transmission delay for spreading software code while retaining network lifetime. Theoretical analysis and experimental results show that DCT in an ABD scheme is reduced by 28.12-29.86% compared with the hybrid scheme, while retaining network lifetime. [ABSTRACT FROM AUTHOR]

In Word and Object, W.V. Quine dismisses connotations that result from the work of explicating expressions as "don't-cares." This paper traces the history of this phrase to an algorithm that Quine developed in the 1950s, which became important in early computer engineering. Computer programmers eventually came to realize that it was in their best interests to abandon the "don't-care" attitude. Similarly, I argue that naturalists who properly appreciate the communal nature of their inquiries have reason to adopt a more careful approach when they propose and evaluate explications. [ABSTRACT FROM AUTHOR]

This paper describes the design of a system for parsing ancient Greek morphologically, taking into account the distinctive requirements of studying a historical language. Sets of stems and inflectional patterns identified by URNs are expressed in a specified orthography, and are loaded dynamically when the parser is built. Analytical results are also expressed with URN values for lexical entity and form, so that replies identify both the result of the analysis and the logic leading to the result. The underlying engine uses finite transducers to collect possible analyses of Greek words stripped of accents. A wrapper program implements an 'analysis by synthesis' algorithm by adding appropriate accents for each candidate analysis, and comparing the result to the originally submitted form. Parsers can be built or tailored to specific corpora without programming, by editing tables of stems and inflectional patterns. [ABSTRACT FROM AUTHOR]

The ability to predict the directions of branches, especially conditional branches, is an important problem in modern computer architecture and advanced compilers. Many static and dynamic techniques have been proposed. Today, all state-of-the-art microprocessors have some form of hardware support for dynamic branch prediction. Static techniques, on the other hand, have not been widely studied because of the belief that they give poorer results. However, good static branch predictions are invaluable information for (static) compiler optimization or performance estimation. In this paper, we propose performing static branch prediction at the source code level. The assumption is that the source code contains information unavailable at the assembly or machine code level that may be used for branch prediction. Empirical studies on 14 integer Spec benchmarks indicate that the simple heuristics proposed can be effective in practice. [ABSTRACT FROM PUBLISHER]

Distributed programs often follow some bounded global predicates, for example, the total number of certain tokens is always the same or bounded in a range. In order to detect bounded global predicates, we can first derive the minimum and maximum global snapshots and then check if the minimum and maximum are out of the range. Recently, Chase and Garg proposed an efficient method to derive the minimum global snapshot by reducing this problem to a maximum network flow problem. A restriction of this method is that all message values (e.g., the token number in messages) must be zero and all process state values (e.g., the token number in processes) must be non-negative. In this paper, we propose an elegant technique, called normalization. By using this technique, we can remove the above restriction and also derive the minimum and maximum global snapshots at the same time. [ABSTRACT FROM AUTHOR]

Graph is an increasingly popular way to model complex data, and the size of single graphs is growing toward massive. Nonetheless, executing graph algorithms efficiently and at scale is surprisingly challenging. As a consequence, distributed programming frameworks have emerged to empower large graph processing. Pregel, as a popular computational model for processing billion-vertex graphs, has been employed to improve the scalability of many algorithms. In this paper, we investigate frequent subgraph mining on single large graphs using Pregel.We present the first distributed algorithm based on Pregel for single massive graphs. In addition, two optimizations are proposed to enhance the algorithm, reducing communication cost and distribution overhead. Extensive experiments conducted on real-life data confirm the effectiveness and efficiency of the proposed algorithm and techniques. [ABSTRACT FROM AUTHOR]

Motivation: Topological domains have been proposed as the backbone of interphase chromosome structure. They are regions of high local contact frequency separated by sharp boundaries. Genes within a domain often have correlated transcription. In this paper, we present a computational efficient spectral algorithm to identify topological domains from chromosome conformation data (Hi-C data). We consider the genome as a weighted graph with vertices defined by loci on a chromosome and the edge weights given by interaction frequency between two loci. Laplacianbased graph segmentation is then applied iteratively to obtain the domains at the given compactness level. Comparison with algorithms in the literature shows the advantage of the proposed strategy. Results: An efficient algorithm is presented to identify topological domains from the Hi-C matrix. [ABSTRACT FROM AUTHOR]

This paper studies the performance characteristics of computational fluid dynamics (CFD) applications on Intel Many Integrated Core (MIC) architecture. Three CFD applications, BT-MZ, LM3D and HOSTA, are evaluated on Intel Knights Corner (KNC) coprocessor, the first public MIC product. The results show that the pure OpenMP scalability of these applications is not sufficient to utilize the potential of a KNC coprocessor. While utilizing the hybrid MPI/OpenMP programming model helps to improve the parallel scalability, the maximum parallel speedup relative to a single thread is still not satisfactory. The OpenCL version of BT-MZ performs better than the OpenMP version but is not comparable to the MPI version and the hybrid MPI/OpenMP version. At the micro-architecture level, while the three CFD applications achieve reasonable instruction execution rates and L1 data cache hit rates, use a large percent of vector instructions, they have low arithmetic density, incur very high branch misprediction rates and do not utilize the Vector Processing Unit efficiently. As a result, they achieve very low single thread floating-point efficiency. For these applications to attain competitive performance on the MIC architecture as on the Xeon processors, both the parallel scalability and the single thread performance should be improved, which is a difficult task. [ABSTRACT FROM AUTHOR]

Dynamic voltage scaling (DVS), which adjusts the clock frequency and supply voltage based on the workload of systems, has been adopted in many computing systems to reduce the energy consumption of the processor. In this paper, we address the problem of minimizing overall energy consumption of a sporadic task in real-time system with a shared set of serially reusable, single unit resources, considering a generalized power model. We first present a static scheduling algorithm, called SSTSASR, which minimizes the system energy consumption of a given set of sporadic tasks and takes the off-chip workload into consideration, assuming that each task releases with the worstcase workload. In addition, we present dynamic slack reclamation techniques, called DSTSASR, which reclaims the slack time from the early completion task to reduce the energy consumption and takes the speed transition overhead into consideration. The simulation results show that the proposed DSTSASR algorithm could achieve a significant amount of energy savings compared with other DVS algorithms. It can reduce the energy consumption by 7.37-31.99% over the DVSSR and by 0.1-5.90% over the SSTSASR. [ABSTRACT FROM AUTHOR]

This paper presents an analysis of the energy consumption of an extensive number of the optimizations a modern compiler can perform. Using GCC as a test case, we evaluate a set of 10 carefully selected benchmarks for 5 different embedded platforms. A fractional factorial design is used to systematically explore the large optimization space (282 possible combinations), while still accurately determining the effects of optimizations and optimization combinations. Hardware power measurements on each platform are taken to ensure all architectural effects on the energy consumption are captured. We show that fractional factorial design can find more optimal combinations than relying on built-in compiler settings. We explore the relationship between run-time and energy consumption, and identify scenarios where they are and are not correlated. A further conclusion of this study is the structure of the benchmark has a larger effect than the hardware architecture on whether the optimization will be effective, and that no single optimization is universally beneficial for execution time or energy consumption. [ABSTRACT FROM PUBLISHER]

This work is primarily inspired by the observation that supervisory control and regulated rewriting have the same nature. Indeed, both of them model a system using some formalism and use a certain formalized control structure to restrict the behavior of the system via some designated control mechanisms. In this paper, we propose the theory of Control Systems (C Systems), which provides a more generic framework to integrate the automaton and grammar representations of control in supervisory control and regulated rewriting. The C system contains two components: the controlled component and the controlling component. The two components are expressed using the same formalism, e.g. automata or grammars. More specifically, we define three types of control systems based on the automaton or grammar representation, namely Automaton Control Systems (AC Systems), Grammar Control Systems (GC Systems) and Leftmost-derivation-based Grammar Control Systems (LGC Systems). We formally study their key theoretical characterizations, such as generative power, equivalence and translation techniques, as well as their connections with supervisory control and regulated rewriting, including the relationships between AC systems and supervisory control, and between GC/LGC systems and regulated rewriting. We also discuss some applications of C systems and finally propose some open questions. [ABSTRACT FROM PUBLISHER]

Large-scale instability of gravitating systems plays a key role in collisionless relaxation and in reaching a quasi-stationary state at the early stage of evolution. Advanced high-resolution methods and permanently increasing performance of computational systems allow this phenomenon to be studied by means of computer simulations at a new level. In this paper, an approach to verification and validation of computer codes implementing high-resolution methods is proposed. The approach is based on comparisons of the simulation results with exact non-stationary solutions of the Vlasov–Poisson equations. The evolution of the gravitating layer model is considered as an example of implementation of this approach. A one-parameter family of exact models of a non-stationary gravitating layer is described, and their stability to large-scale disturbances in the linear approximation is analytically studied. Non-linear instability development is computed with the use of the fifth-order conservative semi-Lagrangian WENO scheme. [ABSTRACT FROM AUTHOR]

In this paper, we investigate the advantages of the 2D Navier–Stokes–Voight (NSV) turbulence model for use in algorithms and explore its limits in the context of image inpainting. We begin by giving a brief review of the work of Bertalmio et al. in 2001 when an elegant analogy between the image intensity function for the image inpainting problem and the stream function in 2D incompressible fluid was established. An approximate solution to the inpainting problem was then obtained by numerically approximating the steady-state solution of the 2D Navier–Stokes vorticity transport equation, and simultaneously solving the Poisson problem between the vorticity and stream function, in the region to be inpainted. This elegant approach allows one to produce an approximate solution to the image inpainting problem by using techniques from computational fluid dynamics. Recently, the 3D NSV model of viscoelastic fluid was suggested by Cao et al. as an inviscid regularization to the 3D Navier–Stokes equations (NSEs). We give some background on the NSV model, describe why it is a good candidate sub-grid scale turbulence model and then we propose this model as an alternative partial differential equation for image inpainting. We describe an implementation of the inpainting procedure using the NSV model and then present numerical results comparing the images obtained when using the NSE versus the NSV model. Our results show that the NSV model allows for a larger time step to converge to the steady-state solution, yielding a more efficient numerical process when automating the inpainting process.We compare the quality of the resulting images using a subjective measure (human evaluation) and an objected measure (by calculating the peak signal-to-noise ratio). We also present some new theoretical results based on energy methods comparing the sufficient conditions for numerical stability for the two model equations. These theoretical and numerical studies shed some light on what can be expected from this category of approach when automating the inpainting problem. [ABSTRACT FROM AUTHOR]

ALGOL was formulated in Zurich in 1958, and this paper explores some of the reasons why this happened in Zurich and not in the USA. One factor may have been that the first computer on the continent, the Z4, was installed in Zurich in 1950. This computer was built by Zuse during the Second World War. It used relays for its arithmetic and control units, but it had a mechanical memory. Though the machine had limited capabilities, it provided valuable programming experience to a number of researchers, in particular to Stiefel, Rutishauser and Speiser at the ETH Zurich. Already in 1952, Rutishauser formulated a higher programming construct, a counted loop, and he also indicated how to convert mathematical expressions into machine language. We also should mention that Bauer, who was influenced by Rutishauser, also developed a method to implement mathematical expressions, but he used computer hardware for the task. The two started to collaborate, and they formulated a preliminary language in 1957. This language was then formalized at a ACM/GAMM meeting in Zurich under the name International Algebraic Language, or IAL, a language later renamed ALGOL 58. [ABSTRACT FROM PUBLISHER]

This paper outlines typical terminology for modeling and highlights key historical and forthcoming aspects of mathematical modeling. Mathematical models (MM) are mental conceptualizations, enclosed in a virtual domain, whose purpose is to translate real-life situations into mathematical formulations to describe existing patterns or forecast future behaviors in real-life situations. The appropriateness of the virtual representation of real-life situations through MM depends on the modeler's ability to synthesize essential concepts and associate their interrelationships with measured data. The development of MM paralleled the evolution of digital computing. The scientific community has only slightly accepted and used MM, in part because scientists are trained in experimental research and not systems thinking. The scientific advancements in ruminant production have been tangible but incipient because we are still learning how to connect experimental research data and concepts through MM, a process that is still obscure to many scientists. Our inability to ask the right questions and to define the boundaries of our problem when developing models might have limited the breadth and depth of MM in agriculture. Artificial intelligence (AI) has been developed in tandem with the need to analyze big data using high-performance computing. However, the emergence of AI, a computational technology that is data-intensive and requires less systems thinking of how things are interrelated, may further reduce the interest in mechanistic, conceptual MM. Artificial intelligence might provide, however, a paradigm shift in MM, including nutrition modeling, by creating novel opportunities to understand the underlying mechanisms when integrating large amounts of quantifiable data. Associating AI with mechanistic models may eventually lead to the development of hybrid mechanistic machine-learning modeling. Modelers must learn how to integrate powerful data-driven tools and knowledge-driven approaches into functional models that are sustainable and resilient. The successful future of MM might rely on the development of redesigned models that can integrate existing technological advancements in data analytics to take advantage of accumulated scientific knowledge. However, the next evolution may require the creation of novel technologies for data gathering and analyses and the rethinking of innovative MM concepts rather than spending resources in collecting futile data or amending old technologies. [ABSTRACT FROM AUTHOR]

Dynamically typed languages are becoming increasingly popular for different software development scenarios such as Web engineering, rapid prototyping or the construction of applications that require runtime adaptiveness. In contrast, statically typed languages have undeniable advantages such as early type error detection and more opportunities for compiler optimizations. Since both approaches offer different benefits, hybrid statically and dynamically typed programming languages have emerged, and some statically typed languages have also incorporated dynamic typing capabilities. In this paper, we present the minimal core of StaDyn, a hybrid typing language that performs static type inference of both statically and dynamically typed references. The type information gathered by the compiler is used to generate efficient .NET code, obtaining a significant runtime performance improvement compared with C# 4.0 and Visual Basic 10. [ABSTRACT FROM AUTHOR]

Wireless sensor networks (WSNs) are emerging as powerful platforms for distributed embedded computing supporting a variety of high-impact applications. However, programming WSN applications is a complex task that requires suitable paradigms and technologies capable of supporting the specific characteristics of such networks which uniquely integrate distributed sensing, computation and communication. Mobile agents are a distributed computing paradigm based on code mobility that has already demonstrated high effectiveness and efficiency in IP-based highly dynamic distributed environments. Due to their intrinsic characteristics, mobile agents may provide more benefits in the context of WSNs than in conventional distributed environments. In this paper we present the design, implementation and experimentation of MAPS (Mobile Agent Platform for Sun SPOT), an innovative Java-based framework for wireless sensor networks based on Sun SPOT technology which enables agent-oriented programming of WSN applications. The MAPS architecture is based on components that interact through events. Each component offers a minimal set of services to mobile agents that are modeled as multi-plane state machines driven by ECA rules. In particular, the offered services include message transmission, agent creation, agent cloning, agent migration, timer handling and easy access to the sensor node resources (sensors, actuators, input switches, flash memory and battery). Agent programming with MAPS is presented through both a simple example related to mobile agent-based monitoring of a sensor node and a more complex case study for real-time human activity monitoring based on wireless body sensor networks. Moreover, a performance evaluation of MAPS carried out by computing micro-benchmarks, related to agent communication, creation and migration, is illustrated. [ABSTRACT FROM AUTHOR]

As network speeds continue to increase, so does the need for scalable pattern matching for deep packet scanning applications such as signature-based network intrusion detection. Multiple-stride deterministic finite automaton (DFA) increases the performance of pattern matching, because they allow multiple bytes of a packet to be scanned simultaneously. However, traditional multiple-stride DFA either rely on specific hardware for parallel comparison or have a huge memory requirements due to state explosion. In this paper, we present a high throughput, multiple-stride pattern-matching architecture that requires a small storage cost and no specific hardware. The basic idea is to group DFA states/transitions into three coarse-grained and variable-size blocks, so that each individual block can employ different-specific methods to optimize storage requirements and performance. The blocks are naturally identified based on basic observations of DFA characteristics: prefix, linear trie and state dependencies. The performance evaluation is done using the Snort pattern sets. We show that multi-byte striding DFA achieves multi Gb/s pure content inspection in software, while utilizing <3 bytes per pattern character. [ABSTRACT FROM AUTHOR]

The paper proposes a simple protocol that ensures sequential consistency. The protocol assumes that the shared memory abstraction is supported by the local memories of nodes that can communicate only by exchanging messages through reliable channels. Unlike other sequential consistency protocols, the one proposed here does not rely on a strong synchronization mechanism, such as an atomic broadcast primitive or a central node managing a copy of every shared object. From a methodological point of view, the protocol is built incrementally starting from the very definition of sequential consistency. It has the noteworthy property that a process that issues a write operation never has to wait for other processes. Depending on the current local state, most read operations issued also have the same property. [ABSTRACT FROM PUBLISHER]

This paper is dedicated to the connection, by a provider, of multiple groups of nodes spread over a network. The role of the provider is to interconnect the members of every group. For this purpose, it must distribute the available links of the network between the groups. The general aim then is to allocate these links in such a way that the communications latencies in the allocated structure are equivalent to the ones in the original (full) network for each group. We study two approaches constructing structures preserving the maximum latency (called the diameter). Unfortunately we show that the associated optimization graph problems are difficult (one cannot be approximated by a constant and the other is NP-complete). Due to these difficulties we relax the constraint on the diameter and propose to construct a unique tree connecting all the groups together. We give a heuristic to treat this problem and we propose several analytical results on its maximum and average latencies performance. [ABSTRACT FROM PUBLISHER]

As an effective means of multi-agent problem solving, autonomous individual programming and interaction that are essential need, are limited in their ability to accommodate the interests of others, and therefore, may unnecessarily constrain the solving ability and negotiability of an agent, particularly in a distributed cooperative environments founded on private and uncertain information. In this paper, a multi-agent group programming model is presented, where each agent executes local programming by evolutionary search. Based on co-evolution idea, agents resolve conflicts and revise their own search direction to optimize local and social objectives in an interactive process by means of clustering and group choice. Finally, the paper presents simulation results that illustrate the operational effectiveness of our agent group programming model. [ABSTRACT FROM PUBLISHER]

Let G(V, E) be an undirected connected graph, where each vertex v is associated with a positive cost C(v) and each edge e = (u, v) is associated with two positive weights, W(u → v) and W(v → u). We consider a new graph problem, called the edge-orientation problem (the EOP). The major issue is to assign each edge e = (u, v) an orientation, either from u to v, denoted as u → v, or from v to u, denoted as v → u, such that maxx∈V{C(x) + Σx→z W(x → z)} is minimized. This paper first shows that the EOP is NP-hard on split graphs and planar graphs. Then, a linear-time algorithm on star graphs is proposed by the prune-and-search strategy. Finally, the algorithmic result on star graphs is extended to trees and simple cactus graphs using the dynamic programming strategy. [ABSTRACT FROM AUTHOR]

Abstract: Research on heuristic evaluation in recent years has focused on improving its effectiveness and efficiency with respect to user testing. The aim of this paper is to refine a research agenda for comparing and contrasting evaluation methods. To reach this goal, a framework is presented to evaluate the effectiveness of different types of support for structured usability problem reporting. This paper reports on an empirical study of this framework that compares two sets of heuristics, Nielsen’s heuristics and the cognitive principles of Gerhardt-Powals, and two media of reporting a usability problem, i.e. either using a web tool or paper. The study found that there were no significant differences between any of the four groups in effectiveness, efficiency and inter-evaluator reliability. A more significant contribution of this research is that the framework used for the experiments proved successful and should be reusable by other researchers because of its thorough structure. [Copyright &y& Elsevier]

Most microprocessor chips today use an out-of-order instruction execution mechanism. This mechanism allows superscalar processors to extract reasonably high levels of instruction level parallelism (ILP). The most significant problem with this approach is a large instruction window and the logic to support instruction issue from it. This includes generating wake-up signals to waiting instructions and a selection mechanism for issuing them. Wide-issue width also requires a large multi-ported register file, so that each instruction can read and write its operands simultaneously. Neither structure scales well with issue width leading to poor performance relative to the gates used. Furthermore, to obtain this ILP, the execution of instructions must proceed speculatively. An alternative, which avoids this complexity in instruction issue and eliminates speculative execution, is the microthreaded model. This model fragments sequential code at compile time and executes the fragments out of order while maintaining in-order execution within the fragments. The only constraints on the execution of fragments are the dependencies between them, which are managed in a distributed and scalable manner using synchronizing registers. The fragments of code are called microthreads and they capture ILP and loop concurrency. Fragments can be interleaved on a single processor to give tolerance to latency in operands or distributed to many processors to achieve speedup. The implementation of this model is fully scalable. It supports distributed instruction issue and a fully scalable register file, which implements a distributed, shared-register model of communication and synchronization between multiple processors on a single chip. This paper introduces the model, compares it with current approaches and presents an analysis of some of the implementation issues. It also presents results showing scalable performance with issue width over several orders of magnitude, from the same binary code. [ABSTRACT FROM AUTHOR]

In this paper we define a model theory and give a semantic proof of cut-elimination for ICTT, an intuitionistic formulation of Church's theory of types defined by Miller et. al. and the basis for the Prolog programming language. Our approach, extending techniques of Takahashi and Andrews and tableaux machinery of Fitting, Smullyan, Nerode and Shore, is to prove a completeness theorem for the cut-free fragment and show semantically that cut is a derived rule. This allows us to generalize a result of Takahashi and Schutte on extending partial truth valuations in impredicative systems. We extend Andrews' notion of Hintikka sets to intuitionistic higher-order logic in a way that also defines tableau-provability for intuitionistic type theory. In addition to giving a completeness theorem without using cut we then show, using cut, how to establish completeness of more conventional term models. These models give a declarative semantics for the logic underlying the Prolog programming. language. [ABSTRACT FROM AUTHOR]

In this paper we encode higher-order rewriting with names into higher-order rewriting in de Bruijn notation. This notation not only is defined for terms (as usually done in the literature) but also for metaterms, which are the syntactical objects used to express the rewriting rules of higher-order systems. Several examples are discussed. Fundamental properties such as confluence and normalisation are shown to be preserved. [ABSTRACT FROM AUTHOR]

Event-based middleware is currently being applied for application component integration in a range of application domains. As a result, a variety of event services has been proposed to address different requirements. In order to aid the understanding of the relationships between these systems, this paper presents a taxonomy of distributed event-based programming systems. The taxonomy is structured as a hierarchy of the properties of a distributed event system and may be used as a framework to describe such a system according to its properties. The taxonomy identifies a set of fundamental properties of event systems and categorizes them according to the event model supported and the structure of the event service. Event services are further classified according to their organization and their interaction models, as well as other functional and non-functional features. [ABSTRACT FROM PUBLISHER]

Grid middleware development has advanced rapidly over the past few years to support component-based programming models and service-oriented architectures. This is most evident with the forthcoming release of the Globus toolkit (GT4), which represents a convergence of concepts (and standards) from both the grid and web-services communities. Grid applications are increasingly modular, composed of workflow descriptions that feature both resource and application dynamism. Understanding the performance implications of scheduling grid workflows is critical in providing effective resource management and reliable service quality to users. This paper describes a series of extensions to an existing performance-aware grid management system (TITAN). These extensions provide additional support for workflow prediction and scheduling using a multi-domain performance management infrastructure. [ABSTRACT FROM PUBLISHER]