OpenMP Threads Research Articles

Efficient parallel CFD-DEM simulations using OpenMP

The paper describes parallelization strategies for the Discrete Element Method (DEM) used for simulating dense particulate systems coupled to Computational Fluid Dynamics (CFD). While the field equations of CFD are best parallelized by spatial domain decomposition techniques, the N-body particulate phase is best parallelized over the number of particles. When the two are coupled together, both modes are needed for efficient parallelization. It is shown that under these requirements, OpenMP thread based parallelization has advantages over MPI processes. Two representative examples, fairly typical of dense fluid–particulate systems are investigated, including the validation of the DEM-CFD and thermal-DEM implementation with experiments. Fluidized bed calculations are performed on beds with uniform particle loading, parallelized with MPI and OpenMP. It is shown that as the number of processing cores and the number of particles increase, the communication overhead of building ghost particle lists at processor boundaries dominates time to solution, and OpenMP which does not require this step is about twice as fast as MPI. In rotary kiln heat transfer calculations, which are characterized by spatially non-uniform particle distributions, the low overhead of switching the parallelization mode in OpenMP eliminates the load imbalances, but introduces increased overheads in fetching non-local data. In spite of this, it is shown that OpenMP is between 50–90% faster than MPI.

A Hybrid MPI–OpenMP Parallel Algorithm and Performance Analysis for an Ensemble Square Root Filter Designed for Multiscale Observations

Abstract A hybrid parallel scheme for the ensemble square root filter (EnSRF) suitable for parallel assimilation of multiscale observations, including those from dense observational networks such as those of radar, is developed based on the domain decomposition strategy. The scheme handles internode communication through a message passing interface (MPI) and the communication within shared-memory nodes via Open Multiprocessing (OpenMP) threads. It also supports pure MPI and pure OpenMP modes. The parallel framework can accommodate high-volume remote-sensed radar (or satellite) observations as well as conventional observations that usually have larger covariance localization radii. The performance of the parallel algorithm has been tested with simulated and real radar data. The parallel program shows good scalability in pure MPI and hybrid MPI–OpenMP modes, while pure OpenMP runs exhibit limited scalability on a symmetric shared-memory system. It is found that in MPI mode, better parallel performance is achieved with domain decomposition configurations in which the leading dimension of the state variable arrays is larger, because this configuration allows for more efficient memory access. Given a fixed amount of computing resources, the hybrid parallel mode is preferred to pure MPI mode on supercomputers with nodes containing shared-memory cores. The overall performance is also affected by factors such as the cache size, memory bandwidth, and the networking topology. Tests with a real data case with a large number of radars confirm that the parallel data assimilation can be done on a multicore supercomputer with a significant speedup compared to the serial data assimilation algorithm.

Hybrid MPI + OpenMP Parallelization of Scramjet Simulation with Hypergraph Partitioning

As one of the most significant methods to study hypersonic flight vehicle, the numerical simulation of supersonic combustion ramjet has drawn an ever increasing attention at present. Nevertheless, the traditional serial simulation cannot satisfy the practical needs because of high calculation precision, avaricious memory overhead and overlong computation time. In this paper, we study on a general algorithm for scramjet simulation, and bring about parallelization by using a hypergraph partitioning algorithm and a two level hybrid parallel model. The whole computing domain is decomposed into several sub-domains based on hypergraph partitioning, and each sub-domain is assigned to a MPI process. A single step of computation operates in the inter loop level, where a compiler directive is used to split MPI process into several OpenMP threads. Finally, speedup and parallel efficiency of our hybrid program testing on a China-made supercomputer with 4 to 256 cores is compared with pure MPI program. And, the hybrid program exhibits better parallel performance than the pure MPI program in the main, roughly as expected. The result indicates that our hybrid parallel strategy is effective and practical in scramjet simulation.

Communication-overlap techniques for improved strong scaling of gyrokinetic Eulerian code beyond 100k cores on the K-computer

