Research on software defect predict model based on JCUDA_BP algorithm

Chun Shan, Lei Dong, Changzhen Hu, Liang Zhang, Jingfeng Xue2015 · DOI

Abstract

For the long time computation and the poor learning effect in application of BP algorithm in software defect predict model, an improved BP algorithm is presented in this paper. The improved algorithm combines the JCUDA technology and the BP algorithm, by learning the sample decomposition, multithreading and CPU-GPU processing mode, both learning speed and predicting time are optimized for the software defect predict model based on BP algorithm. The experimental results show that the improved JCUDA_BP algorithm optimizes the learning process, especially for the larger samples. Also, when the hidden node number reaches a certain number, the effect of the optimized algorithm is much better than the traditional BP algorithm.

Introduction

Software defects significantly impact system reliability and functionality. Predicting these defects early in the development lifecycle allows for more efficient resource allocation during testing. The Backpropagation (BP) neural network is a standard tool for this task; however, it faces significant challenges when applied to large-scale software repositories. Specifically, traditional CPU-based implementations suffer from long computation times and memory overflow issues, often leading to "learning failure" as dataset complexity increases. This research proposes JCUDA_BP, an accelerated algorithm that leverages GPU parallel computing to overcome these bottlenecks.

Methodology: The JCUDA_BP Framework

The JCUDA_BP algorithm integrates Java with NVIDIA’s CUDA platform to offload computationally intensive tasks to the GPU. The core of this approach is a collaborative CPU-GPU processing mode designed to maximize hardware utilization.

The process begins with sample decomposition, where the CPU divides the input data into smaller groups. These groups are then processed in parallel across multiple GPU threads. A critical component of this architecture is the Monitor Thread. This thread runs on the CPU and continuously tracks the progress of individual GPU threads. If a thread fails to meet accuracy thresholds or hangs, the monitor triggers a restart or weight adjustment, ensuring the robustness of the final model.

Collaborative CPU-GPU processing architecture of the JCUDA_BP algorithm.

Experimental Setup and Datasets

To evaluate the performance of JCUDA_BP, the researchers utilized the NASA MDP (Metric Data Program) dataset. Twelve subsets were tested, ranging from the small MC2 dataset (127 samples) to the large PC5 dataset (17,001 samples). This diversity allowed for a comprehensive analysis of how the algorithm scales with data volume.

Key Results and Discussion

The experimental results highlight a clear performance "crossover point." While GPUs introduce a startup latency that can make them slower for very small datasets (e.g., CM1 and MC2), they demonstrate significant advantages as data volume and model complexity increase.

As shown in the performance data, the JCUDA_BP algorithm achieved its highest optimization ratio of 21% on the largest dataset, PC5. For datasets exceeding 1,000 samples, the optimization ratio consistently ranged between 13% and 21%.

Comparison of CPU and GPU computation times across various NASA MDP datasets.

Furthermore, the study tested the impact of neural network complexity by increasing the number of hidden nodes. At 32,768 hidden nodes, the GPU runtime was approximately 628 seconds, compared to 740 seconds for the CPU. This confirms that JCUDA_BP is particularly effective for deep-dive analysis where traditional CPU-based Java environments might encounter memory limits or excessive processing times.

Conclusion

The JCUDA_BP algorithm successfully addresses the computational bottlenecks of traditional BP models in software defect prediction. By leveraging parallel processing and a collaborative CPU-GPU architecture, it provides a scalable solution for large datasets. Future research should explore the application of this framework to modern, massive open-source repositories and compare its performance against other GPU-accelerated machine learning techniques.

Summary updated

Abstract

For the long time computation and the poor learning effect in application of BP algorithm in software defect predict model, an improved BP algorithm is presented in this paper. The improved algorithm combines the JCUDA technology and the BP algorithm, by learning the sample decomposition, multithreading and CPU-GPU processing mode, both learning speed and predicting time are optimized for the software defect predict model based on BP algorithm. The experimental results show that the improved JCUDA_BP algorithm optimizes the learning process, especially for the larger samples. Also, when the hidden node number reaches a certain number, the effect of the optimized algorithm is much better than the traditional BP algorithm.
BibTeX
@misc{shan2015research,
  author = {Chun Shan and Lei Dong and Changzhen Hu and Liang Zhang and Jingfeng Xue},
  title = {{Research on software defect predict model based on JCUDA\_BP algorithm}},
  year = {2015},
  doi = {10.2991/ameii-15.2015.114},
}
Figure