Spiking Neural Networks are a class of Artificial Neural Networks that closely mimic biological neural networks. They are particularly interesting because of their potential to advance research in several fields, both because of better insights on neural behaviour (benefiting medicine, neuroscience, psychology) and the potential in Artificial Intelligence. Their ability to run on a low energy budget once implemented in hardware makes them even more appealing. However, because of their behaviour that evolves with time, when a hardware implementation is not available, their output cannot simply be computed with a one-shot function (however complex), but instead they need to be simulated.

Abstract Nowadays, the role played by registries in monitoring and improving healthcare, including the quality of medical devices, is widely recognized. A well‐designed digital healthcare registry, in particular regarding data collection procedures and tools, can effectively support goals such as monitoring a (large) population subject to a specific condition, describing the natural history of diseases, supporting observational study methods, as well as evaluating the clinical effectiveness or cost effectiveness of healthcare products and services. This article describes the architecture of a new platform implementing a digital interoperable healthcare registry, the Italian Implantable Prostheses Registry (RIPI). One of the main goals of RIPI is to provide reliable and high‐quality data for monitoring surgery outcomes, performing survival analysis, assessing the safety of devices and procedures, and supporting the traceability of patients. The article focuses on the key aspects and choices that guided the design and implementation processes of the new platform. Most of the design choices came from specific requirements to fulfill, in particular concerning data quality, access policy, interoperability, extensibility and modularity. Overall, the article discusses the main challenges and the adopted solutions, proposing a design perspective and describing an experience of interest for computer scientists, engineers and practitioners, in particular in the area of healthcare information systems.

Summary Multithreaded applications facilitate the exploitation of the computing power of multicore architectures. On the other hand, these applications can become extremely energy‐intensive, in contrast with the need for limiting the energy usage of computing systems. In this article, we explore the design of techniques enabling multithreaded applications to maximize their performance under a power cap. We consider two control parameters: the number of cores used by the application, and the core power state. We target the design of an autotuning power‐capping technique with minimal intrusiveness and high portability, which is agnostic about the workload profile of the application. We investigate two different approaches for building the strategy for selecting the best configuration of the parameters under control, namely a heuristic approach and a model‐based approach. Through an extensive experimental study, we evaluate the effectiveness of the proposed technique considering two different selection strategies, and we compare them with existing solutions.

Summary In this article, we present mutable locks, a synchronization construct with the same semantic of traditional locks (such as spin locks or sleep locks), but with a self‐tuned optimized trade‐off between responsiveness and CPU‐time usage during threads' wait phases. Mutable locks tackle the need for efficient synchronization supports in the era of multicore machines, where the run‐time performance should be optimized while reducing resource usage. This goal should be achieved with no intervention by the programmers. Our proposal is intended for exploitation in generic concurrent applications, where scarce or no knowledge is available about the underlying software/hardware stack and the workload. This is an adverse scenario for static choices between spinning and sleeping, which is tackled by our mutable locks thanks to their hybrid waiting phase and self‐tuning capabilities.

Software Transactional Memory (STM) stands as powerful concurrent programming paradigm, enabling atomicity, and isolation while accessing shared data. On the downside, STM may suffer from performance degradation due to excessive conflicts among concurrent transactions, which cause waste of CPU-cycles and energy because of transaction aborts. An approach to cope with this issue consists of putting in place smart scheduling strategies which temporarily suspend the execution of some transaction in order to reduce the transaction conflict rate. In this article, we present an adaptive model-based transaction scheduling technique relying on a Markov Chain-based performance model of STM systems. Our scheduling technique is adaptive in a twofold sense: (i) It controls the execution of transactions depending on throughput predictions by the model as a function of the current system state. (ii) It re-tunes on-line the Markov Chain-based model to adapt it-and the outcoming transaction scheduling decisions-to dynamic variations of the workload. We have been able to achieve the latter target thanks to the fact that our performance model is extremely lightweight. In fact, to be recomputed, it requires a reduced set of input parameters, whose values can be estimated via a few on-line samples related to the current workload dynamics. We also present a scheduler that implements our adaptive technique, which we integrated within the open source TinySTM package. Further, we report the results of an experimental study based on the STAMP benchmark suite, which has been aimed at assessing both the accuracy of our performance model in predicting the actual system throughput and the advantages of the adaptive scheduling policy over literature techniques.

