Thread Pool Research Articles

Modular Termination Verification of Single-Threaded and Multithreaded Programs

We propose an approach for the modular specification and verification of total correctness properties of object-oriented programs. The core of our approach is a specification style that prescribes a way to assign a level expression to each method such that each callee’s level is below the caller’s, even in the presence of dynamic binding. The specification style yields specifications that properly hide implementation details. The main idea is to use multisets of method names as levels, and to associate with each object levels that abstractly reflect the way the object is built from other objects. A method’s level is then defined in terms of the method’s own name and the levels associated with the objects passed as arguments. We first present the specification style in the context of programs that do not modify object fields. We then combine it with separation logic and abstract predicate families to obtain an approach for programs with heap mutation. In a third step, we address concurrency, by incorporating an existing approach for verifying deadlock freedom of channels and locks. Our main contribution here is to achieve information hiding by using the proposed termination levels for lock ordering as well. Also, we introduce call permissions to enable elegant verification of termination of programs where threads cause work in other threads, such as in thread pools or fine-grained concurrent algorithms involving compare-and-swap loops. We explain how our approach can be used also to verify the liveness of nonterminating programs.

Five ways to insert concurrency to a program written in C#

Nowadays processors working in personal computers and mobile devices allow for more and more effective parallel computing. Developers have at their disposal many different methods of implementing concurrency, but usually use the one, that they now best. It is beneficial to know, when a particular technique is good and when it is better to find an alternative. This paper presents different ways of implementing parallel mathematical calculations using threads, tasks, thread pool, task pool and parallel for loop. Each method was used in a C# application running on Windows Presentation Foundation engine on .NET platform. Implemented operation is calculation value of Pi using Leibnitz’s formula.

Dynamic Tuning and Overload Management of Thread Pool System

Distributed applications have been developed using thread pool system (TPS) in order to improve system performance. The dynamic optimization and overload management of TPS are two crucial factors that affect overall performance of distributed thread pool (DTP). This paper presents a DTP, that is based on central management system, where a central manager forwards client’s requests in round robin fashion to available set of TPSs running in servers. The dynamic tuning of each TPS is done based on request rate on the TPS. The overload condition at each TPS is detected by the TPS itself, by throughput decline. The overload condition is resolved by reducing the size of thread pool to previous value, at which it was producing throughput parallel to the request rates. By reducing the size of thread pool on high request rates, the context switches and thread contention overheads are eliminated that enables system resources to be utilized effectively by available threads in the pool. The result of evaluation proved the validity of proposed system.

Design and Implementation of E-Commerce Platform Based on Android

This paper introduces the basic functions of the e-commerce system implemented on Android, including user management functions, product search functions, product browsing functions, and product tracking functions, etc. It is necessary to use technologies in Android in order to implement each module function. For example, network communication requires Android’s network request technology and data analysis technology. The display of pictures requires the use of Android controls and cache technology. The traceability of products requires camera scanning technology. And RSA decryption technology and so on. Through the above thread pool technology and the use of caching mechanism, the user experience of UI will be improved and unnecessary network resources consumption will be avoided.

Experimental evaluation of improved IoT middleware for flexible performance and efficient connectivity

We previously proposed an Internet of Things (IoT) middleware called Middleware for Cooperative Interaction of Things (MinT). MinT supports thread pooling to quickly process requests from other IoT devices. However, using a thread pool with a fixed number of threads equal to the number of CPU cores can waste memory and CPU resources, and degrade the performance of the IoT device. In this paper, we propose an enhanced approach called Improved MinT (MinT-I) to efficiently improve the performance of MinT middleware by real-time adjustment of threads. We aim to improve the performance of the connection part, which is responsible for analyzing, processing, and retransmitting the received packets. The experimental results showed that MinT-I increased the average throughput by approximately 25% to 35% compared to the existing middleware. Moreover, the proposed MinT-I not only can optimize the memory and resource usage, but it can also reduce the latency and power consumption of IoT devices.

