Kernel Implementation Research Articles

Correct and Complete Type Checking and Certified Erasure for Coq, in Coq

Coq is built around a well-delimited kernel that performs type checking for definitions in a variant of the Calculus of Inductive Constructions ( CIC ). Although the metatheory of CIC is very stable and reliable, the correctness of its implementation in Coq is less clear. Indeed, implementing an efficient type checker for CIC is a rather complex task, and many parts of the code rely on implicit invariants which can easily be broken by further evolution of the code. Therefore, on average, one critical bug has been found every year in Coq . This paper presents the first implementation of a type checker for the kernel of Coq (without the module system, template polymorphism and η -conversion), which is proven sound and complete in Coq with respect to its formal specification. Note that because of Gödel’s second incompleteness theorem, there is no hope to prove completely the soundness of the specification of Coq inside Coq (in particular strong normalization), but it is possible to prove the correctness and completeness of the implementation assuming soundness of the specification, thus moving from a trusted code base (TCB) to a trusted theory base (TTB) paradigm. Our work is based on the MetaCoq project which provides meta-programming facilities to work with terms and declarations at the level of the kernel. We verify a relatively efficient type checker based on the specification of the typing relation of the Polymorphic, Cumulative Calculus of Inductive Constructions ( PCUIC ) at the basis of Coq . It is worth mentioning that during the verification process, we have found a source of incompleteness in Coq ’s official type checker, which has then been fixed in Coq 8.14 thanks to our work. In addition to the kernel implementation, another essential feature of Coq is the so-called extraction mechanism: the production of executable code in functional languages from Coq definitions. We present a verified version of this subtle type and proof erasure step, therefore enabling the verified extraction of a safe type checker for Coq in the future.

Large language model evaluation for high‐performance computing software development

AbstractWe apply AI‐assisted large language model (LLM) capabilities of GPT‐3 targeting high‐performance computing (HPC) kernels for (i) code generation, and (ii) auto‐parallelization of serial code in C ++, Fortran, Python and Julia. Our scope includes the following fundamental numerical kernels: AXPY, GEMV, GEMM, SpMV, Jacobi Stencil, and CG, and language/programming models: (1) C++ (e.g., OpenMP [including offload], OpenACC, Kokkos, SyCL, CUDA, and HIP), (2) Fortran (e.g., OpenMP [including offload] and OpenACC), (3) Python (e.g., numpy, Numba, cuPy, and pyCUDA), and (4) Julia (e.g., Threads, CUDA.jl, AMDGPU.jl, and KernelAbstractions.jl). Kernel implementations are generated using GitHub Copilot capabilities powered by the GPT‐based OpenAI Codex available in Visual Studio Code given simple <kernel> + <programming model> + <optional hints> prompt variants. To quantify and compare the generated results, we propose a proficiency metric around the initial 10 suggestions given for each prompt. For auto‐parallelization, we use ChatGPT interactively giving simple prompts as in a dialogue with another human including simple “prompt engineering” follow ups. Results suggest that correct outputs for C++ correlate with the adoption and maturity of programming models. For example, OpenMP and CUDA score really high, whereas HIP is still lacking. We found that prompts from either a targeted language such as Fortran or the more general‐purpose Python can benefit from adding language keywords, while Julia prompts perform acceptably well for its Threads and CUDA.jl programming models. We expect to provide an initial quantifiable point of reference for code generation in each programming model using a state‐of‐the‐art LLM. Overall, understanding the convergence of LLMs, AI, and HPC is crucial due to its rapidly evolving nature and how it is redefining human‐computer interactions.

Exchange-correlation kernel for perturbation dependent auxiliary functions in auxiliary density perturbation theory