Plasma turbulence research based on five-dimensional (5D) gyrokinetic simulations is one of the most critical and demanding issues in fusion science. To pioneer new physics regimes both in problem sizes and in timescales, an improvement of strong scaling is essential. Overlap of computations and communications using non-blocking MPI communication schemes is a promising approach to improving strong scaling, but it often fails on practical applications with conventional MPI libraries. In this work, this classical issue is resolved by developing communication-overlap techniques with additional MPI support for non-blocking communication routines and with heterogeneous OpenMP threads, which work even on conventional MPI libraries and network hardware. These techniques dramatically improved the parallel efficiency of a gyrokinetic toroidal 5D Eulerian code GT5D on the K-computer, which has a dedicated network, and on the Helios system which has a commodity network. On the K-computer, excellent strong scaling was achieved beyond 100k cores whilst keeping a sustained performance of [Formula: see text]10% ([Formula: see text]307 TFlops using 196,608 cores), and simulations for next-generation large-scale fusion experiments are significantly accelerated. This performance is 16[Formula: see text] sped up compared with the maximum performance reported at the 2011 International Conference for High Performance Computing, Networking, Storage and Analysis ([Formula: see text]19 TFlops using 16,384 cores of the BX900 cluster) (Idomura, 2011).

High accuracy and interval arithmetic on multicore processors

In this paper we describe the integration and use of a high-accuracy and interval arithmetic library (C-XSC library) on multicore processors using OpenMP and POSIX Threads for the communication between processes. With this integration we have a parallel environment supporting high accuracy and verified computing. The purpose of this work is to provide an environment in which scientific computing problems can be solved with speed, accuracy and reliability, where the result verification may be carried out automatically by the computer. To validate the environment developed in this work, some tests were done and their results will be discussed in this paper.

All-pairs computations on many-core graphics processors

Developing high-performance applications on emerging multi- and many-core architectures requires efficient mapping techniques and architecture-specific tuning methodologies to realize performance closer to their peak compute capability and memory bandwidth. In this paper, we develop architecture-aware methods to accelerate all-pairs computations on many-core graphics processors. Pairwise computations occur frequently in numerous application areas in scientific computing. While they appear easy to parallelize due to the independence of computing each pairwise interaction from all others, development of techniques to address multi-layered memory hierarchies, mapping within the restrictions imposed by the small and low-latency on-chip memories, striking the right balanced between concurrency, reuse and memory traffic etc., are crucial to obtain high-performance. We present a hierarchical decomposition scheme for GPUs based on decomposition of the output matrix and input data. We demonstrate that a careful tuning of the involved set of decomposition parameters is essential to achieve high efficiency on the GPUs. We also compare the performance of our strategies with an implementation on the STI Cell processor as well as multi-core CPU parallelizations using OpenMP and Intel Threading Building Blocks.

Spiking neuronal network simulation technology for contemporary supercomputers

