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