Multi-core Machines Research Articles

GeoGraph

In many applications of graph processing, the input data is often generated from an underlying geometric point data set. However, existing high-performance graph processing frameworks assume that the input data is given as a graph. Therefore, to use these frameworks, the user must write or use external programs based on computational geometry algorithms to convert their point data set to a graph, which requires more programming effort and can also lead to performance degradation. In this paper, we present our ongoing work on the Geo- Graph framework for shared-memory multicore machines, which seamlessly supports routines for parallel geometric graph construction and parallel graph processing within the same environment. GeoGraph supports graph construction based on k-nearest neighbors, Delaunay triangulation, and b-skeleton graphs. It can then pass these generated graphs to over 25 graph algorithms. GeoGraph contains highperformance parallel primitives and algorithms implemented in C++, and includes a Python interface. We present four examples of using GeoGraph, and some experimental results showing good parallel speedups and improvements over the Higra library. We conclude with a vision of future directions for research in bridging graph and geometric data processing.

Toward a Lingua Franca for Deterministic Concurrent Systems

Many programming languages and programming frameworks focus on parallel and distributed computing. Several frameworks are based on actors, which provide a more disciplined model for concurrency than threads. The interactions between actors, however, if not constrained, admit nondeterminism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. We show that nondeterminism can be handled in a number of ways, surveying dataflow dialects, process networks, synchronous-reactive models, and discrete-event models. These existing approaches, however, tend to require centralized control, pose challenges to modular system design, or introduce a single point of failure. We describe “reactors,” a new coordination model that combines ideas from several of these approaches to enable determinism while preserving much of the style of actors. Reactors promote modularity and allow for distributed execution. By using a logical model of time that can be associated with physical time, reactors also provide control over timing. Reactors also expose parallelism that can be exploited on multicore machines and in distributed configurations without compromising determinacy.

PBBFMM3D: A parallel black-box algorithm for kernel matrix-vector multiplication

Kernel matrix-vector product is ubiquitous in many science and engineering applications. However, a naive method requires O(N2) operations, which becomes prohibitive for large-scale problems. To reduce the computation cost, we introduce a parallel method that provably requires O(N) operations and delivers an approximate result within a prescribed tolerance. The distinct feature of our method is that it requires only the ability to evaluate the kernel function, offering a black-box interface to users. Our parallel approach targets multi-core shared-memory machines and is implemented using OpenMP. Numerical results demonstrate up to 19× speedup on 32 cores. We also present a real-world application in geo-statistics, where our parallel method was used to deliver fast principle component analysis of covariance matrices.

RETRACTED ARTICLE: Teaching management of music academies based on multi-core processors and machine learning

Music colleges are a branch of our country’s colleges and universities, and campus informatization is a new development trend under the rapid development of network information technology today. Informatization is conducive to better campus management and administrative efficiency greatly improves. Compared with ordinary colleges and universities, the development of informatization construction in music and art colleges is relatively backward. Therefore, it is very necessary to customize a complete information campus construction plan specifically for music schools. This article will study the related issues of how to carry out information management in music academies based on the problems and practice of teaching management in music schools. Focus on the embedded multi-core processor storage system and propose new storage architecture based on the original. And through machine learning methods, artificial intelligence software that can recognize music styles is trained. Traditional recognition is relatively dependent on the listener’s experience. Cannot reach a complete standard, the accuracy rate is also unstable. So we use embedded application software under the premise of low power consumption. To achieve a stable and efficient way of listening to replace the traditional manual judgment.

Experimenting with big data computing for scaling data quality-aware query processing