A programming framework for data streaming on the Xeon Phi

ALICE (A Large Ion Collider Experiment) is the dedicated heavy-ion detector studying the physics of strongly interacting matter and the quark-gluon plasma at the CERN LHC (Large Hadron Collider). After the second long shut-down of the LHC, the ALICE detector will be upgraded to cope with an interaction rate of 50 kHz in Pb-Pb collisions, producing in the online computing system (O2) a sustained throughput of 3.4 TB/s. This data will be processed on the fly so that the stream to permanent storage does not exceed 90 GB/s peak, the raw data being discarded. In the context of assessing different computing platforms for the O2 system, we have developed a framework for the Intel Xeon Phi processors (MIC). It provides the components to build a processing pipeline streaming the data from the PC memory to a pool of permanent threads running on the MIC, and back to the host after processing. It is based on explicit offloading mechanisms (data transfer, asynchronous tasks) and basic building blocks (FIFOs, memory pools, C++11 threads). The user only needs to implement the processing method to be run on the MIC. We present in this paper the architecture, implementation, and performance of this system.

Design and implementation of online automatic judging system

For lower efficiency and poorer reliability in programming training and competition by currently artificial judgment, design an Online Automatic Judging (referred to as OAJ) System. The OAJ system including the sandbox judging side and Web side, realizes functions of automatically compiling and running the tested codes, and generating evaluation scores and corresponding reports. To prevent malicious codes from damaging system, the OAJ system utilizes sandbox, ensuring the safety of the system. The OAJ system uses thread pools to achieve parallel test, and adopt database optimization mechanism, such as horizontal split table, to improve the system performance and resources utilization rate. The test results show that the system has high performance, high reliability, high stability and excellent extensibility.

Bit Register Based Algorithm for Thread Pool Management

Bit Register Based Algorithm for Thread Pool Management

Segmentation Method for Magnetic Resonance-Guided High-Intensity Focused Ultrasound Therapy Planning.

High-intensity focused ultrasound (HIFU) is a minimally invasive therapy modality in which ultrasound beams are concentrated at a focal region, producing a rise of temperature and selective ablation within the focal volume and leaving surrounding tissues intact. HIFU has been proposed for the safe ablation of both malignant and benign tissues and as an agent for drug delivery. Magnetic resonance imaging (MRI) has been proposed as guidance and monitoring method for the therapy. The identification of regions of interest is a crucial procedure in HIFU therapy planning. This procedure is performed in the MR images. The purpose of the present research work is to implement a time-efficient and functional segmentation scheme, based on the watershed segmentation algorithm, for the MR images used for the HIFU therapy planning. The achievement of a segmentation process with functional results is feasible, but preliminary image processing steps are required in order to define the markers for the segmentation algorithm. Moreover, the segmentation scheme is applied in parallel to an MR image data set through the use of a thread pool, achieving a near real-time execution and making a contribution to solve the time-consuming problem of the HIFU therapy planning.

Parallel satellite orbital situational problems solver for space missions design and control

Solving different scientific problems for space applications demands implementation of observations, measurements or realization of active experiments during time intervals in which specific geometric and physical conditions are fulfilled. The solving of situational problems for determination of these time intervals when the satellite instruments work optimally is a very important part of all activities on every stage of preparation and realization of space missions.The elaboration of universal, flexible and robust approach for situation analysis, which is easily portable toward new satellite missions, is significant for reduction of missions’ preparation times and costs.Every situation problem could be based on one or more situation conditions. Simultaneously solving different kinds of situation problems based on different number and types of situational conditions, each one of them satisfied on different segments of satellite orbit requires irregular calculations.Three formal approaches are presented. First one is related to situation problems description that allows achieving flexibility in situation problem assembling and presentation in computer memory. The second formal approach is connected with developing of situation problem solver organized as processor that executes specific code for every particular situational condition. The third formal approach is related to solver parallelization utilizing threads and dynamic scheduling based on “pool of threads” abstraction and ensures a good load balance.The developed situation problems solver is intended for incorporation in the frames of multi-physics multi-satellite space mission’s design and simulation tools.