ContextAnalytic exchange-correlation kernel formulations are of the outermost importance for density functional theory (DFT) perturbation calculations. In this paper, the working equation for the exchange-correlation kernel of the generalized gradient approximation (GGA) for perturbation dependent auxiliary functions is derived and discussed in the framework of auxiliary density functional theory (ADFT). The presented new formulation is extended to the unrestricted approach, too. A comprehensive discussion of the implementation of the GGA ADFT kernel, using either the native exchange-correlation functional implementations in deMon2k or the ones from the LibXC library, is given. Calculations with analytic exchange-correlation kernels are compared to their finite difference counterparts. The obtained results are in quantitative agreement. Nevertheless, analytic GGA ADFT kernel implementations show substantial improvement in the computational performance. Similar results are reported for analytic second derivatives of effective core potential (ECP) and model core potential (MCP) matrix elements when compared to their finite difference counterparts in molecular frequency analyses.MethodAll calculations are performed in the framework of ADFT as implemented in deMon2k. In the ADFT analytic frequency calculations, auxiliary density perturbation theory was used. The underlying two-center exchange-correlation kernel matrix elements are calculated by numerical integration either with analytic or finite difference kernel expressions. Validation calculations are performed with the VWN and PBE functionals employing DFT-optimized DZVP basis sets in conjunction with automatically generated GEN-A2 auxiliary density function sets. In the (Pt3Cu)n cluster benchmark calculations, the RPBE functional was used. For Pt atoms, the quasi-relativistic LANL2DZ effective core potential with the corresponding valence basis set was employed, whereas for Cu atoms, the all-electron DFT-optimized TZVP basis was applied. The auxiliary density was expanded by the automatically generated GEN-A2* auxiliary function set. We run all benchmark calculations in parallel on 24 cores.

EMG-based prediction of step direction for a better control of lower limb wearable devices

Background and objectivesLower-limb wearable devices can significantly improve the quality of life of subjects suffering from debilitating conditions, such as amputations, neurodegenerative disorders, and stroke-related impairments. Current control approaches, limited to forward walking, fall short of replicating the complexity of human locomotion in complex environments, such as uneven terrains or crowded places. Here we propose a high-level controller based on two Support Vector Machines exploiting four surface electromyography (EMG) signals of the thigh muscles to detect the onset (Toe-off intention decoder) and the direction (Directional EMG decoder) of the upcoming step. Methods and materialsWe validated a preliminary version of the approach by acquiring EMG signals from ten healthy subjects, performing steps in four directions (forward, backward, right, and left), in three different settings (ground-level walking, stairs, and ramps), and in both steady-state and static conditions. Both the Toe-off intention and Directional EMG decoders have been tested with a 5-fold cross-validation repeated five times, using linear and radial-basis-function kernels, and by changing the classification output timing, from 200 ms before to 50 ms after the toe-off. ResultsThe Toe-off intention decoder reached a median accuracy of 83.34 % (interquartile range (IQR): 6.48) and specificity of 92.72 % (IQR: 3.62) in its radial-basis-function version, while the Directional EMG decoder's median accuracy ranged between 73.92 % (IQR: 5.8), 200 ms before the toe-off, to 92.91 % (IQR: 4.11), 50 ms after the toe-off, with the radial-basis-function kernel implementation. For both the Toe-off intention and Directional EMG decoders the radial-basis-function version achieved better performances than the linear one (Wilcoxon signed rank test, p < 0.05). Conclusions and significanceThe combination of the two decoders proved to be a promising solution to detect the step initiation and classify its direction, paving the way for wearable devices with a broader range of movements and more degrees of freedom, ultimately promoting usability in uncontrolled settings and better reactions to external perturbations. Additionally, the encumbrance of the setup is limited to the thigh of the leg of interest, which simplifies the implementation in compact devices, concurrently limiting the sensors worn by the subject.

Efficient and Portable Vectorized Sweep Kernels for the Transport Equation on 3D Cartesian Grids Using the Kokkos Framework

This paper describes the implementation of efficient and portable vectorized sweep kernels as part of the resolution of the neutron transport equation on three-dimensional Cartesian grids using the discrete ordinates ( S n ) method for the angular variable and the diamond differencing (DD) scheme for the spatial discretization. Vectorization is set up along the directions within the same octant and is independent of the spatial discretization order; therefore, the extension of this technique to high-order DD or discontinuous Galerkin schemes is immediate. Our implementation is written in C++17 and relies on the Kokkos performance portability framework. This library allows one to express shared-memory parallelism (including vectorization) in a machine-independent way and supports many backends including CUDA and OpenMP. Our vectorization procedure relies on the portable single instruction multiple data types provided by Kokkos. The method has been implemented for DD schemes up to order 2 and yields promising results on CPUs supporting standard vector instructions.

On a Spectral Method for β-particle Bound Excitation Collisions in Kilonovae