Combining query processing techniques with data quality management approaches enables enforcement of quality constraints, such as timeliness, accuracy and completeness, as part of ad-hoc query specification and execution, improving the quality of query results. Despite the emergence of novel data quality processing tools, there is a dearth of studies assessing performance and scalability in the execution of data quality assessment tasks during query processing. This paper reports on an empirical study aiming to investigate the extent to which a big data computing framework (Spark) can offer significant gains in performance and scalability when executing data quality querying tasks over a range of computational platforms including a single commodity multi-core machine and a cluster-based platform for a wide range of workloads. Our results show that substantial performance and scalability gains can be obtained by using optimized data science libraries combined with the parallel and distributed capabilities of big data computing. We also provide guidelines on choosing the appropriate computational infrastructure for executing DQ-aware queries.

CHICKN: extraction of peptide chromatographic elution profiles from large scale mass spectrometry data by means of Wasserstein compressive hierarchical cluster analysis

BackgroundThe clustering of data produced by liquid chromatography coupled to mass spectrometry analyses (LC-MS data) has recently gained interest to extract meaningful chemical or biological patterns. However, recent instrumental pipelines deliver data which size, dimensionality and expected number of clusters are too large to be processed by classical machine learning algorithms, so that most of the state-of-the-art relies on single pass linkage-based algorithms.ResultsWe propose a clustering algorithm that solves the powerful but computationally demanding kernel k-means objective function in a scalable way. As a result, it can process LC-MS data in an acceptable time on a multicore machine. To do so, we combine three essential features: a compressive data representation, Nyström approximation and a hierarchical strategy. In addition, we propose new kernels based on optimal transport, which interprets as intuitive similarity measures between chromatographic elution profiles.ConclusionsOur method, referred to as CHICKN, is evaluated on proteomics data produced in our lab, as well as on benchmark data coming from the literature. From a computational viewpoint, it is particularly efficient on raw LC-MS data. From a data analysis viewpoint, it provides clusters which differ from those resulting from state-of-the-art methods, while achieving similar performances. This highlights the complementarity of differently principle algorithms to extract the best from complex LC-MS data.

A Systematic Literature Review of Lexical Analyzer Implementation Techniques in Compiler Design

The term “lexical” in lexical analysis process of the compilation is derived from the word “lexeme”, which is the basic conceptual unit of the linguistic morphological study. In computer science, lexical analysis, also referred to as lexing, scanning or tokenization, is the process of transforming the string of characters in source program to a stream of tokens, where the token is a string with a designated and identified meaning. It is the first phase of a two-step compilation processing model known as the analysis stage of compilation process used by compiler to understand the input source program. The objective is to convert character streams into words and recognize its token type. The generated stream of tokens is then used by the parser to determine the syntax of the source program. A program in compilation phase that performs a lexical analysis process is termed as lexical analyzer, lexer, scanner or tokenizer. Lexical analyzer is used in various computer science applications, such as word processing,information retrieval systems, pattern recognition systems and language-processing systems. However, the scope of our review study is related to language processing. Various tools are used for automatic generation of tokens and are more suitable for sequential execution of the process. Recent advances in multi-core architecture systems have led to the need to re-engineer the compilation process to integrate the multi-core architecture. By parallelization in the recognition of tokens in multiple cores, multi cores can be used optimally, thus reducing compilation time. To attain parallelism in tokenizationon multi-core machines, the lexical analyzer phase of compilation needs to be restructured to accommodate the multi-core architecture and by exploiting the language constructs which can run parallel and the concept of processor affinity. This paper provides a systematic analysis of literature to discuss emerging approaches and issues related to lexical analyzer implementation and the adoption of improved methodologies. This has been achieved by reviewing 30 published articles on the implementation of lexical analyzers. The results of this review indicate various techniques, latest developments, and current approaches for implementing auto generated scanners and hand-crafted scanners. Based on the findings, we draw on the efficacy of lexical analyzer implementation techniques from the results discussed in the selected review studies and the paper provides future research challenges and needs to explore the previously under-researched areas for scanner implementation processes.

Investigation of Orientation Estimation of Multiple IMUs

