Search

FPGA has recently played an increasingly important role in heterogeneous computing, but Register Transfer Level design flows are not only inefficient in design, but also require designers to be familiar with the circuit architecture. High-level synthesis (HLS) allows developers to design FPGA circuits more efficiently with a more familiar programming language, a higher level of abstraction, and automatic adaptation of timing constraints. When using HLS tools, such as Xilinx Vivado HLS, specific design patterns and techniques are required in order to create high-performance circuits. Moreover, designing efficient concurrency and data flow structures requires a deep understanding of the hardware, imposing more learning costs on programmers. In this paper, we propose a set of functional patterns libraries based on the MapReduce model, implemented by C++ templates, which can quickly implement high-performance parallel pipelined computing models on FPGA with specified simple parameters. The usage of this pattern library allows flexible adaptation of parallel and flow structures in algorithms, which greatly improves the coding efficiency. The contributions of this paper are as follows. (1) Four standard functional operators suitable for hardware parallel computing are defined. (2) Functional concurrent programming patterns are described based on C++ templates and Xilinx HLS. (3) The efficiency of this programming paradigm is verified with two algorithms with different complexity.

Smart Contracts based cryptocurrencies such as Ethereum are becoming increasingly popular in various domains: but with this increase in popularity comes a significant decrease in throughput and efficiency. Smart Contracts are executed by every miner in the system serially without any parallelism, both inter and intra-Smart Contracts. Such a serial execution inhibits the scalability required to obtain extremely high throughput pertaining to computationally intensive tasks deployed with such Smart Contracts. While significant advancements have been made in the field of concurrency, from GPU architectures that enable massively parallel computation to tools such as MapRe-duce that distributed computing to several nodes connected in the system to achieve higher performance in distributed systems, none are incorporated in blockchain-based distributed computing. The team proposes a novel blockchain that allows public nodes in a permission-independent blockchain to deploy and run Smart Contracts that provide concurrency-related functionalities within the Smart Contract framework. In this paper, the researchers present “ConCurrency,” a blockchain network capable of handling big data-based computations. The technique is based on currently used distributed system paradigms, such as MapReduce, while also allowing for fundamental parallelly computable problems. Concurrency is achieved using a sharding protocol incorporated with consensus mechanisms to ensure high scalability, high reliability, and better efficiency. A detailed methodology and a comprehensive analysis of the proposed blockchain further indicate a significant increase in throughput for parallelly computable tasks, as detailed in this paper.

Since the COVID-19 pandemic, video live-streaming technologies that ensure learning continuity have evolved rapidly. With the epidemic under control in China, a growing number of colleges classroom teaching will be online live simultaneously. Traditional offline teaching will gradually transform to the combination of online and offline mode. With the demand for the normality high-definition online live-streaming, the traditional live broadcast system faces the problems of limited scalability, poor fault tolerant ability and poor user experience. In this paper, a distributed online live-streaming system cross multiple campuses which based on SRS is designed and realized. Through dynamic distributed push, upstream and downstream traffic separation, and multi-level load balancing mechanism, the system can satisfy the need of the automatic and unattended normal video live-streaming teaching of large-scale classrooms. In this loosely coupled system, all components are distributed on each campus and communicate via message queues and HTPP API. The system has been applied to Xi’an Jiaotong University daily online and offline teaching for 700 classrooms spread over three campuses.

Spring is a very popular and strong open-source framework in web application development. It provides most of features about dependency injection (DI) container, but it is weak and defective in concurrent access and cyclic reference among objects. Based on the technique of object dependent graph, an new DI container named as GDCC solves these issues successfully.

Summary Adapting high-performance software to various architecture while ensuring performance is a challenging endeavor more so in our industry where HPC drives explorations and production activities. Seismic exploration is impossible without seismic imaging and velocity model building which both entirely rely on supercomputers. In this work, we describe how we ported our existing proprietary seismic libraries to GPUs & how this single effort will work out for many other architectures.

In this paper we study the problem of consistency in distributed storage systems relying on erasure coding for storage efficient fault-tolerance. We propose QLOC - a flexible framework for supporting the storage of warm data, i.e., data which, while not being very frequently in use, nevertheless continues to be accessed for reads or writes regularly. QLOC builds upon (1) a generic family of local reconstruction codes with guarantees in terms of fault-tolerance, efficient recovery from failures and degraded mode operations, and can be instantiated with parameters customized to requirements such as storage overhead and reliability dictated by user needs and operational environments, and (2) quorum-based consistency mechanisms with support for read-modify-write operations without any underlying atomic primitives, providing deployment choices trading-off fault-tolerance, consistency and concurrency requirements. We carry out a theoretical analysis of the code properties, and experimentally benchmark the performance of the consistency enforcement mechanisms, demonstrating the practicality of the proposed approach. Ministry of Education (MOE) Published version The work of Anwitaman Datta and Adamas Aqsa Fahreza was supported by the Ministry of Education (MoE), Singapore, through the Academic Research Fund Tier 1 for the project titled ‘StorEdge: Data store along a cloud-to-thing continuum with integrity and availability’ under Project 2018-T1-002-076.