Controlling power usage has become a core objective in modern computing platforms. In this article we present an innovative Time Warp architecture oriented to efficiently run parallel simulations under a power cap. Our architectural organization considers power usage as a foundational design principle, as opposed to classical power-unaware Time Warp design. We provide early experimental results showing the potential of our proposal.

Energy consumption has become a core concern in computing systems. In this context, power capping is an approach that aims at ensuring that the power consumption of a system does not overcome a predefined threshold. Although various power capping techniques exist in the literature, they do not fit well the nature of multi-threaded workloads with shared data accesses and non-minimal thread-level concurrency. For these workloads, scalability may be limited by thread contention on hardware resources and/or data, to the point that performance may even decrease while increasing the thread-level parallelism, indicating scarce ability to exploit the actual computing power available in highly parallel hardware. In this paper, we consider the problem of maximizing the performance of multi-thread applications under a power cap by dynamically tuning the thread-level parallelism and the power state of CPU-cores in combination. Based on experimental observations, we design a technique that adaptively identifies, in linear time within a bi-dimensional space, the optimal parallelism and power state setting. We evaluated the proposed technique with different benchmark applications, and using different methods for synchronizing threads when accessing shared data, and we compared it with other state-of-the-art power capping techniques.

Software Transactional Memory (STM) may suffer from performance degradation due to excessive conflicts among concurrent transactions. An approach to cope with this issue consists in putting in place smart scheduling policies which temporarily suspend the execution of some transaction in order to reduce the actual conflict rate. In this paper, we present an adaptive transaction scheduling policyrelying on a Markov Chain-based model of STM systems. The policy is adaptive in a twofold sense: (i) it schedules transactions depending on throughput predictions by the model as a function of the current system state, (ii) its underlying Markov Chain-based model is periodically re-instantiated at run-time to adapt it to dynamic variations of the workload. We also present an implementation of our adaptive transaction scheduler which has been integrated within the open source TinySTM package. The accuracy of our performance model in predicting the system throughput and the advantages of the adaptive scheduling policy over state-of-the-art approaches have been assessed via an experimental study based on the STAMP benchmark suite.

In this paper, we present a novel framework for supporting the management and optimization of application subject to software anomalies and deployed on large scale cloud architectures, composed of different geographically distributed cloud regions. The framework uses machine learning models for predicting failures caused by accumulation of anomalies. It introduces a novel workload balancing approach and a proactive system scale up/scale down technique. We developed a prototype of the framework and present some experiments for validating the applicability of the proposed approaches.

In this article we exploit a combination of analytical and Machine Learning (ML) techniques in order to build a performance model allowing to dynamically tune the level of concurrency of applications based on Software Transactional Memory (STM). Our mixed approach has the advantage of reducing the training time of pure machine learning methods, and avoiding approximation errors typically affecting pure analytical approaches. Hence it allows very fast construction of highly reliable performance models, which can be promptly and effectively exploited for optimizing actual application runs. We also present a real implementation of a concurrency regulation architecture, based on the mixed modeling approach, which has been integrated with the open source Tiny STM package, together with experimental data related to runs of applications taken from the STAMP benchmark suite demonstrating the effectiveness of our proposal.

In this paper we explore machine-learning approaches for dynamically selecting the well suited amount of concurrent threads in applications relying on Software Transactional Memory (STM). Specifically, we present a solution that dynamically shrinks or enlarges the set of input features to be exploited by the machine-learner. This allows for tuning the concurrency level while also minimizing the overhead for input-features sampling, given that the cardinality of the input-feature set is always tuned to the minimum value that still guarantees reliability of workload characterization. We also present a fully heedged implementation of our proposal within the TinySTM open source framework, and provide the results of an experimental study relying on the STAMP benchmark suite, which show significant reduction of the response time with respect to proposals based on static feature selection.