Inertial Measurement Units (IMUs) were first applied to aircraft navigation and large devices in the 1930s. At that time their application was restricted because of constraints such as size, cost, and power consumption. In recent years, however, Micro-electromechanical (MEMS) IMUs were introduced with very favorable features such as low cost, compactness, and low processing power. One of the disadvantages of these low cost IMU sensors is that the accuracy is lower compared to high-end sensors. However, past experimental results have shown that redundant Magnetic and Inertial Measurement Units (MIMUs) improve navigation performance such as for unmanned air vehicles. Even though past simulation and experimental results demonstrated that redundant sensors improve the navigation performance, however, none of the current research work offers information as to how many sensors are required in order to meet a certain accuracy. This paper evaluates different numbers of sensor configurations of an MIMU sensor array using a simulation environment. Differently rotated MIMU sensors are incrementally added and the Madgwick filter is used to estimate the Euler angles of foot mounted MIMU data. The evaluation measure used is the root mean square error (RMSE) based on the Euler angles as compared to the ground truth. During the experiments it was noticed that the execution time with increasing number of sensors increases exponentially, and thus, the parallelization of the code was designed and implemented, and run on a multi-core machine. Thus, the speedup of the parallel implementation was evaluated. The findings using the parallel version with 16 sensors are that the execution time is less than twice the execution time of having only 1 sensor and 24 times less than using the sequential version with the added benefit of a 26% increase in accuracy.

PyCuRT: An Automated Data Curation Workflow for Radiotherapy Big Data Analysis using Pythons’ NyPipe

Personalized medicine in Radiotherapy (RT) aims to increase tumor control probability and decrease normal tissue toxicity. Recently, Radiomics is widely used to infer tumor/tissue characteristics and link outcome to applied dose and underlying biology. The building of robust models requires high amounts of data, which are often only available from multiple centers/sites. Missing standardization of data (inconsistent naming schemes, differences in acquisition parameters) makes manual curation necessary, which can be extremely time-consuming. Here, we propose a fully automated general framework that can sort all relevant RT data with minimal human intervention - pyCuRT. Our method builds upon NyPipe, a Python package used to create complex analysis workflows. Any DICOM directory containing different radiological data e.g., batch exported from PACS systems without specific structure requirements, can be used as input for pyCuRT. It checks the integrity of files and sorts them based on DICOM attributes. For RT data, using information from the RT Plan, pyCuRT links together the DICOM-RT objects, i.e., the RT planning CT, Structure Set (SS), and Dose Distribution (DD). Furthermore, the structure within the SS showing the highest overlap with the DD can be automatically identified, allowing the extraction of inconsistently named structures. The final output has a subject/session/scan structure. Parallelization is implemented to speed up computation on multi-core machines. Successful curation has been achieved in retrospectively collected data cohorts of 3 different cancer entities (brain n = 621, rectal n = 127, and pancreatic n = 13 for a total of ∼50000 scans), from several various institutions across Germany. In the rectal cohort, e.g., from more than 2000 present images, 774 CT scans with 224 unique series descriptions were identified. From them, pyCuRT extracted the RT planning CTs, and linked them to the corresponding RT-DD and RT-SS automatically. Furthermore, all structures with any combination of GTV or PTV in the name were correctly extracted from the SSs and saved as NIFTI (the 35 RT-SS not containing those structures were identified correctly). The total processing time was around 2 hours and a half, which corresponds to less than 3 seconds per scan. We propose a new, fully automated method to curate radiotherapy data coming from different institutions and vendors. Its robustness and usability were demonstrated in three cohorts of tumor entities treated with RT. Future work will expand the workflow to automatically classify MR sequences.

Parallel Theatre: An actor framework in Java for high performance computing