Борис Яковлевич Штейнберг, доктор технических наук, старший научный сотрудник, заведующий кафедры алгебры и дискретной математики, Южный федеральный университет, (г. Ростов-на-Дону, Российская Федерация), borsteinb@mail.ru. Александр Александрович Василенко, аспирант, ассистент кафедры информатики и вычислительного эксперимента, Южный федеральный университет, (г. Ростовна-Дону, Российская Федерация), avas@sfedu.ru. Вадим Владимирович Веселовский, студент, кафедра алгебры и дискретной математики, Южный федеральный университет, (г. Ростов-на-Дону, Российская Федерация), vesvadvlad1@gmail.com. Никита Александрович Живых, студент, кафедра алгебры и дискретной математики, Южный федеральный университет, (г. Ростов-на-Дону, Российская Федерация), zivih.n@gmail.com. B.Ya. Steinberg1, A.A. Vasilenko1, V.V. Veselovskiy1, N.A. Zhivykh1 1Southern Federal University, Rostov-on-Don, Russian Federation E-mail: borsteinb@mail.ru, avas@sfedu.ru, vesvadvlad1@gmail.com, zivih.n@gmail.com В статье предлагаются методы построения быстрых решателей для систем линейных алгебраических уравнений с блочно-ленточными матрицами. Предлагается структура данных для эффективного хранения таких матриц в оперативной памяти и быстрый алгоритм решения систем линейных уравнений с такой матрицей, основанный на этой структуре. Статья ориентирована на создание решателей, основанных на итерационных алгоритмах решения систем линейных уравнений как с симметрическими матрицами, так и с матрицами, имеющими седловую особенность. Предлагается разрабатывать и использовать специальный предкомпилятор для ускорения решателя. В данной работе экспериментальный решатель реализован на языке Си, предварительная компиляция выполнена на основе имеющейся у авторов Оптимизирующей распараллеливающей системы. Приводятся результаты численных экспериментов, демонстрирующие высокую эффективность разработанных методов, в том числе, и эффективность предкомпилятора. The article proposes methods for constructing fast solvers for systems of linear algebraic equations with block-band matrices. A data structure for efficient storage of such matrices in RAM and a fast algorithm for solving systems of linear equations with such matrices based on this structure are proposed. The article is focused on the creation of solvers based on iterative algorithms for solving systems of linear equations with both symmetric matrices and matrices having a saddle-point singularity. It is proposed to develop and use a special precompiler to speed up the solver. The experimental solver is implemented in C, and the preliminary compilation is based on the Optimizing Parallelizing System in this paper. The results of numerical experiments that demonstrate high efficiency of the developed methods, including the efficiency of the precompiler, are presented. Работа проводилась при финансовой поддержке гранта Правительства РФ № 075-15-2019-1928.

The recent advancements in multicore machines highlight the need to simplify concurrent programming in order to leverage their computational power. One way to achieve this is by designing efficient concurrent data structures (e.g. stacks, queues, hash-tables, etc.) and synchronization techniques (e.g. locks, combining techniques, etc.) that perform well in machines with large amounts of cores. In contrast to ordinary, sequential data-structures, the concurrent data-structures allow multiple threads to simultaneously access and/or modify them. Synch is an open-source framework that not only provides some common high-performant concurrent data-structures, but it also provides researchers with the tools for designing and benchmarking high performant concurrent data-structures. The Synch framework contains a substantial set of concurrent data-structures such as queues, stacks, combining-objects, hash-tables, locks, etc. and it provides a user-friendly runtime for developing and benchmarking concurrent data-structures. Among other features, the provided runtime provides functionality for creating threads easily (both POSIX and user-level threads), tools for measuring performance, etc. Moreover, the provided concurrent data-structures and the runtime are highly optimized for contemporary NUMA multiprocessors such as AMD Epyc and Intel Xeon.

