Parallelizing and optimizing codes for recent multi-/many-core processors have been recognized to be a complex task. For this reason, strategies to automatically transform sequential codes into parallel and discover optimization opportunities are crucial to relieve the burden to developers. In this paper, we present a compile-time framework to (semi) automatically find parallel patterns (Pipeline and Farm) and transform sequential streaming applications into parallel using GrPPI, a generic parallel pattern interface. This framework uses a novel pipeline stage-balancing technique which provides the code generator module with the necessary information to produce balanced pipelines. The evaluation, using a synthetic video benchmark and a real-world computer vision application, demonstrates that the presented framework is capable of producing parallel and optimized versions of the application. A comparison study under several thread-core oversubscribed conditions reveals that the framework can bring comparable performance results with respect to the Intel TBB programming framework.

The emergence of generic interfaces, encapsulating algorithmic aspects in pattern-based constructions, has greatly alleviated the development of data-intensive and stream-processing applications. In this paper, we complement the basic patterns supported by GRPPI, a C++ General and Reusable Parallel Pattern Interface of the state-of-the-art, with the advanced parallel patterns Pool, Windowed-Farm, and Stream-Iterator. This collection of advanced patterns is basically oriented to some domain-specific applications, ranging from the evolutionary to the real-time computing areas, where compositions of basic patterns are not capable of fully mimicking algorithmic behavior of their original sequential codes. The experimental evaluation of the advanced patterns on a set of domain-specific use-cases, using different back-ends (C++ Threads, OpenMP and Intel TBB) and pattern-specific parameters, reports remarkable performance gains. We also demonstrate the benefits of the GRPPI pattern interface from the usability and flexibility points of view.

In the recent years, the large volumes of stream data and the near real-time requirements of data streaming applications have exacerbated the need for new scalable algorithms and programming interfaces for distributed and shared-memory platforms. To contribute in this direction, this paper presents a new distributed MPI back end for GrPPI, a C++ high-level generic interface of data-intensive and stream processing parallel patterns. This back end, as a new execution policy, supports the distributed and hybrid (distributed and shared-memory) parallel execution of the Pipeline and Farm patterns, where the hybrid mode combines the MPI policy with a GrPPI shared-memory one. A detailed analysis of the GrPPI MPI execution policy reports considerable benefits from the programmability, flexibility and readability points of view. The experimental evaluation on a streaming application with different distributed and shared-memory scenarios reports considerable performance gains with respect to the sequential versions at the expense of negligible GrPPI overheads.

SummaryThe rapid progress of multi/many‐core architectures has caused data‐intensive parallel applications not yet fully optimized to deliver the best performance. In the advent of concurrent programming, frameworks offering structured patterns have alleviated developers' burden adapting such applications to multithreaded architectures. While some of these patterns are implemented using synchronization primitives, others avoid them by means of lock‐free data mechanisms. However, lock‐free programming is not straightforward, ensuring an appropriate use of their interfaces can be challenging, since different memory models plus instruction reordering at compiler/processor levels can interfere in the occurrence of data races. The benefits of race detectors are formidable in this sense; however, they may emit false positives if are unaware of the underlying lock‐free structure semantics. To mitigate this issue, this paper extends ThreadSanitizer, a race detection tool, with the semantics of 2 lock‐free data structures: the single‐producer/single‐consumer and the multiple‐producer/multiple‐consumer queues. With it, we are able to drop false positives and detect potential semantic violations. The experimental evaluation, using different queue implementations on a set of μ benchmarks and real applications, demonstrates that it is possible to reduce, on average, 60% the number of data race warnings and detect wrong uses of these structures.

SummaryCurrent parallel programming frameworks aid developers to a great extent in implementing applications that exploit parallel hardware resources. Nevertheless, developers require additional expertise to properly use and tune them to operate efficiently on specific parallel platforms. On the other hand, porting applications between different parallel programming models and platforms is not straightforward and demands considerable efforts and specific knowledge. Apart from that, the lack of high‐level parallel pattern abstractions, in those frameworks, further increases the complexity in developing parallel applications. To pave the way in this direction, this paper proposes GRPPI, a generic and reusable parallel pattern interface for both stream processing and data‐intensive C++ applications. GRPPI accommodates a layer between developers and existing parallel programming frameworks targeting multi‐core processors, such as C++ threads, OpenMP and Intel TBB, and accelerators, as CUDA Thrust. Furthermore, thanks to its high‐level C++ application programming interface and pattern composability features, GRPPI allows users to easily expose parallelism via standalone patterns or patterns compositions matching in sequential applications. We evaluate this interface using an image processing use case and demonstrate its benefits from the usability, flexibility, and performance points of view. Furthermore, we analyze the impact of using stream and data pattern compositions on CPUs, GPUs and heterogeneous configurations.