Theatre is an actor-based system currently implemented in Java, which enables modelling, analysis and implementation of predictable time-dependent distributed systems like cyber-physical systems. Theatre, though, can also be used for untimed complex systems. The core feature of Theatre is its control-based character. A reflective control layer, which can be tailored to the needs of specific application domains, is responsible for scheduling and dispatching messages asynchronously exchanged among actors. A Theatre system is a federation of theatres (computing nodes), upon which application actors are partitioned. Actors can move from a theatre to another. In its distributed implementation, Theatre rests on a socket network initially established among the interacting theatres. Messages and actors exploit Java serialization/deserialization when moving from a theatre to another. This paper proposes a novel extension of Theatre, Parallel Theatre, which is developed for an exploitation of the computing potential of nowadays multi-core machines with shared memory. Parallel Theatre avoids sockets and Java serialization. A key factor of Parallel Theatre consists in being a completely lock-free computing framework. Locks are avoided not only at the application level, as it was already demonstrated by classical actor systems, but also in the runtime system, thus enabling high-performance computing of scalable systems. This paper describes Parallel Theatre and the particular control forms which were developed for untimed and timed parallel systems. Then two scalable models are presented. The first one is concerned with a parallel algorithm for matrix multiplication. The second example is related to a parallel simulation of a multi-agent model for the Iterated Prisoner's Dilemma (IPD), which permits to observe the emergence of cooperation in large populations of players. The experimental results confirm the achievement of good execution performance.

Concurrent Prefix Recovery

This paper proposes a new recovery model based on group commit, called concurrent prefix recovery (CPR). CPR differs from traditional group commit implementations in two ways: (1) it provides a semantic description of committed operations, of the form "all operations until time ti from session i"; and (2) it uses asynchronous incremental checkpointing instead of a WAL to implement group commit in a scalable bottleneck-free manner. CPR provides the same consistency as a point-in-time commit, but allows a scalable concurrent implementation. We used CPR to make two systems durable: (1) a custom in-memory transactional database; and (2) FASTER, our state-of-theart, scalable, larger-than-memory key-value store. Our detailed evaluation of these modified systems shows that CPR is highly scalable and supports concurrent performance reaching hundreds of millions of operations per second on a multi-core machine.

Lock-Free Parallelization for Variance-Reduced Stochastic Gradient Descent on Streaming Data

Stochastic Gradient Descent (SGD) is an iterative algorithm for fitting a model to the training dataset in machine learning problems. With low computation cost, SGD is especially suited for learning from large datasets. However, the variance of SGD tends to be high because it uses only a single data point to determine the update direction at each iteration of gradient descent, rather than all available training data points. Recent research has proposed variance-reduced variants of SGD by incorporating a correction term to approximate full-data gradients. However, it is difficult to parallelize such variants with high performance and accuracy, especially on streaming data. As parallelization is a crucial requirement for large-scale applications, this article focuses on the parallel setting in a multicore machine and presents LFS-STRSAGA, a lock-free approach to parallelizing variance-reduced SGD on streaming data. LFS-STRSAGA embraces a lock-free data structure to process the arrival of streaming data in parallel, and asynchronously maintains the essential information to approximate full-data gradients with low cost. Both our theoretical and empirical results show that LFS-STRSAGA matches the accuracy of the state-of-the-art variance-reduced SGD on streaming data under sparsity assumption (common in machine learning problems), and that LFS-STRSAGA reduces the model update time by over 98 percent.

Discovering regulatory motifs of genetic networks using the indexing-tree based algorithm: a parallel implementation

PurposeThe problem of motif discovery has become a significant challenge in the era of big data where there are hundreds of genomes requiring annotations. The importance of motifs has led many researchers to develop different tools and algorithms for finding them. The purpose of this paper is to propose a new algorithm to increase the speed and accuracy of the motif discovering process, which is the main drawback of motif discovery algorithms.Design/methodology/approachAll motifs are sorted in a tree-based indexing structure where each motif is created from a combination of nucleotides: ‘A’, ‘C’, ‘T’ and ‘G’. The full motif can be discovered by extending the search around 4-mer nucleotides in both directions, left and right. Resultant motifs would be identical or degenerated with various lengths.FindingsThe developed implementation discovers conserved string motifs in DNA without having prior information about the motifs. Even for a large data set that contains millions of nucleotides and thousands of very long sequences, the entire process is completed in a few seconds.Originality/valueExperimental results demonstrate the efficiency of the proposed implementation; as for a real-sequence of 1,270,000 nucleotides spread into 2,000 samples, it takes 5.9 s to complete the overall discovering process when the code ran on an Intel Core i7-6700 @ 3.4 GHz machine and 26.7 s when running on an Intel Xeon x5670 @ 2.93 GHz machine. In addition, the authors have improved computational performance by parallelizing the implementation to run on multi-core machines using the OpenMP framework. The speedup achieved by parallelizing the implementation is scalable and proportional to the number of processors with a high efficiency that is close to 100%.