Various blocking operations, such as input/output (IO) operations, are an essential functionality of concurrent applications. However, these operations often cause efficiency-related challenges in multithreaded applications because of the single- thread access policy. IO operations' speed and efficiency heavily rely on operating system (OS) threads and scheduling processes, which is time consuming because of the insufficient distribution of OS resources. Because of their overgeneralization, required to support various usage scenarios, robust OS kernel threads are commonly heavyweight and oversized, created in a limited number, and heavily dependent on OS schedulers. Various asynchronous programming techniques tackled issues in implementing modern concurrent applications with blocking operations with the complete reconstruction of threads and their schedulers. Based on our previous preliminary research, we further explored a model of structured concurrency in Java Virtual Machine (JVM), through the updated implementation of virtual threads and accompanying schedulers, as a novel form of lightweight user-mode threads in the JVM, decoupled from OS threads and managed within the JVM. In this paper, we present our findings about the efficiency of those schedulers utilized for virtual threads on blocking operations, compared with the implementation of OS threads' schedulers, and review possibilities of reducing memory footprints and context switching costs.

The existing concurrency model for Java (or C) requires programmers to design and implement thread-safe classes by explicitly acquiring locks and releasing locks. Such a model is error-prone and is the reason for many concurrency bugs. While there are alternative models like transactional memory, manually writing locks remains prevalent in practice. In this work, we propose AutoLock, which aims to solve the problem by fully automatically generating thread-safe classes. Given a class which is assumed to be correct with sequential clients, AutoLock automatically generates a thread-safe class which is linearizable, and does it in a way without requiring a specification of the class. AutoLock takes three steps: (1) infer access annotations (i.e., abstract information on how variables are accessed and aliased), (2) synthesize a locking policy based on the access annotations, and (3) consistently implement the locking policy. AutoLock has been evaluated on a set of benchmark programs and the results show that AutoLock generates thread-safe classes effectively and could have prevented existing concurrency bugs.

This paper aims to explore and solve the difficult problems faced in the development of traditional credit banks, and analyze the adaptability of blockchain technology in credit banks. The credit chain was designed with Beihang Chain as a prototype, and the transaction speed, scalability and credibility were improved through technologies such as domain indexing, dual-chain concurrency and parallel Byzantine protocol. Then the credit chain is applied to the credit bank architecture to provide an effective solution for the construction of credit bank.

In this paper, we propose an effective concurrency bug testing approach that focuses on suspicious bug-causing code regions instead of indiscriminately testing the whole program. Additionally, with a simple loop heuristic, the region-based approach effectively avoids the state explosion problem. It is highly efficient while guaranteeing to find any existing concurrency bugs in the specified code regions. We also devise an optimization scheme to reduce the number of interleavings to be examined to achieve maximum efficiency. Our method can conveniently identify bug-causing interleavings and hence significantly improve debugging efficiency. We have implemented the proposed approach and successfully tested on a few large application cases. The experimental results show that the approach can precisely identify bug sources and perform much more effectively than traditional approaches.

We extend the algebra of reversible computation to support quantum computing. Since the algebra is based on true concurrency, it is reversible for quantum computing and it has a sound and complete theory.

For the last two decades, a wide spectrum of interpretations of non-interference11The notion of non-interference discussed in this paper enforces flow security in a program and is different from the concept of non-interference used for establishing functional correctness of parallel programs [1] have been used in the security analysis of programs, starting with the notion proposed by Goguen & Meseguer along with arguments of its impact on security practice. While the majority of works deal with sequential programs, several researchers have extended the notion of non-interference to enforce information flow-security in non-deterministic and concurrent programs. Major efforts of generalizations are based on (i) considering input sequences as a basic unit for input/output with semantic interpretation on a two-point information flow lattice, or (ii) typing of expressions as values for reading and writing, or (iii) typing of expressions along with its limited effects. Such approaches have limited compositionality and, thus, pose issues while extending these notions for concurrent programs. Further, in a general multi-point lattice, the notion of a public observer (or attacker) is not unique as it depends on the level of the attacker and the one attacked. In this paper, we first propose a compositional variant of non-interference for sequential systems that follow a general information flow lattice and place it in the context of earlier definitions of non-interference. We show that such an extension leads to the capturing of violations of information flow security in a concrete setting of a sequential language. Finally, we generalize non-interference for concurrent programs and illustrate its use for security analysis, particularly in the cases where information is transmitted through shared variables.