웹 응용 서비스에서 성능 분석을 위한 실험적인 평가 기법

The performance of a web application is an essential issue to provide high quality of the services in interactive web environments. On a sudden increase in traffic in a very short span of time, the servers became CPU starved and would become unresponsive. This would lead to a bad experience for the clients of web service. This paper deals with the effects of two configurable software settings of J2EE application servers: the maximum size of the thread pool and the maximum size of database connection pool. In order to figure out the optimum configuration value, this paper builds experimental evaluation method for web performance analysis. Finally, a case study related with the proper experimental method is presented with performance result.

Parallel Quick Sort using Thread Pool Pattern

Sorting algorithms, their implementations and their applications in modern computing necessitates improvements for sorting large data sets quickly and efficiently. This paper will analyze the performance of a multi-threaded quick sort implemented using the thread pool pattern. The analysis will be done by comparing the time required to sort various data sets and their memory constraints, against the native sorting implementations of the Dual Pivot Quicksort and Merge Sort using the Fork-Join framework in the Oracle Java 8 programming language. Analysis is done of the effect of different number of processor (cores) of the test machine, as well as the performance barrier due to the initial time taken to create “p” threads, p being the number of processors. This paper also analyzes the limitations of the inbuilt Java method Arrays.parallelSort() and how the proposed system overcomes this problem. Finally, it also discuss possible improvements to the proposed system to further improve its performance.

PARSECSs

In this work, we show how parallel applications can be implemented efficiently using task parallelism. We also evaluate the benefits of such parallel paradigm with respect to other approaches. We use the PARSEC benchmark suite as our test bed, which includes applications representative of a wide range of domains from HPC to desktop and server applications. We adopt different parallelization techniques, tailored to the needs of each application, to fully exploit the task-based model. Our evaluation shows that task parallelism achieves better performance than thread-based parallelization models, such as Pthreads. Our experimental results show that we can obtain scalability improvements up to 42% on a 16-core system and code size reductions up to 81%. Such reductions are achieved by removing from the source code application specific schedulers or thread pooling systems and transferring these responsibilities to the runtime system software.

Java SDK를 이용한 파일 클라우드 시스템의 설계 및 구현

클라우드 컴퓨팅은 IT 관련된 기능들이 서비스 형태로 제공되는 컴퓨팅 스타일이다. 사용자들은 전문 지식이 없거나 제어할 줄 몰라도 인터넷으로부터 서비스를 이용할 수 있다. 정보가 인터넷 상의 서버에 영구적으로 저장되고 데스크탑 컴퓨터, 노트북, 휴대용 기기 등과 같은 클라이언트에는 일시적으로 보관된다. 이러한 클라우드 컴퓨팅에서 소프트웨어와 데이터는 서버에 저장된다. 클라우드 컴퓨팅은 웹 2.0, SaaS(software as a service)와 같이 최근 잘 알려진 기술 경향들과 연관성을 가지는 일반화된 개념이다. 이들 개념들의 공통점은 사용자들의 컴퓨팅 요구를 만족시키기 위해 인터넷을 이용한다는 사실이다. 이는 단순히 서버 등의 자원을 제공해 주면서 사용자가 디바이스에 제약없이 데이터에 접근할 수 있도록 해준다. 개인적인 용도의 파일을 저장하고 이를 여러 디바이스에서 공유하는 클라우드 서비스가 주목을 받고 있다. 본 논문에서는 Dropbox와 OAuth, PACloud를 통해 이와 같은 서비스를 구현할 수 있다. 또한 스레드 폴링을 이용하여 서버에 들어오는 여러 태스크들을 적절하게 처리할 수 있는 구현 기술을 제시하였다. 아울러 구현 기술을 설명하기 위해 소프트웨어 공학적인 여러 다이어그램을 제시하였다. Cloud computing is a computing term that evolved in the late 2000s, based on utility and consumption of computer resources. Google say that "Cloud computing involves deploying groups of remote servers and software networks that allow different kinds of data sources be uploaded for real time processing to generate computing results without the need to store processed data on the cloud. Cloud computing relies on sharing of resources to achieve coherence and economies of scale, similar to a utility (like the electricity grid) over a network. At the foundation of cloud computing is the broader concept of converged infrastructure and shared services. Cloud computing, or in simpler shorthand just "the cloud", also focuses on maximizing the effectiveness of the shared resources." The cloud service is a smart and/or intelligent service to save private files in any device, anytime, anywhere. Dropbox, OAuth, PAClous are required that the accumulated user's data are archives with cloud service. Currently we suggest an implementation technique to process many tasks to the cloud server with a thread pooling. Thread pooling is one of efficient implementating technique for client and service environment. In this paper, to present the implementation technique we suggest three diagrams in the consideration of software engineering.