Mutable locks: Combining the best of spin and sleep locks

SummaryIn 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.

HydraList

Increased capacity of main memory has led to the rise of in-memory databases. With disk access eliminated, efficiency of index structures has become critical for performance in these systems. An ideal index structure should exhibit high performance for a wide variety of workloads, be scalable, and efficient in handling large data sets. Unfortunately, our evaluation shows that most state-of-the-art index structures fail to meet these three goals. For an index to be performant with large data sets, it should ideally have time complexity independent of the key set size. To ensure scalability, critical sections should be minimized and synchronization mechanisms carefully designed to reduce cache coherence traffic. Moreover, complex memory hierarchy in servers makes data placement and memory access patterns important for high performance across all workload types. In this paper, we present HydraList, a new concurrent, scalable, and high performance in-memory index structure for massive multi-core machines. The key insight behind our design of HydraList is that an index structure can be divided into two components (search and data layers) which can be updated independently leading to lower synchronization overhead. By isolating the search layer, we are able to replicate it across NUMA nodes and reduce cache misses and remote memory accesses. As a result, our evaluation shows that HydraList outperforms other index structures especially in a variety of workloads and key types.

Parallel execution combinatorics with metaheuristics: Comparative study

Abstract Optimization arises everywhere in industrial and engineering fields, with complex and time-consuming problems to be solved. Exact search techniques cannot afford practical solutions for most of the real-life problems in reasonable time-bound. Metaheuristics proved to be numerically efficient solvers for such problems in terms of solution quality, however, they could require large time and energy to get the optimal solution. Parallelization (i.e., distributed) is a promising approach for overcoming the overwhelming energy and time consumption values of these methods. Despite recent approaches in running metaheuristics in parallel, the community still lacks for novel studies comparing and benchmarking the canonical optimization techniques while being running in parallel. In this work, we present two extensive studies to the solution quality, energy consumption, and execution time for three different metaheuristics (Genetic Algorithm, Variable Neighborhood Search, and Simulated Annealing) and their distributed counterparts. The main aim of our studies is exploring the efficiency of parallel execution of the metaheuristics while being running in new computing environments. Here, we want to identify the combinatorics between metaheuristics and solving optimization problems while being run in parallel. For our studies, we consider a multicore machine with 32 cores. This choice to a recent and commonly used system shall enrich the existing literature for multicore systems against the enormous existing studies over cluster systems. The analyses and discussions for the results of the different algorithms exhibit the combinatorics between the different metaheuristics and the parallel execution using a different number of cores. The outcome of these studies builds a guide for future designs of efficient and energy-aware optimization techniques.

Faster RooFitting: Automated parallel calculation of collaborative statistical models

RooFit [1,2] is the main statistical modeling and fitting package used to extract physical parameters from reduced particle collision data, e.g. the Higgs boson experiments at the LHC [3,4]. RooFit aims to separate particle physics model building and fitting (the users’ goals) from their technical implementation and optimization in the back-end. In this paper, we outline our efforts to further optimize this back-end by automatically running parts of user models in parallel on multi-core machines. A major challenge is that RooFit allows users to define many different types of models, with different types of computational bottlenecks. Our automatic parallelization framework must then be flexible, while still reducing run-time by at least an order of magnitude, preferably more. We have performed extensive benchmarks and identified at least three bottlenecks that will benefit from parallelization. We designed a parallelization layer that allows us to parallelize existing classes with minimal effort, but with high performance and retaining as much of the existing class’s interface as possible. The high-level parallelization model is a task-stealing approach. Preliminary results show speed-ups of factor 2 to 20, depending on the exact model and parallelization strategy.