Java Pathfinder (JPF) is one of the most mature software model checker developed by NASA for detecting errors lurking in concurrent Java programs. However, the use of JPF often leads to the state space explosion due to the non-determinism of thread interleavings. Parallelization is one mainstream technique to deal with the problem by utilizing the advantage of multi-core processors. Hence, making JPF parallelized to improve the performance in verifying programs is highly desired. In this paper, we present a divide & conquer approach to splitting the entire state space into multiple layers, in which each layer consists of many sub-state spaces so that JPF can independently verify such sub-state spaces in parallel. Some experiments demonstrate that the proposed technique mitigates the state space explosion that prevents the use of only one JPF instance from conducting model checking.

Modern programming languages support concurrent programming based on channels and processes. Channels enable synchronous and asynchronous message-passing between independent light-weight processes making it easy to express common concurrency patterns. The implementation of channels and processes in compilers and language runtimes is a difficult task that relies heavily on traditional and error-prone low-level concurrency primitives, raising concerns about correctness and reliability. In this paper, we present an automatic program generation technique to test such programming language implementations. We define a type and effect system for programs that communicate over channels and where every execution is guaranteed to eventually terminate. We can generate and run such programs, and if a program fails to terminate, we have found a bug in the programming language implementation. We implement such an automatic program generator and apply it to Go, Kotlin, Crystal, and Flix. We find two new bugs in Flix, and reproduce two bugs; one in Crystal and one in Kotlin.

Tongue image extraction is a primary and fundamental step in the objectification of the tongue diagnoses of traditional Chinese medicine. Aiming at the problems that some methods need to adjust parameters by manual and their accuracy and efficiency are not high, in this paper, a kind of novel concurrent d-search algorithm fusing multi-dimensional information is proposed for the application of tongue image extraction in order to realize automatic, fast and accurate tongue image extraction. In our method, original tongue image is considered as a pixel network. Starting from the seed pixel of central region, according to the intensity, hue and relative position information of the pixels of tongue image, a novel d-search algorithm is utilized to search tongue body region in original tongue image. Because tongue coating is surrounded by tongue substance in most cases, we propose a novel position operator to decide whether current pixel is surrounded by tongue substance in our d-search algorithm so as to extract tongue image with coating accurately. In the same time, to improve the efficiency of our algorithm, the original tongue image is divided into several regions (i.e. sub-images), concurrent techniques are utilized to search different tongue regions separately, so as to get the tongue image templates of different regions quickly, and then they are combined into one template. In addition, morphological operators including closing and opening are applied to the template after combination, so that small holes in the template image can be filled. In the end, an and operation is applied to the ultimate template and original tongue image, in order to get extracted tongue image. In our study, we conduct the comparison experiments of 4 methods including the method of manual extraction, our method, tongue image extraction based on greedy rules and tongue image extraction based on random walk. The comparison experiments are conducted from the aspects of accuracy and efficiency. The tongue images of the 5 typical kinds of colors including light red, light white, red, deep red and purple are utilized to test the 3 methods. Furthermore, a tongue image with thick white coating and a tongue image with thick yellow coating are also utilized to test the 3 methods. These tongue image samples cover all kinds of tongue colors and include tongue images with or without tongue coating. Therefore, the results of our tests are persuasive. In comparative experiments, our method achieves quite good effect in the aspect of accuracy and is superior to the current 2 methods in the aspect of efficiency, which can meet the accuracy and efficiency requirements of the objectification of tongue diagnoses. And we have implemented automatic tongue image extraction without adjusting any parameters by manual.

A proton therapy facility (HUST-PTF) based on a superconducting cyclotron is being developed by Huazhong University of Science and Technology (HUST) and China Academy of Atomic Energy (CIAE). The beam transport system in this facility provides the required beam for the treatment rooms. The beamline control system (BCS) manages the operation of the degrader, beamline magnet power supplies (PS), diagnostics devices, etc. For additional security, BCS utilizes the OPC UA as the distributed control protocol. Since the PS controllers adopt a TCP communication protocol, an OPC UA server with TCP driver is developed as a gateway and front controller for PS control. In order to adapt fast beam-energy change, the "list-trigger" strategy is applied to the PS control. BCS downloads the respective current value lists to PS controllers before the treatment, and then triggers the PS controllers by pulse signals to alter the operation current to the next value in the list during the treatment. It is vital to decide when the current regulation process is complete in the transitional period, BCS should update the current values more frequent than the steady state. Therefore, the OPC UA server adopts the node dynamic refresh scheme. A virtual simulation based on docker followed by a thorough analysis are conducted on the PS control system, where the results show the node refresh time of the OPC UA server meets the PS control requirement. The virtual simulation is also proved to be cost-saving and reliable for control system tests and worth promoting.