One of the problems of Software-Transactional-Memory (STM) systems is the performance degradation that can be experienced when applications run with a non-optimal concurrency level, namely number of concurrent threads. When this level is too high a loss of performance may occur due to excessive data contention and consequent transaction aborts. Conversely, if concurrency is too low, the performance may be penalized due to limitation of both parallelism and exploitation of available resources. In this paper we propose a machine-learning based approach which enables STM systems to predict their performance as a function of the number of concurrent threads in order to dynamically select the optimal concurrency level during the whole lifetime of the application. In our approach, the STM is coupled with a neural network and an on-line control algorithm that activates or deactivates application threads in order to maximize performance via the selection of the most adequate concurrency level, as a function of the current data access profile. A real implementation of our proposal within the TinySTM open-source package and an experimental study relying on the STAMP benchmark suite are also presented. The experimental data confirm how our self-adjusting concurrency scheme constantly provides optimal performance, thus avoiding performance loss phases caused by non-suited selection of the amount of concurrent threads and associated with the above depicted phenomena.

Pervasive Grid applications solve complex tasks in distributed environments relying on centralized and decentralized nodes interconnected by wireless and wired networks. Examples of such applications are Emergency Management and Intelligent Transportation. In previous works we introduced the ASSISTANT programming model as a support for easy and effective development of pervasive Grid applications. In this work we extend ASSISTANT in order to support fault tolerance. This is done by providing constructs enabling and controlling replication. Via these constructs, the application programmers can express replication strategies, which are automatically managed by the ASSISTANT run-time support in terms of replica consistency. We also report some experimental results showing reduced performance overheads for the classical case of replica consistency relying on a-priori agreement on the processing order of input streams in case of a flood emergency management application.

APART (A Posteriori Active ReplicaTion) is a recently proposed active replication protocol specifically tailored for multi-tier data acquisition systems. It ensures consistency of middle-tier sink replicas by means of an a-posteriori synchronization phase based on reconciliation, which is activated only in case replicas react to an input message from the sensors by generating an output event destined to the back-end tier. This paper enhances APART via a novel non-blocking synchronization scheme which prevents replicas from stalling while waiting for the outcome of an on-going synchronization phase. Contrarily, replicas are allowed to optimistically process data from the sensors, and to immediately propagate any output event towards the back-end tier. The removal of the blocking synchronization phase from the critical path gives rise to striking performance gains via an effective overlapping of event processing and synchronization. On the other hand, system consistency is ensured by enhancing the back-end tier synchronization logic in order to filter out optimistically produced output events that are incompatible with the reconciled state trajectory.

The Markov modulated Poisson process (MMPP) has been shown to well describe the flow of incoming traffic in networked systems, such as the Grid and the WWW. This makes the MMPP/M/1 queue a valuable instrument to evaluate and predict the service level of networked servers. In a recent work we have provided an approximate solution for the response time distribution of the MMPP/M/1 queue, which is based on a weighted superposition of M/M/l queues (i.e. a hyper-exponential process). In this article we address the tradeoff between the accuracy of this approximation and its computational cost. By jointly considering both accuracy and cost, we identify the scenarios where such approximate solution could be effectively used in support of network servers (dynamic) configuration and evaluation strategies, aimed at ensuring the agreed dependability levels in case of, e.g., request redirection due to faults.

This paper proposes APART (a posteriori active replication), a novel active replication protocol specifically tailored for multi-tier data acquisition systems. Unlike existing active replication solutions, APART does not rely on a-priori coordination schemes determining a same schedule of events across all the replicas, but it ensures replicas consistency by means of an a-posteriori reconciliation phase. The latter is triggered only in case the replicated servers externalize their state by producing an output event towards a different tier. On one hand, this allows coping with non-deterministic replicas, unlike existing active replication approaches. On the other hand, it allows attaining striking performance gains in the case of silent replicated servers, which only sporadically, yet unpredictably, produce output events in response to the receipt of a (possibly large) volume of input messages. This is a common scenario in data acquisition systems, where sink processes, which filter and/or correlate incoming sensor data, produce output messages only if some application relevant event is detected. Further, the APART replica reconciliation scheme is extremely lightweight as it exploits the cross-tier communication pattern spontaneously induced by the application logic to avoid explicit replicas coordination messages.