The interaction of β-particles with the weakly ionized plasma background is an important mechanism for powering the kilonova (KN) transient signal from neutron star mergers. For this purpose, we present an implementation of the approximate fast-particle collision kernel, described by Inokuti following the seminal formulation of Bethe, in a spectral solver of the Vlasov–Maxwell–Boltzmann equation. In particular, we expand the fast-particle plane-wave atomic excitation kernel into coefficients of the Hermite basis, and derive the relevant discrete spectral system. In this fast-particle limit, the approach permits the direct use of atomic data, including optical oscillator strengths, normally applied to photon–matter interaction. The resulting spectral matrix is implemented in the MASS-APP spectral solver framework, in a way that avoids full matrix storage per spatial zone. We numerically verify aspects of the matrix construction, and present a proof-of-principle 3D simulation of a 2D axisymmetric KN ejecta snapshot. Our preliminary numerical results indicate that a reasonable choice of Hermite basis parameters for β-particles in the KN is a bulk velocity parameter u = 0, a thermal velocity parameter α = 0.5c, and a 9 × 9 × 9 mode velocity basis set (Hermite orders of 0–8 in each dimension). For interior-ejecta sample zones, we estimate that the ratio of thermalization from large-angle (≳2.°5) bound excitation scattering to total thermalization is ∼0.002–0.003.

A fully scalable homogenization method to upscale 3-D elastic media

SUMMARY Modelling seismic wavefields in complex 3-D elastic media is the key in many fields of Earth Science: seismology, seismic imaging, seismic hazard assessment and earthquake source mechanism reconstruction. This modelling operation can incur significant computational cost, and its accuracy depends on the ability to take into account the scales of the subsurface heterogeneities varying. The theory of homogenization describes how the small-scale heterogeneities interact with the seismic waves and allows to upscale elastic media consistently with the wave equation. In this study, an efficient and scalable numerical homogenization tool is developed, relying on the similarity between the equations describing the propagation of elastic waves and the homogenization process. By exploiting the optimized implementation of an elastic modelling kernel based on a spectral-element discretization and domain decomposition, a fully scalable homogenization process, working directly on the spectral-element mesh, is presented. Numerical experiments on the entire SEAM II foothill model and a 3-D version of the Marmousi II model illustrate the efficiency and flexibility of this approach. A reduction of two orders of magnitude in terms of absolute computational cost is observed on the elastic wave modelling of the entire SEAM II model at a controlled accuracy.

Block-wise dynamic mixed-precision for sparse matrix-vector multiplication on GPUs

Sparse matrix-vector multiplication (SpMV) plays a critical role in a wide range of linear algebra computations, particularly in scientific and engineering disciplines. However, the irregular memory access patterns, extensive memory usage, high bandwidth requirements, and underutilization of parallelism hinder the computational efficiency of SpMV on GPUs. In this paper, we propose a novel approach called block-wise dynamic mixed-precision (BDMP) to address these challenges. Our methodology involves partitioning the original matrix into uniformly sized blocks, with each block’s size determined by considering architectural characteristics and accuracy requirements. Additionally, we dynamically assign precision to each block using a precision selection method that takes into account the value distribution of the original sparse matrix. We develop two distinct SpMV computation algorithms for BDMP: BDMP-PBP (Precision-based partitioning) and BDMP-TCKI (Tailored compression and kernel implementation). BDMP-PBP partitions the matrix into two independent matrices for separate computations based on block precision, offering flexibility for integration with other optimization techniques. Meanwhile, BDMP-TCKI focuses on achieving significant thread-level parallelism and memory utilization by tailoring an appropriate compressed storage format and kernel implementation for each block. We compare BDMP with NVIDIA’s cuSPARSE library and three state-of-the-art SpMV methods, including SELLP, MergeBase, and BalanceCSR, using matrices from the University of Florida’s SuiteSparse dataset collection. BDMP-PBP and BDMP-TCKI show average speedups up to 2.64×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes $$\\end{document} and 2.91×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes $$\\end{document} on Turing RTX 2080Ti, and up to 2.99×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes $$\\end{document} and 3.22×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes $$\\end{document} on Ampere A100. The results demonstrate that BDMP enables the optimization of computation speed without compromising the precision necessary for reliable results.

Exploring Data Layout for Sparse Tensor Times Dense Matrix on GPUs

An important sparse tensor computation is sparse-tensor-dense-matrix multiplication (SpTM), which is used in tensor decomposition and applications. SpTM is a multi-dimensional analog to sparse-matrix-dense-matrix multiplication (SpMM). In this article, we employ a hierarchical tensor data layout that can unfold a multidimensional tensor to derive a 2D matrix, making it possible to compute SpTM using SpMM kernel implementations for GPUs. We compare two SpMM implementations to the state-of-the-art PASTA sparse tensor contraction implementation using: (1) SpMM with hierarchical tensor data layout; and, (2) unfolding followed by an invocation of cuSPARSE’s SpMM. Results show that SpMM can outperform PASTA 70.9% of the time, but none of the three approaches is best overall. Therefore, we use a decision tree classifier to identify the best performing sparse tensor contraction kernel based on precomputed properties of the sparse tensor.