To simplify shared-memory concurrent programming, in addition to low-level synchronisation primitives, several modern programming languages have started to offer core support for higher-level communication primitives as well, in the guise of message passing through channels. Yet, a growing body of evidence suggests that channel-based programming abstractions for shared memory also have their issues.The Discourje project aims to help programmers cope with message-passing concurrency bugs in Clojure programs, based on run-time verification and dynamic monitoring. The idea is that programmers write not only implementations, but also specifications (of sessions of channel actions). Discourje then offers a library to ensure that implementations run safely relative to specifications (= “bad” channel actions never happen).This paper gives a tour of the current state of Discourje, by example; it is intended to serve both as a general overview for readers who are unfamiliar with previous work on Discourje, and as an introduction to new features for readers who are familiar.

[Context] There are a variety of testing techniques available that present different and often complementary characteristics (e.g., cost of application, effectiveness in revealing defects, types of defects). Considering these complementary characteristics make the selection process even more complex. Testers must make decisions on which techniques they will use in a specific situation. Combining different testing techniques outperforms the use of any single technique alone. [Objective] This paper proposes an approach to support the combined selection of testing techniques for concurrent software projects. The approach is implemented in the SeleCTT-v2 tool, supporting testers to find complementary testing techniques in the body of knowledge proposed in SeleCTT-v1. [Method] We conducted a case study to evaluate the combined selection approach (SeleCTT-v2) with the previous version of the SeleCTT-v1 and to investigate how testers perform a combined selection task for concurrent software projects. [Results and Conclusions] The results indicated a rise in the effectiveness of the combined selection of concurrent testing techniques suggested, which demonstrates SeleCTT-v2 is less likely to make an incorrect recommendation of combined techniques for a concurrent software project, thus avoiding costs associated with the incorrect application of a testing technique. If the testers could access a tool that supports the selection process, the effectiveness of the results would have reached a higher value, as evidenced by our approach. Performing the combination of testing techniques is essential to ensure that software under test has all their features tested to prevent possible errors.

There has been tremendous progress in the past few decades towards developing applications that receive data and send data concurrently. In such a day and age, there is a requirement for a language that can perform optimally in such environments. Currently, the two most popular languages in that respect are Go and Java. In this paper, we look to analyze the concurrency features of Go and Java through a complete programming language performance analysis, looking at their compile time, run time, binary sizes and the language’s unique concurrency features. This is done by experimenting with the two languages using the matrix multiplication and PageRank algorithms. To the extent of our knowledge, this is the first work which used PageRank algorithm to analyse concurrency. Considering the results of this paper, application developers and researchers can hypothesize on an appropriate language to use for their concurrent programming activity.Results of this paper show that Go performs better for fewer number of computation but is soon taken over by Java as the number of computations drastically increase. This trend is shown to be the opposite when thread creation and management is considered where Java performs better with fewer computation but Go does better later on. Regarding concurrency features both Java with its Executor Service library and Go had their own advantages that made them better for specific applications.

Rely-Guarantee is a comprehensive technique that supports compositional reasoning for concurrent programs. However, specifications of the Rely condition - environment interference, and Guarantee condition - local transformation of thread state - are challenging to establish. Thus the construction of these conditions becomes bottleneck in automating the technique. To tackle the above problem, we propose a verification framework that, based on Rely-Guarantee principles, constructs the correctness proof of concurrent program through inferring suitable Rely -Guarantee conditions automatically. Our framework first constructs a Hoare-style sequential proof for each thread and then applies abstraction refinement to elevate these proofs into concurrent ones with appropriate Rely-Guarantee relations. Experiment results demonstrate that our approach is efficient in proving the correctness of concurrent programs.

Concurrency bugs are notoriously hard to identify and fix. A systematic way of avoiding concurrency bugs is to design and implement a locking policy that consistently guards all shared variables. Concurrency bugs thus can be viewed as the result of an illy-designed or poorly implemented locking policy. The trouble is that the locking policy is often not documented, which makes debugging concurrency bugs clueless. We argue that it is too late to debug concurrency bugs after programming is done and we instead detect and fix them while they are being implemented. In this work, we propose an approach named IFIX which flags potential concurrency bugs and recommends fixes while the bugs are introduced. The key idea is to automatically conjecture what the intended locking policy is based on static analysis and recommend fixes accordingly. The recommended fixes are present to the programmer promptly and the user feedback (i.e., whether the certain recommendation is selected) is used to refine the conjectured locking policy and consequently future fixes. IFIX is evaluated on 43 concurrent programs, and through a user study with 30 programmers. The experiment results and user feedback show that IFIX is efficient, accurate and user-friendly.