Heterogeneous parallel platforms, comprising multiple processing units and architectures, have become a cornerstone in improving the overall performance and energy efficiency of scientific and engineering applications. Nevertheless, taking full advantage of their resources comes along with a variety of difficulties: developers require technical expertise in using different parallel programming frameworks and previous knowledge about the algorithms used underneath by the application. To alleviate this burden, we present an adaptive offline implementation selector that allows users to better exploit resources provided by heterogeneous platforms. Specifically, this framework selects, at compile time, the tuple device-implementation that delivers the best performance on a given platform. The user interface of the framework leverages two C++ language features: attributes and concepts. To evaluate the benefits of this framework, we analyse the global performance and convergence of the selector using two different use cases. The experimental results demonstrate that the proposed framework allows users enhancing performance while minimizing efforts to tune applications targeted to heterogeneous platforms. Furthermore, we also demonstrate that our framework delivers comparable performance figures with respect to other approaches.

Over the last years, heterogeneous architectures have become a de facto approach for improving the performance of numerous scientific and industrial applications. However, developing for these architectures is not straightforward: each processor demands its specific programming paradigm and, often, certain applications are only well-suited to run on a particular processing unit. Therefore, a major challenge arises when programming for these platforms: to select the most suitable device and routine implementation to solve a given problem. To deal with this issue, this paper proposes a novel probabilistic-based selector that uses the problem size to automatically choose the most appropriate version of a same kernel. In order to analyze this approach, we have developed this selector within the OmpSs programming framework and evaluated its accuracy and performance gains when executing different implementations of the general matrix-matrix multiplication. Finally, we also demonstrate how this solution delivers a comparable performance with respect to a runtime approach from the state-of-the-art.

The rapid progress of multi-/many-core architectures has caused data-intensive parallel applications not yet be fully suited for getting the maximum performance. The advent of parallel programming frameworks offering structured patterns has alleviated developers' burden adapting such applications to parallel platforms. For example, the use of synchronization mechanisms in multithreaded applications is essential on shared-cache multi-core architectures. However, ensuring an appropriate use of their interfaces can be challenging, since different memory models plus instruction reordering at compiler/processor levels may influence the occurrence of data races. The benefits of race detectors are formidable in this sense, nevertheless if lock-free data structures with no high-level atomics are used, they may emit false positives. In this paper, we extend the ThreadSanitizer race detection tool in order to support semantics of the general Single-Producer/Single-Consumer (SPSC) lock-free parallel queue and to detect benign data races where it was correctly used. To perform our analysis, we leverage the FastFlow SPSC bounded lock-free queue implementation to test our extensions over a set of μ-benchmarks and real applications on a dual-socket Intel Xeon CPU E5-2695 platform. We demonstrate that this approach can reduce, on average, 30% the number of data race warning messages.

One of the most common techniques to evaluate the performance of a computer I/O subsystem performance has been found on detailed simulation models including specific features of storage devices like disk geometry, zone splitting, caching, read-ahead buffers and request reordering. However, as soon as a new technological innovation is added, those models need to be reworked to include new devices making difficult to have general models up to date. Another alternative is modeling a storage device as a black-box probabilistic model, where the storage device itself, its interface and the interconnection mechanisms are modeled as a single stochastic process, defining the service time as a random variable with an unknown distribution. This approach allows generating disk service times needing less computational power by means of a variate generator included in a simulator. This approach allows to reach a greater scalability in the I/O subsystems performance evaluation by means of simulation. In this paper, we present a method for building a variate generator from service time experimental data. In order to build the variate generator, both real workloads and synthetic workloads may be used. The workload is used to feed the evaluated disk to obtain service time measurements. From experimental data we build a variate generator that fits the disk service times distribution. We also present a use case of our method, where we have obtained a relative error ranging from 0.45% to 1%.

In this paper we present a tool to perform analysis of High Performance Applications, which make a great amount of I/O operation, on large storage networks. In order to perform those analyses we have developed SIMCAN, a simulation tool to analyze High-Performance I/O Architectures. Storage subsystem performance is one of the major concerns that arise on large storage networks. Major requirements for storage networks are scalability and performance. In those kinds of networks, defining an architecture that satisfies those requirements is a very difficult task. With SIMCAN, custom environments can be configured and deployed on a flexible and easy way. In fact, the most interesting features of this simulation tool are its flexibility and scalability, so the simulation of distributed storage environments can be performed with the required detail level. Thus, in order to evaluate the benefits and the accuracy of the proposed tool, we have tested it with a typical high performance application, and compared the results of the simulated architecture with the real one.