Approach to fuzzing testing of network interfaces of Linux family operating systems using hardware virtualization technology

The purpose of this research is to create a new approach to fuzzing testing of network interfaces of Linux family operating systems. The relevance of the research is due to the growing number of network attacks, the prevalence of Linux family operating systems on server hardware, and their use in the construction of cloud computing systems. According to data as of November 2021, among all web servers whose operating system is known, 38.9% use Linux family operating systems. In this work, the architecture and implementation of the Linux kernel networking stack are investigated. Current research in the field of Linux kernel security is analyzed.

DDPG-MPCC: An Experience Driven Multipath Performance Oriented Congestion Control

We introduce a novel multipath data transport approach at the transport layer referred to as ‘Deep Deterministic Policy Gradient for Multipath Performance-oriented Congestion Control’ (DDPG-MPCC), which leverages deep reinforcement learning to enhance congestion management in multipath networks. Our method combines DDPG with online convex optimization to optimize fairness and performance in simultaneously challenging multipath internet congestion control scenarios. Through experiments by developing kernel implementation, we show how DDPG-MPCC performs compared to the state-of-the-art solutions.

Modelling rainfall-induced landslides at a regional scale, a machine learning based approach

AbstractIn Italy, rainfall represents the most common triggering factor for landslides; thus, many Italian Regional Departments of Civil Protection are setting up warning systems based on rainfall recordings. Common methods are mainly based on empirical relationships that provide the rainfall thresholds above which the occurrence of landslide phenomena is likely to be expected. In recent years, the use of machine learning approaches has gained popularity in landslide susceptibility analysis and prediction. To support the operational early warning system of Liguria Civil Protection Department for landslides hazard, we propose the implementation of a polynomial Kernel regularized least squares regression (KRLS) algorithm, for predicting the daily occurrence of shallow landslides in the five Alert Zones in Liguria (North Western Italy). The model provides an estimate of the number of landslides associated with the set of three different hydrological features, also used for the Hydrological Assessment procedure: the soil moisture, the accumulated precipitation over 12 h and the precipitation peak over 3 h. Results of the model are converted to an Alert Scenario of landslide occurrence, based on the magnitude of the expected event and identified according to the National and Regional legislation (Regional Civil Protection guidelines D.G.R. n. 1116, 23/12/2020). The performance of the predictive model (e.g. accuracy of 93%) is deemed satisfactory and the methodology is considered a valuable support to the operational early warning system of Liguria Civil Protection Department. The choice of predictive variables allows, in future development, the values obtained from historical data to be replaced by those obtained from meteorological forecast models, introducing the use of the developed model in the operational forecasting chain.

Sparse matrix‐vector and matrix‐multivector products for the truncated SVD on graphics processors

SummaryMany practical algorithms for numerical rank computations implement an iterative procedure that involves repeated multiplications of a vector, or a collection of vectors, with both a sparse matrix and its transpose. Unfortunately, the realization of these sparse products on current high performance libraries often deliver much lower arithmetic throughput when the matrix involved in the product is transposed. In this work, we propose a hybrid sparse matrix layout, named CSRC, that combines the flexibility of some well‐known sparse formats to offer a number of appealing properties: (1) CSRC can be obtained at low cost from the popular CSR (compressed sparse row) format; (2) CSRC has similar storage requirements as CSR; and especially, (3) the implementation of the sparse product kernels delivers high performance for both the direct product and its transposed variant on modern graphics accelerators thanks to a significant reduction of atomic operations compared to a conventional implementation based on CSR. This solution thus renders considerably higher performance when integrated into an iterative algorithm for the truncated singular value decomposition (SVD), such as the randomized SVD or, as demonstrated in the experimental results, the block Golub–Kahan–Lanczos algorithm.

Partially Oblivious Congestion Control for the Internet via Reinforcement Learning