Understanding energy behaviors of thread management constructs

Java programmers are faced with numerous choices in managing concurrent execution on multicore platforms. These choices often have different trade-offs (e.g., performance, scalability, and correctness guarantees). This paper analyzes an additional dimension, energy consumption. It presents an empirical study aiming to illuminate the relationship between the choices and settings of thread management constructs and energy consumption. We consider three important thread management constructs in concurrent programming: explicit thread creation, fixed-size thread pooling, and work stealing. We further shed light on the energy/performance trade-off of three ``tuning knobs'' of these constructs: the number of threads, the task division strategy, and the characteristics of processed data. Through an extensive experimental space exploration over real-world Java programs, we produce a list of findings about the energy behaviors of concurrent programs, which are not always obvious. The study serves as a first step toward improving energy efficiency of concurrent programs on parallel architectures.

Depth-Based Selective Blurring in Stereo Images Using Accelerated Framework

We propose a hybrid method for stereo disparity estimation by combining block and region-based stereo matching approaches. It generates dense depth maps from disparity measurements of only 18 % image pixels (left or right). The methodology involves segmenting pixel lightness values using fast K-Means implementation, refining segment boundaries using morphological filtering and connected components analysis; then determining boundaries' disparities using sum of absolute differences (SAD) cost function. Complete disparity maps are reconstructed from boundaries' disparities. We consider an application of our method for depth-based selective blurring of non-interest regions of stereo images, using Gaussian blur to de-focus users' non-interest regions. Experiments on Middlebury dataset demonstrate that our method outperforms traditional disparity estimation approaches using SAD and normalized cross correlation by up to 33.6 % and some recent methods by up to 6.1 %. Further, our method is highly parallelizable using CPU and GPU framework based on Java Thread Pool and APARAPI with speed-up of 5.8 for 250 stereo video frames (4,096 x 2,304).

TaskLocalRandom: a statistically sound substitute to pseudorandom number generation in parallel java tasks frameworks

SummarySeveral software efforts have been produced over the past few years in various programming languages to help developers handle pseudorandom streams partitioning. Parallel and distributed stochastic simulations can obviously benefit from this kind of high‒level tools. The latest release of the Java Development Kit (JDK 7) tries to tackle this problem by providing facilities to partition a pseudorandom stream across various threads thanks to the new class ThreadLocalRandom. Meanwhile, Java 7 offers a framework to split a problem in a divide and conquer way through the new class called ForkJoinPool. As any other Java thread pool, ForkJoin exploits threads as workers and manipulates the tasks that will be run on the workers. In ThreadLocalRandom, pseudorandom number generation is handled at a thread level. As a consequence, a scientific application taking advantage of a Java thread pool to parallelize its computation may suffer from a bad pseudorandom stream partitioning due to the behavior of ThreadLocalRandom. The present work introduces TaskLocalRandom, a task‒level alternative to ThreadLocalRandom that solves this partitioning problem and assigns an independent pseudorandom stream to each task run in the thread pool. TaskLocalRandom is compatible with existing Java thread pools such as Executors or ForkJoin. Copyright © 2014 John Wiley & Sons, Ltd.