Event Abstract Back to Event Spiking neuronal network simulation technology for contemporary supercomputers Moritz Helias1*, Susanne Kunkel2, Jochen Eppler3, Gen Masumoto4, Jun Igarashi5, Shin Ishii6, Tomoki Fukai5, Abigail Morrison2 and Markus Diesmann1 1 Inst of Neuroscience and Medicine (INM-6) Computational and Systems Neuroscience, Research Center Juelich, Germany 2 Functional Neural Circuits Group Albert-Ludwig University of Freiburg, Germany 3 Inst of Neuroscience and Medicine (INM-6), Computational and Systems Neuroscience, Research Center Juelich, Germany 4 High-Performance Computing Team, RIKEN, Computational Science Research Program Kobe, Japan 5 Laboratory for Neural Circuit Theory, RIKEN Brain Science Institute, Wako, Japan 6 Integrated Systems Biology, Laboratory Department of Systems Science, Graduate School of Informatics, Kyoto University, Japan Functional neuronal networks, like the visual cortex of primates, comprise on the order of 100 million neurons, consisting of areas that exceed 10 million neurons and 100 billion synapses. The memory demands of such simulations are only met by distributed simulation software and supercomputers, like the Jugene BG/P supercomputer in Juelich and the K computer in Kobe. Though connectivity between brain areas is sparse, there are fewer constraints within areas. A general simulation tool needs to be able to simulate networks of 10 million neurons with arbitrary connectivity, often assumed to be random. This presents the worst case scenario: Firstly, there is no redundancy that allows to compress the representation of synaptic connectivity. Secondly, communication between the compute nodes is potentially all-to-all. Here we quantitatively demonstrate the recent advances of neural simulation technology [2] on the example of the simulator NEST [1], which have lead to a readily usable tool for the neuroscientist. As the memory rather than run time limits the maximal size of a neuronal network, we explain the systematic improvements of the distributed data structures adapted to the sparse and random connectivity. High performance and good scaling of network setup and simulation are achieved with a hybrid code combining OpenMP threads and MPI, exploiting the multi-core architectures of K and Jugene. We parameterize and employ a model of memory consumption to estimate the machine size needed for a given neuroscientific question; a crucial tool not only to plan simulations, but also for computation time grant applications. Simulations of networks exceeding 10 million neurons on K and Jugene are shown to determine the limits of the current technology and computer architectures. Partially supported by the Helmholtz Alliance on Systems Biology, the Next-Generation Supercomputer Project of MEXT, EU Grant 269921 (BrainScaleS), the VSR computation time grant JINB33 on the JUGENE supercomputer, and by early access to the K computer at the RIKEN Advanced Institute for Computational Science. [1] Gewaltig M-O and Diesmann M (2007) NEST. Scholarpedia, 2(4):1430. [2] Kunkel S, Potjans TC, Eppler JM, Plesser HE, Morrison A and Diesmann M (2012) Front. Neuroinform. 5:35. doi: 10.3389/fninf.2011.00035 Keywords: Large scale modeling Conference: 5th INCF Congress of Neuroinformatics, Munich, Germany, 10 Sep - 12 Sep, 2012. Presentation Type: Poster Topic: Neuroinformatics Citation: Helias M, Kunkel S, Eppler J, Masumoto G, Igarashi J, Ishii S, Fukai T, Morrison A and Diesmann M (2013). Spiking neuronal network simulation technology for contemporary supercomputers. Front. Neuroinform. Conference Abstract: 5th INCF Congress of Neuroinformatics. doi: 10.3389/conf.fninf.2013.08.00012 Copyright: The abstracts in this collection have not been subject to any Frontiers peer review or checks, and are not endorsed by Frontiers. They are made available through the Frontiers publishing platform as a service to conference organizers and presenters. The copyright in the individual abstracts is owned by the author of each abstract or his/her employer unless otherwise stated. Each abstract, as well as the collection of abstracts, are published under a Creative Commons CC-BY 4.0 (attribution) licence (https://creativecommons.org/licenses/by/4.0/) and may thus be reproduced, translated, adapted and be the subject of derivative works provided the authors and Frontiers are attributed. For Frontiers’ terms and conditions please see https://www.frontiersin.org/legal/terms-and-conditions. Received: 21 Mar 2013; Published Online: 27 Nov 2013. * Correspondence: Dr. Moritz Helias, Inst of Neuroscience and Medicine (INM-6) Computational and Systems Neuroscience, Research Center Juelich, Jülich, Germany, m.helias@fz-juelich.de Login Required This action requires you to be registered with Frontiers and logged in. To register or login click here. Abstract Info Abstract The Authors in Frontiers Moritz Helias Susanne Kunkel Jochen Eppler Gen Masumoto Jun Igarashi Shin Ishii Tomoki Fukai Abigail Morrison Markus Diesmann Google Moritz Helias Susanne Kunkel Jochen Eppler Gen Masumoto Jun Igarashi Shin Ishii Tomoki Fukai Abigail Morrison Markus Diesmann Google Scholar Moritz Helias Susanne Kunkel Jochen Eppler Gen Masumoto Jun Igarashi Shin Ishii Tomoki Fukai Abigail Morrison Markus Diesmann PubMed Moritz Helias Susanne Kunkel Jochen Eppler Gen Masumoto Jun Igarashi Shin Ishii Tomoki Fukai Abigail Morrison Markus Diesmann Related Article in Frontiers Google Scholar PubMed Abstract Close Back to top Javascript is disabled. Please enable Javascript in your browser settings in order to see all the content on this page.

Analysis and Research on Optimization of Multi-Threading Load Balance under Multi-Core Architecture Based on OpenMP

This paper presents OpenMP thread scheduling strategies by studying OpenMP load balance. In addition to analyze the defects of OpenMP load balance, an optimization program is proposed, and the ideas and methods of this program are described in this paper.

A hybrid MPI–OpenMP scheme for scalable parallel pseudospectral computations for fluid turbulence

A hybrid scheme that utilizes MPI for distributed memory parallelism and OpenMP for shared memory parallelism is presented. The work is motivated by the desire to achieve exceptionally high Reynolds numbers in pseudospectral computations of fluid turbulence on emerging petascale, high core-count, massively parallel processing systems. The hybrid implementation derives from and augments a well-tested scalable MPI-parallelized pseudospectral code. The hybrid paradigm leads to a new picture for the domain decomposition of the pseudospectral grids, which is helpful in understanding, among other things, the 3D transpose of the global data that is necessary for the parallel fast Fourier transforms that are the central component of the numerical discretizations. Details of the hybrid implementation are provided, and performance tests illustrate the utility of the method. It is shown that the hybrid scheme achieves good scalability up to ∼20,000 compute cores with a maximum efficiency of 89%, and a mean of 79%. Data are presented that help guide the choice of the optimal number of MPI tasks and OpenMP threads in order to maximize code performance on two different platforms.

Yada: Straightforward parallel programming

Now that multicore chips are common, providing an approach to parallel programming that is usable by regular programmers has become even more important. This cloud has one silver lining: providing useful speedup on a program is useful in and of itself, even if the resulting performance is lower than the best possible parallel performance on the same program. To help achieve this goal, Yada is an explicitly parallel programming language with sequential semantics. Explicitly parallel, because we believe that programmers need to identify how and where to exploit potential parallelism, but sequential semantics so that programmers can understand and debug their parallel programs in the way that they already know, i.e. as if they were sequential. The key new idea in Yada is the provision of a set of types that support parallel operations while still preserving sequential semantics. Beyond the natural read-sharing found in most previous sequential-like languages, Yada supports three other kinds of sharing. Writeonce locations support a single write and multiple reads, and two kinds of sharing for locations updated with an associative operator generalise the reduction and parallel-prefix operations found in many data-parallel languages. We expect to support other kinds of sharing in the future. We have evaluated our Yada prototype on eight algorithms and four applications, and found that programs require only a few changes to get useful speedups ranging from 2.2 to 6.3 on an 8-core machine. Yada performance is mostly comparable to parallel implementations of the same programs using OpenMP or explicit threads.

Performance‐based parallel loop self‐scheduling using hybrid OpenMP and MPI programming on multicore SMP clusters

AbstractParallel loop self‐scheduling on parallel and distributed systems has been a critical problem and it is becoming more difficult to deal with in the emerging heterogeneous cluster computing environments. In the past, some self‐scheduling schemes have been proposed as applicable to heterogeneous cluster computing environments. In recent years, multicore computers have been widely included in cluster systems. However, previous researches into parallel loop self‐scheduling did not consider certain aspects of multicore computers; for example, it is more appropriate for shared‐memory multiprocessors to adopt Open Multi‐Processing (OpenMP) for parallel programming. In this paper, we propose a performance‐based approach using hybrid OpenMP and MPI parallel programming, which partition loop iterations according to the performance weighting of multicore nodes in a cluster. Because iterations assigned to one MPI process are processed in parallel by OpenMP threads run by the processor cores in the same computational node, the number of loop iterations allocated to one computational node at each scheduling step depends on the number of processor cores in that node. Experimental results show that the proposed approach performs better than previous schemes. Copyright © 2010 John Wiley & Sons, Ltd.

Performance Evaluation of Mixed-Mode OpenMP/MPI Implementations

With the current prevalence of multi-core processors in HPC architectures mixed-mode programming, using both MPI and OpenMP in the same application, is seen as an important technique for achieving high levels of scalability. As there are few standard benchmarks written in this paradigm, it is difficult to assess the likely performance of such programs. To help address this, we examine the performance of mixed-mode OpenMP/MPI on a number of popular HPC architectures, using a synthetic benchmark suite and two large-scale applications. We find performance characteristics which differ significantly between implementations, and which highlight possible areas for improvement, especially when multiple OpenMP threads communicate simultaneously via MPI.

Optimized Convex Hull With Mixed (MPI and OpenMP) Programming On HPC

As a programmer, one is aspired to solve ever larger, more memory intensive problems, or simply solve problems with greater speed than possible on a sequential computer. A programmer can turn to parallel programming and parallel computers to satisfy these needs. Parallel programming methods on parallel computers gives access to greater memory and Central Processing Unit (CPU) resources which is not available on sequential computers. This paper discusses the benefits of developing 2D and 3D convex hull on mixed mode MPI, OpenMP applications on both single and clustered SMPs. In this experimentation for purpose of optimization of 3D convex hull we merged both MPI and OpenMP library which gives another mixed mode programming method to get optimized results. The job is divided into sub-jobs and are submitted to cluster of SMP nodes using MPI and these subjobs are computed in parallel using OpenMP threads in SMP nodes. Experiments on sequential, MPI, OpenMP and Hybrid programming models show that Hybrid programming model substantially outperforms others.

The VOLSCAT package for electron and positron scattering of molecular targets: A new high throughput approach to cross-section and resonances computation

VOLSCAT is a computer program which implements the Single Center Expansion (SCE) method to solve the scattering equation for the elastic collision of electrons/positrons off molecular targets. The scattering potential needed is calculated by on-the-fly calls to the external SCELib library for molecular properties, recently ported to GPU computing environment and ClearSpeed platforms, and made available by means of an Application Program Interface (SCELib-API) which is also provided with the VOLSCAT package in a beta version. The result is a high throughput approach to the solution of the complex e − / e + -molecule scattering problem, with allows for intensive calculations both for the number of systems which can be studied and for their size. Accurate partial and total elastic cross sections are produced in output together with the associated eigenphase sums. Indirect scattering processes arising from the formation of temporary negative ions can also be analyzed through the computation of the resonances' parameters. Program summary Program title: VOLSCAT V1.0 Catalogue identifier: AEEW_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEEW_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 4 618 353 No. of bytes in distributed program, including test data, etc.: 120 307 536 Distribution format: tar.gz Programming language: Fortran90 Computer: All SMP platforms based on AIX, Linux and SUNOS operating systems over SPARC, POWER, Intel Itanium2, X86, em64t and Opteron processors Operating system: SUNOS, IBM AIX, Linux RedHat (Enterprise), Linux SuSE (SLES) Has the code been vectorized or parallelized?: Yes. The parallel version in the present release of the code is limited to the OpenMP calculation of the exchange potential V FEGE or V SCE . The number of OpenMP threads can then be set in the input script. RAM: For a typical (isolated) biomolecule (e.g. Cytosine or Ribose) a converged calculation would require from 320 MB up to 2.5 GB. Word size: 64 bits Classification: 16.5 External routines: LAPACK (dsyev, dgetri, dgetrf) ( http://www.netlib.org/lapack/) Nature of problem: In this set of codes an efficient procedure is implemented to calculate partial cross section for the scattering between an electron/positron and a molecular target as a function of the collision energies. Solution method: The scattering equations are derived in the framework of the Single Center Expansion (SCE) procedure which allows the reduction of the original three-dimensional problem to a radial (one-dimensional) equation through the expansion of the scattering potential and the system wavefunction in a set of symmetry-adapted (real) spherical harmonics. The local part of the electrostatic interaction between the charged projectile (electron/positron) and the molecular target is provided in input by the SCELib library, which also provides the correlation and polarization corrections for the short-range and long-range part, respectively, of the interaction. A proper Application Programming Interface (API) is used by VOLSCAT to load the energy-independent part of the potential while the non-local exchange contribution is approximated by a local form and calculated on the fly in the VOLSCAT run for each desired collision energy. The resulting SCE one-dimensional homogeneous scattering equation is rewritten in an integral form by means of the standard Green's function technique resulting in a set of Volterra coupled equations which are solved to give the phase shifts and cross sections for any desired impact energy in terms of the partial components defined by the irreducible representations of the symmetry point group to which the target molecule belongs. The total cross section can then be straightforwardly calculated by summing over all the partial cross sections produced in the output. By the Breit–Wigner analysis of the eigenphase sum produced as a function of the energy one can also get information on the location of possible resonance states arising in the collision process. Restrictions: Depending on the molecular system under study and on the operating conditions the program may or may not fit into available RAM memory. Additional comments: A beta version of SCELib-API is included in the distribution package. Running time: The execution time strongly depends on the molecular target description and on the hardware/OS chosen, it is directly proportional to the ( r , θ , φ ) grid size and to the number of angular basis functions used.

Nested parallelism for multi-core HPC systems using Java

Since its introduction in 1993, the Message Passing Interface (MPI) has become a de facto standard for writing High Performance Computing (HPC) applications on clusters and Massively Parallel Processors (MPPs). The recent emergence of multi-core processor systems presents a new challenge for established parallel programming paradigms, including those based on MPI. This paper presents a new Java messaging system called MPJ Express. Using this system, we exploit multiple levels of parallelism–messaging and threading–to improve application performance on multi-core processors. We refer to our approach as nested parallelism. This MPI-like Java library can support nested parallelism by using Java or Java OpenMP (JOMP) threads within an MPJ Express process. Practicality of this approach is assessed by porting to Java a massively parallel structure formation code from Cosmology called Gadget-2. We introduce nested parallelism in the Java version of the simulation code and report good speed-ups. To the best of our knowledge it is the first time this kind of hybrid parallelism is demonstrated in a high performance Java application.

Using hybrid MPI and OpenMP programming to optimize communications in parallel loop self-scheduling schemes for multicore PC clusters

Recently, a series of parallel loop self-scheduling schemes have been proposed, especially for heterogeneous cluster systems. However, they employed the MPI programming model to construct the applications without considering whether the computing node is multicore architecture or not. As a result, every processor core has to communicate directly with the master node for requesting new tasks no matter the fact that the processor cores on the same node can communicate with each other through the underlying shared memory. To address the problem of higher communication overhead, in this paper we propose to adopt hybrid MPI and OpenMP programming model to design two-level parallel loop self-scheduling schemes. In the first level, each computing node runs an MPI process for inter-node communications. In the second level, each processor core runs an OpenMP thread to execute the iterations assigned for its resident node. Experimental results show that our method outperforms the previous works.

Performance of Quantum Chromodynamics (QCD) Simulations on the SGI Altix

We study performance and scaling of the Berlin Quantum Chromodynamics Program (BQCD) on the SGI Altix 4700 at Leibniz Supercomputing Centre (LRZ). We employ different communication methods (MPI, MPI with two OpenMP threads per process, as well as the shmem library) and run the MPI version on the two types of nodes of that machine. For comparison with other machines we made performance measurements on an IBM p690 cluster and a Cray XT4.

Source-Code-Correlated Cache Coherence Characterization of OpenMP Benchmarks

Cache coherence in shared-memory multiprocessor systems has been studied mostly from an architecture viewpoint, often by means of aggregating metrics. In many cases, aggregate events provide insufficient information for programmers to understand and optimize the coherence behavior of their applications. A better understanding would be given by source code correlations of not only aggregate events, but also finer granularity metrics directly linked to high-level source code constructs, such as source lines and data structures. In this paper, we explore a novel application-centric approach to studying coherence traffic. We develop a coherence analysis framework based on incremental coherence simulation of actual reference traces. We provide tool support to extract these reference traces and synchronization information from OpenMP threads at runtime using dynamic binary rewriting of the application executable. These traces are fed to ccSIM, our cache-coherence simulator. The novelty of ccSIM lies in its ability to relate low-level cache coherence metrics (such as coherence misses and their causative invalidations) to high-level source code constructs including source code locations and data structures. We explore the degree of freedom in interleaving data traces from different processors and assess simulation accuracy in comparison to metrics obtained from hardware performance counters. Our quantitative results show that: 1) Cache coherence traffic can be simulated with a considerable degree of accuracy for SPMD programs, as the invalidation traffic closely matches the corresponding hardware performance counters. 2) Detailed, high-level coherence statistics are very useful in detecting, isolating, and understanding coherence bottlenecks. We use ccSIM with several well-known benchmarks and find coherence optimization opportunities leading to significant reductions in coherence traffic and savings in wall-clock execution time