Despite years of research on transport protocols, the tussle between in-network and end-to-end congestion control has not been solved. This debate is due to the variance of conditions and assumptions in different network scenarios, e.g., cellular versus data center networks. Recently, the community has proposed a few transport protocols driven by machine learning, nonetheless limited to end-to-end approaches. In this paper, we present Owl, a transport protocol based on reinforcement learning, whose goal is to select the proper congestion window learning from end-to-end features and network signals, when available. We show that our solution converges to a fair resource allocation after the learning overhead. Our kernel implementation, deployed over emulated and large scale virtual network testbeds, outperforms all benchmark solutions based on end-to-end or in-network congestion control.

HipBone: A performance-portable graphics processing unit-accelerated C++ version of the NekBone benchmark

We present hipBone, an open-source performance-portable proxy application for the Nek5000 (and NekRS) computational fluid dynamics applications. HipBone is a fully GPU-accelerated C++ implementation of the original NekBone CPU proxy application with several novel algorithmic and implementation improvements which optimize its performance on modern fine-grain parallel GPU accelerators. Our optimizations include a conversion to store the degrees of freedom of the problem in assembled form in order to reduce the amount of data moved during the main iteration and a portable implementation of the main Poisson operator kernel. We demonstrate near-roofline performance of the operator kernel on three different modern GPU accelerators from two different vendors. We present a novel algorithm for splitting the application of the Poisson operator on GPUs which aggressively hides MPI communication required for both halo exchange and assembly. Our implementation of nearest-neighbor MPI communication then leverages several different routing algorithms and GPU-Direct RDMA capabilities, when available, which improves scalability of the benchmark. We demonstrate the performance of hipBone on three different clusters housed at Oak Ridge National Laboratory, namely, the Summit supercomputer and the Frontier early-access clusters, Spock and Crusher. Our tests demonstrate both portability across different clusters and very good scaling efficiency, especially on large problems.

HybriDC: A Resource-Efficient CPU-FPGA Heterogeneous Acceleration System for Lossless Data Compression.

Lossless data compression is a crucial and computing-intensive application in data-centric scenarios. To reduce the CPU overhead, FPGA-based accelerators have been proposed to offload compression workloads. However, most existing schemes have the problem of an imbalanced resource utilization and a poor practicability. In this paper, we propose HybriDC, an adaptive resource-efficient CPU-FPGA heterogeneous acceleration system for lossless data compression. Leveraging complementary advantages of the heterogeneous architecture, HybriDC provides a universal end-to-end compression acceleration framework with application compatibility and performance scalability. To optimize the hardware compression kernel design, we build a performance-resource model of the compression algorithm taking into account the design goal, compression performance, available resources, etc. According to the deduced resource-balanced design principle, the compression algorithm parameters are fine-tuned, which reduces 32% of the block RAM usage of the LZ4 kernel. In the parallel compression kernel implementation, a memory-efficient parallel hash table with an extra checksum is proposed, which supports parallel processing and improves the compression ratio without extra memory. We develop an LZ4-based HybriDC system prototype and evaluate it in detail. Our LZ4 compression kernel achieves state-of-the-art memory efficiency, 2.5-4× better than existing designs with comparable compression ratios. The evaluation of total resource utilization and end-to-end throughput demonstrates the excellent scalability of HybriDC. In power efficiency, the four-kernel HybriDC prototype achieves a threefold advantage over the standard LZ4 algorithm.

Acceleration with long vector architectures: Implementation and evaluation of the FFT kernel on NEC SX‐Aurora and RISC‐V vector extension

SummaryNovel architectures leveraging long and variable vector lengths like the NEC SX‐Aurora or the vector extension of RISCV are appearing as promising solutions on the supercomputing market. These architectures often require re‐coding of scientific kernels. For example, traditional implementations of algorithms for computing the fast Fourier transform (FFT) cannot take full advantage of vector architectures. In this article, we present the implementation of FFT algorithms able to leverage these novel architectures. We evaluate these codes on NEC SX‐Aurora , comparing them with the optimized NEC libraries; and in a prototype of a RISC‐V core with a vector processing unit. We present the benefits and limitations of two approaches of RADIX‐2 FFT vector implementations. We show that our approach makes better use of the vector unit of the NEC SX‐Aurora , reaching higher or equal performance than the optimized NEC library. More generally, we prove the importance of maximizing the vector length usage of the algorithm, taking advantage of the FFT properties to reduce long‐latency vector operations, and reordering the instructions according to the specific hardware features to boost the performance of FFT‐like computational kernels.