In this paper we introduce M-PLAT, an intelligent tutoring system for helping students to learn the basics of programming languages. In fact, the M-PLAT system represents a full collection of intelligent tutoring systems, and due to its modular and hierarchical architecture it can be upgraded to deal with a new programming language that is not yet included in the system. Thus, this tutoring system is not limited to a unique programming language, making M-PLAT a very scalable system. The best important feature of our system is that M-PLAT dynamically adapts itself to the learning style of each student, optimizing the learning time to each student.

Data management is one of the most important problems in grid environments. Most of the efforts in data management in grids have been focused on data replication. Data replication is a practical and effective method to achieve efficient data access in grids. However all data replication schemes lack in providing a grid file system. One important challenge facing grid computing is the design of a grid file system. The Global Grid Forum defines a Grid File System as a human-readable resource namespace for management of heterogeneous distributed data resources, that can span across multiple autonomous administrative domains. This paper describes a new Grid File System according to the Global Grid Forum recommendations that integrates heterogeneous data storage resources in grids using standard grid technologies: GridFTP and the Resource Namespace Services, both defined by the Global Grid Forum. To obtain high performance, we apply the parallel I /O techniques used in traditional parallel file systems.

This paper 1 proposes a new disk scheduling algorithm for a storage virtualization schema, decoupling virtual disks and physical disks. It allows the system to virtualize not only the storage capacity, but also the storage bandwidth, following QoS directives. That virtualization can be applied to the applications bandwidth and access time requirements, allowing that each virtual disk could be used for real-time or best-effort applications. The scheduler proposed maintains the QoS of real time requests by rejecting those which deadline will fail. All those efforts are oriented towards the consecution of a network In-Band virtualization schema that not only controls the storage bandwidth, but it will also virtualize a centralized cache in order to obtain a better performance of the whole system. Keywords : Distributed Architectures; Multimedia Systems; Quality of Service; Scheduling and resource management; Virtualization. 1 Introduction There is a permanent interest on optimizing the I/O performance. The best tool for achieving this objective has been optimizing the scheduling politics of I/O devices, The performance of these techniques depends on which kind of tasks will be performed. However, the requirements and the platforms for real time tasks (as multimedia tasks) and general purpose tasks seemed to be so different [6] that people developed specialized systems. That is because disk scheduling algorithms for general purpose systems tried to reduce the access time, while real time systems tended to satisfy the real-time constraints, normally for cyclical streams. With the multimedia applications increasing, some authors [10] have proposed the design of a new kind of system, named integrated, that includes

Increasing the capacity of Web servers is a common need as the number of clients is growing up. Several distributed solutions to this problem exist: cluster based Web systems, virtual Web clusters or distributed Web systems. All these solutions work under the premise that the contents are fully replicated in every node of the cluster In this paper(1) we give a solution which does not require fully replication and at the same time avoids the overheads of cluster based Web systems eliminating the need that every requests reaches to a Web switch.

Mobile devices are mainly used for communication, entertainment, and as electronic assistants. However, their increasing computational, storage, communicational and multimedia capabilities make them suitable for previously unexpected scenarios such as Ambient Intelligence (AmI). Thus, mobile devices may be used as intermediaries between us and the smart objects (everyday objects augmented with computational services) in our surroundings. This paper describes the design and implementation of a middleware to transform mobile devices into universal remote controllers of smart objects.

Functional requirements for information systems can be modeled through use cases. Furthermore, use case models have been successfully used in broader contexts than software engineering, as systems engineering. Even if small systems may be modeled as a set of use cases, when large systems requirements are modeled with a plain use case model several difficulties arise. Traditionally, the behavior of use cases has been modeled through textual specifications. In this paper we present an alternate approach based on interaction modeling. The behavior modeling has two variants (one for UML 1.x and one for UML 2.0). We also integrate our behavior modeling with standard use case relationships.

In order to achieve high performance data access a typical technique used in the past was application data access pattern. In this paper we formulate a similar approach for Grids through the usage of I/O phases. Phases allow to de fine different DataGrids for different usages, but in order to adapt this to the huge and heterogeneous Grid infrastructure we need some way to select the storage resources. This is accomplished through the usage of grouping techniques based in locality and performance using three metrics distance, server I/O performance and network performance. Those metrics lead to the definition of three entities, I/O community, intragrid and intergrid. Those entities combined define several DataGrids that are assigned to different application I/O phases. An evaluation of those ideas is presented through GridExpand, a data access middleware for Grids. (1)