Parallel protein secondary structure prediction schemes using Pthread and OpenMP over hyper-threading technology

Protein secondary structure prediction has a fundamental influence on today's bioinformatics research. In this work, tertiary classifiers for the protein secondary structure prediction are implemented on Denoeux Belief Neural Network (DBNN) architecture. Hydrophobicity matrix, orthogonal matrix, BLOSUM62 matrix and PSSM matrix are experimented separately as the encoding schemes for DBNN. Hydrophobicity matrix, BLOSUM62 matrix and PSSM matrix are applied to DBNN architecture for the first time. The experimental results contribute to the design of new encoding schemes. Our accuracy of the tertiary classifier with PSSM encoding scheme reaches 72.01%, which is almost 10% better than the previous results obtained in 2003. Due to the time consuming task of training the neural networks, Pthread and OpenMP are employed to parallelize DBNN in the Hyper-Threading enabled Intel architecture. Speedup for 16 Pthreads is 4.9 and speedup for 16 OpenMP threads is 4 in the 4 processors shared memory architecture. Both speedup performance of OpenMP and Pthread is superior to that of other research. With the new parallel training algorithm, thousands of amino acids can be processed in reasonable amount of time. Our research also shows that Hyper-Threading technology for Intel architecture is efficient for parallel biological algorithms.

Performance Portability in the Physical Parameterizations of the Community Atmospheric Model

Community models for global climate research, such as the Community Atmospheric Model, must perform well on a variety of computing systems. Supporting diverse research interests, these computationally demanding models must be efficient for a range of problem sizes and processor counts. In this paper we describe the data structures and associated infrastructure developed for the physical parameterizations that allow the Community Atmospheric Model to be tuned for vector or non-vector systems, to provide load balancing while minimizing communication overhead, and to exploit the optimal mix of distributed Message Passing Interface (MPI) processes and shared OpenMP threads.