Special Issue 19th international workshop on algorithms, models and tools for parallel computing on heterogeneous platforms (HeteroPar'21)

Heterogeneity has emerged as one of the most profound and challenging characteristics of today's parallel environments. From the macro level, where networks of distributed computers, composed of diverse node architectures, are interconnected with potentially heterogeneous networks, to the micro level, where deeper memory hierarchies and various accelerator architectures are increasingly common, the impact of heterogeneity on all computing tasks is increasing rapidly. Traditional parallel algorithms, programming environments, and tools, designed for legacy homogeneous multiprocessors, achieve a small fraction of the efficiency and the potential performance that can be obtained in current and future heterogeneous computing platforms. New ideas, innovative algorithms, and specialized programming environments and tools are needed to efficiently use these modern parallel and heterogeneous architectures. The International workshop on algorithms, models and tools for parallel computing on heterogeneous platforms (HeteroPar) is a forum for researchers working on algorithms, programming languages, tools, and theoretical models for efficiently solving complex problems on heterogeneous parallel platforms. HeteroPar 2021 took place (virtually) in Lisbon, Portugal, organized for the 13th time in conjunction with the Euro-Par annual international conference. The format of the workshop included one keynote and 11 technical presentations. The workshop papers represented an interesting mix of topics, addressing the implementation of algorithms and kernels for heterogeneous computing, programming models, data management, runtime and resource management, energy efficiency, cloud computing, and artificial intelligence-based methods oriented towards heterogeneous platforms, as the basis for the next generation exascale computers. The selected papers cover a good spectrum of research topics in the area of heterogeneous computing showing the challenges present on these modern platforms.

A Deep Neural Network Accelerator using Residue Arithmetic in a Hybrid Optoelectronic System

The acceleration of Deep Neural Networks (DNNs) has attracted much attention in research. Many critical real-time applications benefit from DNN accelerators but are limited by their compute-intensive nature. This work introduces an accelerator for Convolutional Neural Network (CNN) , based on a hybrid optoelectronic computing architecture and residue number system (RNS) . The RNS reduces the optical critical path and lowers the power requirements. In addition, the wavelength division multiplexing (WDM) allows high-speed operation at the system level by enabling high-level parallelism. The proposed RNS compute modules use one-hot encoding, and thus enable fast switching between the electrical and optical domains. We propose a new architecture that combines residue electrical adders and optical multipliers as the matrix-vector multiplication unit. Moreover, we enhance the implementation of different CNN computational kernels using WDM-enabled RNS based integrated photonics. The area and power efficiency of the proposed accelerator are 0.39 TOPS/s/mm 2 and 3.22 TOPS/s/W, respectively. In terms of computation capability, the proposed chip is 12.7× and 4.02× better than other optical implementation and memristor implementation, respectively. Our experimental evaluation using DNN benchmarks illustrates that our architecture can perform on average more than 72 times faster than GPU under the same power budget.

Assignment of structural domains in proteins using diffusion kernels on graphs

Though proposing algorithmic approaches for protein domain decomposition has been of high interest, the inherent ambiguity to the problem makes it still an active area of research. Besides, accurate automated methods are in high demand as the number of solved structures for complex proteins is on the rise. While majority of the previous efforts for decomposition of 3D structures are centered on the developing clustering algorithms, employing enhanced measures of proximity between the amino acids has remained rather uncharted. If there exists a kernel function that in its reproducing kernel Hilbert space, structural domains of proteins become well separated, then protein structures can be parsed into domains without the need to use a complex clustering algorithm. Inspired by this idea, we developed a protein domain decomposition method based on diffusion kernels on protein graphs. We examined all combinations of four graph node kernels and two clustering algorithms to investigate their capability to decompose protein structures. The proposed method is tested on five of the most commonly used benchmark datasets for protein domain assignment plus a comprehensive non-redundant dataset. The results show a competitive performance of the method utilizing one of the diffusion kernels compared to four of the best automatic methods. Our method is also able to offer alternative partitionings for the same structure which is in line with the subjective definition of protein domain. With a competitive accuracy and balanced performance for the simple and complex structures despite relying on a relatively naive criterion to choose optimal decomposition, the proposed method revealed that diffusion kernels on graphs in particular, and kernel functions in general are promising measures to facilitate parsing proteins into domains and performing different structural analysis on proteins. The size and interconnectedness of the protein graphs make them promising targets for diffusion kernels as measures of affinity between amino acids. The versatility of our method allows the implementation of future kernels with higher performance. The source code of the proposed method is accessible at https://github.com/taherimo/kludo. Also, the proposed method is available as a web application from https://cbph.ir/tools/kludo.