100,541 research outputs found
Redescription of Troticus ovalis (Fahringer) comb. nov., its first host record and a note on T. melamopterus Cameron (Hymenoptera: Braconidae: Agathidinae)
No full textDisophrys ovalis Fahringer, 1937 (Hymenoptera: Braconidae: Agathidinae) from Egypt is redescribed and transferred to the genus Troticus Brullé, 1846 (comb. nov.) with Disophrys aegyptiaca Fahringer, 1937, as its junior synonym (syn. nov.). For the first time a reliable host record for the genus and for T. ovalis is given. The holotype of Troticus melamopterus Cameron, 1903 has been examined by the first author and is transferred to the genus Cremnops Foerster, 1862 (C. melamopterus Cameron, 1903 comb. nov.)
Redescription of Troticus ovalis (Fahringer) comb. nov., its first host record and a note on T. melamopterus Cameron (Hymenoptera: Braconidae: Agathidinae)
No full textDisophrys ovalis Fahringer, 1937 (Hymenoptera: Braconidae: Agathidinae) from Egypt is redescribed and transferred to the genus Troticus Brullé, 1846 (comb. nov.) with Disophrys aegyptiaca Fahringer, 1937, as its junior synonym (syn. nov.). For the first time a reliable host record for the genus and for T. ovalis is given. The holotype of Troticus melamopterus Cameron, 1903 has been examined by the first author and is transferred to the genus Cremnops Foerster, 1862 (C. melamopterus Cameron, 1903 comb. nov.)
Spathius maderi FAHRINGER 1930
No full textSpathius maderi FAHRINGER 1930 M a t e r i a l e x a m i n e d: Mazandaran province: Savadkooh, 2, 1, August 2009. G e n e r a l d i s t r i b u t i o n: Palaearctic.Published as part of Sakenin, H., Naderian, H., Samin, N., Rastegar, J., Tabari, M., Papp, J. & I, Northern, 2012, On a collection of Braconidae (Hymenoptera) from northern Iran, pp. 1319-1330 in Linzer biologische Beiträge 44 (2) on page 1324, DOI: 10.5281/zenodo.533526
Automatic Data Layout Optimizations for GPUs
No full textMemory optimizations have became increasingly important in order to fully exploit the computational power of modern GPUs. The data arrangement has a big impact on the performance, and it is very hard for GPU programmers to identify a well-suited data layout. Classical data layout transformations include grouping together data fields that have similar access patterns, or transforming Array-of-Structures (AoS) to Structure-of-Arrays (SoA).
This paper presents an optimization infrastructure to automatically determine an improved data layout for OpenCL programs written in AoS layout. Our framework consists of two separate algorithms: The first one constructs a graph-based model, which is used to split the AoS input struct into several clusters of fields, based on hardware dependent parameters. The second algorithm selects a good per-cluster data layout (e.g., SoA, AoS or an intermediate layout) using a decision tree. Results show that the combination of both algorithms is able to deliver higher performance than the individual algorithms. The layouts proposed by our framework result in speedups of up to 2.22, 1.89 and 2.83 on an AMD FirePro S9000, NVIDIA GeForce GTX 480 and NVIDIA Tesla k20m, respectively, over different AoS sample programs, and up to 1.18 over a manually optimized program
A uniform approach for programming distributed heterogeneous computing systems
No full textLarge-scale compute clusters of heterogeneous nodes equipped with multi-core CPUs and GPUs are getting increasingly popular in the scientific community. However, such systems require a combination of different programming paradigms making application development very challenging. In this article we introduce libWater, a library-based extension of the OpenCL programming model that simplifies the development of heterogeneous distributed applications. libWater consists of a simple interface, which is a transparent abstraction of the underlying distributed architecture, offering advanced features such as inter-context and inter-node device synchronization. It provides a runtime system which tracks dependency information enforced by event synchronization to dynamically build a DAG of commands, on which we automatically apply two optimizations: collective communication pattern detection and device-host-device copy removal. We assess libWater's performance in three compute clusters available from the Vienna Scientific Cluster, the Barcelona Supercomputing Center and the University of Innsbruck, demonstrating improved performance and scaling with different test applications and configurations
Spectral turning bands for efficient Gaussian random fields generation on GPUs and accelerators
No full textA random field (RF) is a set of correlated random variables associated with different spatial locations. RF generation algorithms are of crucial importance for many scientific areas, such as astrophysics, geostatistics, computer graphics, and many others. Current approaches commonly make use of 3D fast Fourier transform (FFT), which does not scale well for RF bigger than the available memory; they are also limited to regular rectilinear meshes.
We introduce random field generation with the turning band method (RAFT), an RF generation algorithm based on the turning band method that is optimized for massively parallel hardware such as GPUs and accelerators. Our algorithm replaces the 3D FFT with a lower‐order, one‐dimensional FFT followed by a projection step and is further optimized with loop unrolling and blocking. RAFT can easily generate RF on non‐regular (non‐uniform) meshes and efficiently produce fields with mesh sizes bigger than the available device memory by using a streaming, out‐of‐core approach. Our algorithm generates RF with the correct statistical behavior and is tested on a variety of modern hardware, such as NVIDIA Tesla, AMD FirePro and Intel Phi. RAFT is faster than the traditional methods on regular meshes and has been successfully applied to two real case scenarios: planetary nebulae and cosmological simulations
Celerity: High-Level C++ for Accelerator Clusters
No full textIn the face of ever-slowing single-thread performance growth for CPUs, the scientific and engineering communities increasingly turn to accelerator parallelization to tackle growing application workloads. Existing means of targeting distributed memory accelerator clusters impose severe programmability barriers and maintenance burdens. The Celerity programming environment seeks to enable developers to scale C++ applications to accelerator clusters with relative ease, while leveraging and extending the SYCL domain-specific embedded language. By having users provide minimal information about how data is accessed within compute kernels, Celerity automatically distributes work and data. We introduce the Celerity C++ API as well as a prototype implementation, demonstrating that existing SYCL code can be brought to distributed memory clusters with only a small set of changes that follow established idioms. The Celerity prototype runtime implementation is shown to have comparable performance to more traditional approaches to distributed memory accelerator programming, such as MPI+OpenCL, with significantly lower implementation complexity
Automatic problem size sensitive task partitioning on heterogeneous parallel systems
No full textIn this paper we propose a novel approach which automatizes task partitioning in heterogeneous systems. Our framework is based on the Insieme Compiler and Runtime infrastructure. The compiler translates a single-device OpenCL program into a multi-device OpenCL program. The runtime system then performs dynamic task partitioning based on an offline-generated prediction model. In order to derive the prediction model, we use a machine learning approach that incorporates static program features as well as dynamic, input sensitive features. Our approach has been evaluated over a suite of 23 programs and achieves performance improvements compared to an execution of the benchmarks on a single CPU and a single GPU only
An automatic input-sensitive approach for heterogeneous task partitioning
No full textUnleashing the full potential of heterogeneous systems, consisting of multi-core CPUs and GPUs, is a challenging task due to the difference in processing capabilities, memory availability, and communication latencies of different computational resources.
In this paper we propose a novel approach that automatically optimizes task partitioning for different (input) problem sizes and different heterogeneous multi-core architectures. We use the Insieme source-to-source compiler to translate a single-device OpenCL program into a multi-device OpenCL program. The Insieme Runtime System then performs dynamic task partitioning based on an offline-generated prediction model. In order to derive the prediction model, we use a machine learning approach based on Artificial Neural Networks (ANN) that incorporates static program features as well as dynamic, input sensitive features. Principal component analysis have been used to further improve the task partitioning. Our approach has been evaluated over a suite of 23 programs and respectively achieves a performance improvement of 22% and 25% compared to an execution of the benchmarks on a single CPU and a single GPU which is equal to 87.5% of the optimal performance
- …