Input characterization to describe the flow of incoming traffic in network systems, such as the GRID and the WWW, is often performed by using Markov modulated Poisson processes (MMPP). Therefore, to enact capacity planning and quality-of-service (QoS) oriented design, the model of the hosts that receive the incoming traffic is often described as a MMPP/M/1 queue. The drawback of this model is that no closed form for its solution has been derived. This means that evaluating even the simplest output statistics of the model, such as the average response times of the queue, is a computationally intensive task and its usage in the above contexts is often unadvisable. In this paper we discuss the possibility to approximate the behavior of a MMPP/M/1 queue with a computational effective analytical approximation, thus saving the large amount of calculations required to evaluate the same data by other means. The employed method consists in approximating the MMPP/M/1 queue as a weighted superposition of different M/M/1 queues. The analysis is validated by comparing the results of a discrete event simulator with those obtained from the proposed approximations, in the context of a real case study involving a GRID networked server.

Response time is a key factor of any e-commerce application, and a set of solutions have been proposed to provide low response time despite network congestions or failures. Being them mostly based on caching of Web objects and replication of DBMS managed data at the edges, or at intermediate points, of the Web infrastructure, they reveal effective when handling client requests only performing read access to application data. However, any update request typically needs to be redirected to the origin DBMSs, hence not taking advantage from data replication and related client proximity. In order to alleviate the effects of network congestions or failures, we have proposed a multi-path protocol that increases the likelihood for the update request to be processed along a responsive (e.g. failure free) network path in between the client location and the origin DBMS sites. In this paper we present an extensive simulation study of the effects of such a multi-path approach on the client perceived response time. The study relies on both Brite generated network topologies and the NLANR graph. Also, well known realistic TCP models are used to capture the effects of network delays during both normal and anomalous (i.e. packet loss affected) operation mode

A content delivery network (CDN) is composed by a set of "reverse proxies" placed in proper geographical locations which provide caching and content distribution services to third party Web sites. Client requests are dispatched to one of the cache nodes that constitute the proxy by using content-aware and state-aware switching. Different distributions are generally believed to be more representative of the general traffic behavior; the classical Markovian model well captures the peculiarities of high intensity traffic during the busiest periods. The Markov chain is finite since, it admits a maximum amount of concurrently processed requests and derive the asymptotic state probabilities of the model of the CDN which can be finally used to configure the CDN with proper parameters to sustain the requested service levels, and thus to meet the SLA for each service class.

The e-transaction abstraction is a recent formalization of end-to-end reliability properties for three-tier systems. In this work, we present a protocol ensuring the e-transaction guarantees in case the back-end tier consists of a centralized database. Our proposal addresses the case of stateless application servers, and is both simple and effective since 1) it does not employ any distributed commit protocol and 2) does not require coordination among the replicas of the application server.

Quality-of-service (QoS) provisioning in the Internet has been a topic of active research in the last few years. However, due to both financial and technical reasons, the proposed solutions are not commonly employed in practice. As a consequence, the Internet architecture is still mainly oriented to a best effort delivery model, which does not provide any guarantee neither on the message delivery latency, nor on the probability that a service residing at some host becomes temporarily unreachable due to network congestion. We address this issue by presenting an innovative, application level protocol tailored for Web transactional applications, which attempts to reduce the impact of network congestion on the latency experienced by the end-users. The intuition underlying our proposal is to exploit the intrinsic potential of parallelism commonly exhibited by application service provider (ASP) infrastructures, where the application access point is replicated over a large number of geographically distributed edge servers. At this purpose, we allow privileged classes of users to concurrently contact multiple, replicated access points so to increase the probability to timely reach at least one of them and to promptly activate the application business logic for the interaction with a back-end database system. We complete our proposal with an efficient mechanism that prevents multiple, undesired updates on the back-end database and, at the same time, strongly limits the additional load on the ASP infrastructure due to the increased amount of requests from the privileged users.

Architectures consisting of multiple cache servers are a popular solution to deal with performance and network resource utilization issues related to the growth of the Web request. Cache cooperation is often carried out through purely hierarchical and flat schemes that suffer from scalability problems when the number of servers increases. We propose, implement and compare the performance of three novel distributed cooperation models based on a two-tier organization of the cache servers. The experimental results show that the proposed architectures are effective in supporting cooperative document lookup and download They guarantee cache hit rates comparable to those of the most performing protocols with a significant reduction of the cooperation overhead Moreover in case of congested network, they reduce the 90-percentile of the system response time up to nearly 30% with respect to the best pure cooperation mechanisms.

