Abstract
This article describes a framework for synchronization optimizations and a set of transformations for programs that implement critical sections using mutual exclusion locks. The basic synchronization transformations take constructs that acquire and release locks and move these constructs both within and between procedures. They also eliminate, acquire and release constructs that use the same lock and are adjacent in the program. The article also presents a synchronization optimization algorithm, lock elimination, that uses these transformations to reduce the synchronization overhead. This algorithm locates computations that repeatedly acquire and release the same lock, then transforms the computations so that they acquire and release the lock only once. The goal of this algorithm is to reduce the lock overhead by reducing the number of times that computations acquire and release locks. But because the algorithm also increases the sizes of the critical sections, it may decrease the amount of available concurrency. The algorithm addresses this trade-off by providing several different optimization policies. The policies differ in the amount by which they increase the sizes of the critical sections. Experimental results from a parallelizing compiler for object-based programs illustrate the practical utility of the lock elimination algorithm. For three benchmark applications, the algorithm can dramatically reduce the number of times the applications acquire and release locks, which significantly reduces the amount of time processors spend acquiring and releasing locks. The resulting overall performance improvements for these benchmarks range from no observable improvement to up to 30% performance improvement.

Abstract

Abstract

Abstract
This paper describes the main steps needed to apply neural networks in the domain of dynamic security assessment (DSA). The paper provides also an overview of the application of neural networks in DSA. Special emphasis is given to the application of this approach in a medium size real system where a large penetration of wind power is foreseen.

Abstract
Preliminary filtering of a large decision set can be an important issue in multicriteria problems. Besides eliminating dominated solutions, it is usual to define aspiration levels in some or all the attributes, and then eliminate all the solutions that do not respect the imposed limits. This procedure may lead to the undesired elimination of possibly interesting solutions, due to the irrelevant violation of a specified limit. In this paper, a new method is presented that overcomes this problem by defining the concept of accepted solution as a fuzzy set and calculating a degree of acceptance for each solution that takes values in the interval [0, 1] instead of having only the crisp {0, 1} values. The method also deals with fuzzy attributes, and has an additional feature of advising the decision maker regarding the definition of the acceptance level that leads to selection or exclusion of an alternative. To illustrate the application of the fuzzy filtering method (FFM), a planning problem in the area of power distribution systems is used. The example shows how FFM can be used to reduce an initial set of 48 plans, according to the expressed aspiration levels.

Abstract
This paper presents a technique, adaptive replication, for automatically eliminating synchronization bottlenecks in multithreaded programs that perform atomic operations on objects. Synchronization bottlenecks occur when multiple threads attempt to concurrently update the same object. It is often possible to eliminate synchronization bottlenecks by replicating objects. Each thread can then update its own local replica without synchronization and without interacting with other threads. When the computation needs to access the original object, it combines the replicas to produce the correct values in the original object. One potential problem is that eagerly replicating all objects may lead to performance degradation and excessive memory consumption. Adaptive replication eliminates unnecessary replication by dynamically measuring the amount of contention at each object to detect and replicate only those objects that would otherwise cause synchronization bottlenecks. We have implemented adaptive replication in the context of a parallelizing compiler for a subset of C++. Given an unannotated sequential program written in C++, the compiler automatically extracts the concurrency, determines when it is legal to apply adaptive replication, and generates parallel code that uses adaptive replication to efficiently eliminate synchronization bottlenecks. Our experimental results show that for our set of benchmark programs, adaptive replication can improve the overall performance by up to a factor of three over versions that use no replication, and can reduce the memory consumption by up to a factor of four over versions that fully replicate updated objects. Furthermore, adaptive replication never significantly harms the performance and never increases the memory usage without a corresponding increase in the performance.