A Distributed Shared Memory Middleware for Speculative Parallel Discrete Event Simulation

The large diffusion of multi-core machines has pushed the research in the field of Parallel Discrete Event Simulation (PDES) toward new programming paradigms, based on the exploitation of shared memory. On the opposite side, the advent of Cloud computing—and the possibility to group together many (low-cost) virtual machines to form a distributed memory cluster capable of hosting simulation applications—has raised the need to bridge shared memory programming and seamless distributed execution. In this article, we present the design of a distributed middleware that transparently allows a PDES application coded for shared memory systems to run on clusters of (Cloud) resources. Our middleware is based on a synchronization protocol called Event and Cross State Synchronization. It allows cross-simulation-object access by event handlers, thus representing a powerful tool for the development of various types of PDES applications. We also provide data for an experimental assessment of our middleware architecture, which has been integrated into the open source ROOT-Sim speculative PDES platform.

Shared-memory Parallel Maximal Clique Enumeration from Static and Dynamic Graphs

Maximal Clique Enumeration (MCE) is a fundamental graph mining problem and is useful as a primitive in identifying dense structures in a graph. Due to the high computational cost of MCE, parallel methods are imperative for dealing with large graphs. We present shared-memory parallel algorithms for MCE, with the following properties: (1) the parallel algorithms are provably work-efficient relative to a state-of-the-art sequential algorithm, (2) the algorithms have a provably small parallel depth, showing they can scale to a large number of processors, and (3) our implementations on a multicore machine show good speedup and scaling behavior with increasing number of cores and are substantially faster than prior shared-memory parallel algorithms for MCE; for instance, on certain input graphs, while prior works either ran out of memory or did not complete in five hours, our implementation finished within a minute using 32 cores. We also present work-efficient parallel algorithms for maintaining the set of all maximal cliques in a dynamic graph that is changing through the addition of edges.

SEQUENCE SLIDER: expanding polyalanine fragments for phasing with multiple side-chain hypotheses.

Fragment-based molecular-replacement methods can solve a macromolecular structure quasi-ab initio. ARCIMBOLDO, using a common secondary-structure or tertiary-structure template or a library of folds, locates these with Phaser and reveals the rest of the structure by density modification and autotracing in SHELXE. The latter stage is challenging when dealing with diffraction data at lower resolution, low solvent content, high β-sheet composition or situations in which the initial fragments represent a low fraction of the total scattering or where their accuracy is low. SEQUENCE SLIDER aims to overcome these complications by extending the initial polyalanine fragment with side chains in a multisolution framework. Its use is illustrated on test cases and previously unknown structures. The selection and order of fragments to be extended follows the decrease in log-likelihood gain (LLG) calculated with Phaser upon the omission of each single fragment. When the starting substructure is derived from a remote homolog, sequence assignment to fragments is restricted by the original alignment. Otherwise, the secondary-structure prediction is matched to that found in fragments and traces. Sequence hypotheses are trialled in a brute-force approach through side-chain building and refinement. Scoring the refined models through their LLG in Phaser may allow discrimination of the correct sequence or filter the best partial structures for further density modification and autotracing. The default limits for the number of models to pursue are hardware dependent. In its most economic implementation, suitable for a single laptop, the main-chain trace is extended as polyserine rather than trialling models with different sequence assignments, which requires a grid or multicore machine. SEQUENCE SLIDER has been instrumental in solving two novel structures: that of MltC from 2.7 Å resolution data and that of a pneumococcal lipoprotein with 638 residues and 35% solvent content.