The benefits of Web caching can be improved by systems of cooperative cache servers that share their cached documents. The increasing number of Web cache servers over the Internet makes the scalability of the cooperation protocol a major issue to be addressed. In this paper, we propose the Two-Tier Cooperation (2TC) protocol, which is specifically designed for systems of dozens or hundreds of cache servers with no centralized control. 2TC embeds two classical cooperation approaches for distributed Web caching systems, namely informed cooperation (IC) and query cooperation (QC), that are applied within different subsets of cache servers in the system. IC is applied within subsets of close servers and lets them cooperate through mutual exchange of state information related to their cache content. QC lets more distant cache servers cooperate through query/reply messages to locate documents within the global cache. Thanks to the use of IC among close cache servers, QC can explore the cache content of several cache servers through a single query message. High scalability arises as few queries explore the cache content of many cache servers and state information is exchanged within small groups of close cache servers. We report experimental results based on real traces that compare a prototype implementation of 2TC with classical protocols of the informed and query classes. The results point out a strong reduction (up to 50%) of the amount of transferred information to manage cooperation. This overhead reduction is achieved with no performance degradation in terms of latency and cache hit rate.

Sharing cached documents among cooperative Web proxies is an effective solution to reduce Web traffic and alleviate network bottlenecks. This paper aims at comparing the performance of two cooperation protocols which follow opposite approaches: the Internet Cache Protocol (ICP) and the Full Informed Protocol (FIP). The former activates information exchange among proxies on client demand; the latter guarantees that any proxy is kept informed about the cache content of all the other cooperative proxies. The performance comparison is carried out through analytical models determining under which conditions one protocol outperforms the other. Our analysis shows that ICP is often preferable to FIP, thus pointing out that the client demand based approach is an effective solution for proxy cooperation.

Discrete event simulation is a methodology to study the behavior of complex systems. Its drawback is that, in order to get reliable results, simulations usually have to be run over a long stretch of time. This time requirement could decrease through the usage of parallel or distributed computing systems. In this paper, we analyze the Time Warp synchronization protocol for parallel discrete event simulation and present an analytical model evaluating the upper bound on the completion time of a Time Warp simulation. In our analysis, we consider the case of a simulation model with homogeneous logical processes, where "homogeneous" means they have the same average event routine time and the same state saving cost. Then we propose a methodology to determine when it is time-convenient to use a Time Warp synchronized simulation, instead of a sequential one, for a simulation model with features matching those considered in our analysis. We give an answer to this question without the need to preliminary generate the simulation code. Examples of methodology usage are reported for the case of both a synthetic benchmark and a real world model.

A useless checkpoint corresponds to the occurrence of a checkpoint and communication pattern called Z-cycle. A recent result shows that ensuring a computation without Z-cycles is a particular application of a property, namely Virtual Precedence (VP), defined on an interval-based abstraction of a computation. We first propose a taxonomy of communication-induced checkpointing protocols based on the way they ensure the VP property. Then we derive a sufficient condition ensuring no Z-cycles in a distributed computation. This condition defines a checkpoint and communication pattern, namely suspect Z-cycle, such that if no suspect Z-cycle exists in a distributed computation then no Z-cycle exists. We present finally a communication-induced checkpointing protocol that avoids useless checkpoints by preventing on-the-fly the formation of suspect Z-cycles and discuss its performance with respect to other protocols.

A system structure and protocols for improving the performance of a distributed transaction processing system when there is some regional locality of data reference are presented. A distributed computer system is maintained at each region, and a central computer system with a replication of all databases at the distributed sites is introduced. It provides the advantage of distributed systems principally for local transactions, and has the advantage of centralized systems for transactions accessing nonlocal data. Specialized protocols keep the copies at the distributed and centralized systems consistent without incurring the overhead and delay of generalized protocols for fully replicated databases. The advantages achievable through this system structure and the tradeoffs between protocols for concurrency and coherency control of the duplicate copies of the databases are studied. An approximate analytic model is used to estimate the system performance. It is found that the performance is sensitive to the protocol and that substantial performance improvement can be obtained as compared with distributed systems.>