Asynchronous Data Access and Transaction Decomposition in Distributed Databases

A RDBMS is usually accessed using blocking drivers like JDBC/ODBC which require clients to block and wait for the result of each query they issue. An asynchronous database access mechanism would eliminate the need for such blocking and greatly improve client performance. Thread-Per-Connection and Thread Pooling are two methods currently being used to provide this asynchrony. These methods require the use of multiple threads in the database server, which provides the clients with access to the database. This is inefficient since a lot of memory and computing power is spent in creating, scheduling and switching multiple threads. In this paper, we show how asynchronous database access can be achieved with a single thread using the Fork-Join mechanism which employs Future objects in Java. We also show how Asynchronous Transaction Decomposition in distributed databases can help improve client performance. Keywords: Asynchronous, Transaction Decomposition, Future objects, Fork-Join

GPU code generation for ODE-based applications with phased shared-data access patterns

We present a novel code generation scheme for GPUs. Its key feature is the platform-aware generation of a heterogeneous pool of threads. This exposes more data-sharing opportunities among the concurrent threads and reduces the memory requirements that would otherwise exceed the capacity of the on-chip memory. Instead of the conventional strategy of focusing on exposing as much parallelism as possible, our scheme leverages on the phased nature of memory access patterns found in many applications that exhibit massive parallelism. We demonstrate the effectiveness of our code generation strategy on a computational systems biology application. This application consists of computing a Dynamic Bayesian Network (DBN) approximation of the dynamics of signalling pathways described as a system of Ordinary Differential Equations (ODEs). The approximation algorithm involves (i) sampling many (of the order of a few million) times from the set of initial states, (ii) generating trajectories through numerical integration, and (iii) storing the statistical properties of this set of trajectories in Conditional Probability Tables (CPTs) of a DBN via a prespecified discretization of the time and value domains. The trajectories can be computed in parallel. However, the intermediate data needed for computing them, as well as the entries for the CPTs, are too large to be stored locally. Our experiments show that the proposed code generation scheme scales well, achieving significant performance improvements on three realistic signalling pathways models. These results suggest how our scheme could be extended to deal with other applications involving systems of ODEs.

GPU code generation for ODE-based applications with phased shared-data access patterns

We present a novel code generation scheme for GPUs. Its key feature is the platform-aware generation of a heterogeneous pool of threads. This exposes more data-sharing opportunities among the concurrent threads and reduces the memory requirements that would otherwise exceed the capacity of the on-chip memory. Instead of the conventional strategy of focusing on exposing as much parallelism as possible, our scheme leverages on the phased nature of memory access patterns found in many applications that exhibit massive parallelism. We demonstrate the effectiveness of our code generation strategy on a computational systems biology application. This application consists of computing a Dynamic Bayesian Network (DBN) approximation of the dynamics of signalling pathways described as a system of Ordinary Differential Equations (ODEs). The approximation algorithm involves (i) sampling many (of the order of a few million) times from the set of initial states, (ii) generating trajectories through numerical integration, and (iii) storing the statistical properties of this set of trajectories in Conditional Probability Tables (CPTs) of a DBN via a prespecified discretization of the time and value domains. The trajectories can be computed in parallel. However, the intermediate data needed for computing them, as well as the entries for the CPTs, are too large to be stored locally. Our experiments show that the proposed code generation scheme scales well, achieving significant performance improvements on three realistic signalling pathways models. These results suggest how our scheme could be extended to deal with other applications involving systems of ODEs.