An innovative method for the 'apparent' yield evaluation is presented. By this method it is possible to evaluate the quality of the manufacturing process and the expected fraction of truly good chips at the end of the testing and reconfiguration phase. It permits the characterization of fault-tolerant VLSI chips (or WSI systems) with and without redundancy. It is easy to use and permits the predictability of the approximation level of the yield values.>

A yield calculation method for the yield formula of fault-tolerant VLSI chips that improves existing methods and combines generalities, ease of computation, and predictability in approximation levels is presented. The method is concerned with the evaluation of the probability that a chip is acceptable given n defects. This is accomplished by introducing a Markov chain model in which each state represents an operating chip configuration, and the state transitions take place in the presence of manufacturing defects. Results from the comparison of this method to a method for memory chip yield evaluation, a method for the M-out-of-N yield problem evaluation, and a method for the square grid chip yield evaluation are presented.>

The authors develop an approximate analytical model to study the tradeoffs of replicating data in a distributed database environment. Several concurrency control protocols are considered, including pessimistic, optimistic, and semi-optimistic protocols. The approximate analysis captures the effect of the protocol on hardware resource contention and data contention. The accuracy of the approximation is validated through detailed simulations. It is found that the benefit of replicating data and the optimal number of replicates are sensitive to the concurrency control protocol. Under the optimistic and semi-optimistic protocols, replications can significantly improve response time with an additional MIPS (million instructions per second) requirement to maintain consistency among the replicates. The optimal degree of replication is further affected by the transaction mix (e.g. the fraction of read-only transactions), the communications delay and overhead, the number of distributed sites, and the available MIPS. Sensitivity analyses have been carried out to examine how the optimal degree of replication changes with respect to these factors.>

A hybrid system structure comprised of distributed systems to take advantage of locality of reference and a central system to handle transactions that access non-local data is examined. Several transaction processing applications, such as reservation systems, insurance and banking have such regional locality of reference. A concurrency and coherency control protocol that maintains the integrity of the data and performs well for transactions that access local or non-local data is described. It is shown that the performance of the hybrid system is much less sensitive to the fraction of remote accesses than the distributed system and offers similar performance to the distributed system for local transactions.>

Conventional M-out-of-N yield models can only roughly represent many practical chip architectures. On the other hand, representative models have the drawback of computational complexity. A yield model is introduced that overcomes the limits of existing models and provides ease of computation and predictability in approximation levels. The model is versatile enough to be included in CAM/CAD programming environments. Some application examples are given to illustrate the model accuracy, ease of use, and flexibility.>

An examination is made of a system structure and protocols to improve the performance and availability of a distributed transaction processing (TP) system when there is some regional locality of data reference. Several TP applications, such as reservation systems, insurance, and banking, belong to this category. While maintaining a distributed system at each region, a central system is introduced with a replication of all databases at the distributed sites. Specialized protocols can be designed to keep the copies at the distributed and centralized systems consistent without incurring the overhead and delay of generalized protocols for fully replicated databases. The authors study the advantages of this system structure and the tradeoffs between protocols for concurrency and coherency control of the duplicate copies of the databases. An approximate analytic model is used to estimate the system performance and the method is validated through simulations.>

The author shows that formula (9) of the above mentioned paper (see ibid., vol.C-33, p.113-124, (1984)) is erroneous. A new solution is proposed, and its congruency is shown.>

In a hybrid distributed-centralized database system architecture, some transactions run at (geographically) distributed systems, and other transactions at a central computing complex. Static and dynamic load-sharing strategies are studied for such systems. The strategies take into account not only the difference in load at different sites, but also the effect of routing on data-contention and transaction-abort probabilities. Five dynamic strategies are examined and are compared with an optimal static strategy. A dynamic strategy that is based on analytical estimates of the effect of routing on all transactions in the system, rather than that on the incoming transaction alone, is found to be the best.>

A combined performance and reliability (performability) measure for gracefully degradable fault-tolerant satellite systems is introduced, and a closed-form analytic solution is provided in order to compute the performability for a class of unrepairable systems. An efficient algorithm for the solution of Markovian models which take into account the degradation of more than one type of system components is given. By means of an example on a commercial communication-satellite system we intend to illustrate this novel measure and compare it to more conventional ones.