Home Latest Articles
Latest Articles
  • Zhen Dong, Dehui Du, Min Zhang, Tao Yue, Peng Liang
    Journal of Computer Research and Development. 2026, 63(5): 1095-1096.
  • Chunhui Wang, Jiaqi Zhao, Xiaohong Chen, Zhi Jin
    Journal of Computer Research and Development. 2026, 63(5): 1097-1116.

    The embedded system requirements specification serves as the cornerstone of system development, playing a crucial role in transforming high-level user intentions into clear and executable software requirements. Currently, this process remains highly dependent on manual derivation and composition by domain experts, with inherent limitations such as low efficiency and insufficient interpretability. Although automated requirements generation is regarded as a potential solution, its development still faces two core challenges: how to effectively embed domain-specific device knowledge, and how to strictly adhere to the standards of intent satisfiability and traceability to construct an interpretable requirements system. To address these issues, we propose an interpretable requirements specification method based on large language models (LLMs). By constructing a prompt chain that integrates domain knowledge and requirements engineering, our method gradually complements and refines user intentions into device, system, and software requirements level by level under human-computer interaction collaboration, ensuring the satisfiability of requirements. Additionally, it introduces the problem diagram and scenario diagram model to guarantee the traceability of requirements. Experiments on four embedded system cases show that compared with manual methods, our method reduces time cost by approximately 73% and improves the quality of requirements specification documents by 82%. Moreover, its interpretability increases by about 15% and 21% compared with both manual methods and single-step LLM methods, providing an efficient and reliable new approach for requirements specification of complex embedded systems.

  • Zhengkang Zuo, Xiaoying Zhu, Zhen You, Changjing Wang
    Journal of Computer Research and Development. 2026, 63(5): 1117-1138.

    Search tree algorithms are widely used in areas such as database indexing, compiler design, and file systems, where the functional correctness of these algorithms is a critical factor in ensuring software reliability. However, traditional development process faces two major challenges: first, algorithm design often lacks rigorous mathematical modeling, causing correctness verification to remain at an empirical level; second, existing verification approaches heavily rely on manual or interactive theorem proving, making the verification complexity grow exponentially with increasing algorithm scale. To address the above issues, an Isabelle-driven method for modeling and automated verification of search tree algorithms is proposed. This method builds on a formally verified functional modeling library to construct a modular modeling strategy that supports various search tree structures, and introduces a formal specification-driven framework for automatically synthesizing algorithmic code. Developers are required to supply only minimal functional expressions to complete the implementation. In addition, a reusable lemma library has been developed to support an automated block-wise verification strategy, significantly reducing verification costs. Furthermore, a method for generating functional executable programs is proposed. Experimental evaluation using a representative case study demonstrates that the proposed method substantially reduces verification costs. Compared with interactive verification approaches, the average reductions in code size and manual effort are 88.60% and 61.51%, respectively; compared with generative AI plus interactive verification methods, the average reductions in code size and manual effort are 88.09% and 41.76%, respectively. Overall, the proposed framework provides a systematic and highly automated solution for the formal verification of complex data structure algorithms in specific domains, while also offering a feasible pathway and methodological support for generating correct functional executable programs.

  • Zhengkang Zuo, Chao Zhou, Yuhan Ke, Zhen You, Changjing Wang
    Journal of Computer Research and Development. 2026, 63(5): 1139-1157.

    The priority search tree (PST) is a data structure that combines the characteristics of search trees and priority queues, enabling efficient retrieval of high-priority elements while maintaining worst-case search efficiency comparable to that of search trees. Nipkow et al. further modeled and mechanized the verification of PST with a static priority mechanism, laying an important foundation for its formal analysis and subsequent theoretical exploration. However, static priority mechanisms can lead to degraded performance under highly skewed access distributions, limiting their applicability in practice. To overcome this limitation, a functional adaptive priority search tree (FAPST) is proposed. FAPST adopts dynamic priority adjustment based on access frequency and is formally modeled and verified at the formal level to ensure functional correctness and reliability. This structure preserves balance and worst-case efficiency while adaptively responding to access patterns, thereby significantly improving the retrieval of frequently accessed elements. To further address the shifting nature of data hotspots in practical scenarios, a hotspot migration mechanism is introduced. This mechanism incorporates a priority decay strategy to accelerate responses to emerging hotspots and mitigate the stagnation of outdated ones. Experimental results demonstrate that, in both access-sensitive and hotspot-shifting workloads, the formally verified FAPST achieves notable reductions in the number of key function calls of 64.8% and 46.3% respectively, compared with conventional PSTs.

  • Jiahao Zhu, Zichao Wei, Jingyi Guo, Ming Wen, Hai Jin
    Journal of Computer Research and Development. 2026, 63(5): 1158-1176.

    Graph neural networks (GNNs) and code pre-trained models (CodePTMs) have been widely applied in vulnerability detection tasks, achieving the state-of-the-art (SOTA) performance on vulnerability benchmark datasets. However, such datasets (denoted as regular datasets) commonly collect vulnerable and non-vulnerable samples from different sources, resulting in significantly divergent code characteristics. Consequently, existing learning models tend to capture spurious features specific to certain datasets, rather than understanding the actual root causes of vulnerabilities. A robust and reliable vulnerability detection model should be able to make pairwise predictions, that is, recognizing the vulnerable code as vulnerable while the corresponding fixed version as non-vulnerable. However, the capability of existing learning models to make such pairwise predictions is significant and has not been explored extensively. Specifically, we first construct a large-scale real-world dataset containing vulnerable code and the corresponding fixed version. This ensures that positive and negative samples are derived from the same source, thus forming similar distributions in terms of code characteristics. We then evaluate eight mainstream SOTA vulnerability detection models in the rigorous setting to see if they can distinguish vulnerable code from its fixed versions (i.e., paired vulnerability instances). Our results reveal that all models perform poorly in making pairwise predictions when trained on regular datasets. We also find that retraining with these paired instances can improve the models’ performance by 17% on average. Furthermore, we highlight the limitations of existing CodePTMs in aggregating local code information (i.e., a key statement concerning vulnerable semantics). Driven by our findings, we devise a new approach and the evaluation results demonstrate that it outperforms the SOTA model UniXcoder by 58.47% towards making pairwise predictions.

  • Quan Zhang, Juexiao Feng, Chijin Zhou, Yu Jiang
    Journal of Computer Research and Development. 2026, 63(5): 1177-1190.

    The evolution of large language models (LLMs) and Model Context Protocol (MCP) has facilitated the development of various MCP servers and tools that extend LLM capabilities, allowing LLMs to interact with external services and content. However, these servers also introduce new security threats. Specifically, they are granted privileges to automate tasks such as email processing and cloud infrastructure management. Due to the inherent instability of LLM outputs and their susceptibility to manipulation, attackers can exploit LLMs to illicitly invoke these tools, causing severe damage. Therefore, the analysis and control of privileges for LLM servers are of paramount importance. This research designs an automated analysis framework to analyze MCP servers and their associated tools. Through static analysis, the framework identifies the privileged APIs called by these tools and their invocation methods. It then categorizes these privileges based on their sensitivity and corresponding behaviors to investigate the current state of privilege usage. We collect 1609 MCP servers and conduct a detailed analysis of 200, revealing that each server requests an average of 40.74 privileged APIs. Furthermore, a significant 52% of these privilege validations rely on API Tokens and passwords, which fail to adhere to the principle of least privilege. This study calls for developers to implement stricter privilege controls for MCP servers and actively explore more secure authorization mechanisms.

  • Ziwei Huang, Yiqi Yao, Yungang Bao, Sa Wang
    Journal of Computer Research and Development. 2026, 63(5): 1191-1208.

    Improving resource utilization is important for cloud service providers to achieve cost reduction and efficiency, as the cost of construction and operating costs in datacenters are extremely high. However, existing metrics such as benchmarks are often scenario-specific and lack adaptability. Some metrics, such as simulated or pre-execution solutions are struggle to cope with sudden workload fluctuations. Therefore, cloud service providers urgently require a real-time performance metric for monitoring performance and managing resources. Existing real-time metrics often rely on software or hardware support, and most fail to accurately identify resource bottlenecks. To address this challenge, we propose KFCMetric (metric based on kernel function call frequencies), a performance metric based on the frequency of kernel function calls. KFCMetric employs static kernel analysis techniques to generate kernel function call graphs and utilizes a random forest algorithm to select kernel functions that exhibit a strong correlation with application performance and resource status. The behavior of these kernel can dynamically reflect the runtime resource state of applications and accurately pinpoint the root causes of performance bottlenecks. Building on KFCMetric, we further introduce a resource management system, KFCSys. Using dynamic kernel instrumentation techniques, KFCSys captures the calls and returns of these kernel functions and uses a variance-based scaling algorithm to measure the deviation of data points from normal. Based on the real-time status of latency-critical applications, KFCSys dynamically adapts resource allocation to meet the resource requirements of latency-critical applications, ensuring their service quality. Experimental results indicate that KFCMetric achieves an accuracy of 96.7% in detecting resource bottlenecks, and its interference detection accuracy shows up to a 31.4% improvement over CPI. In terms of resource management, KFCSys reduces the average tail latency by up to 30.4% compared with PARTIES, and by 40.7% compared with the standard Linux resource management system. Moreover, KFCSys decreases the proportion of performance violation time by 10% relative to PARTIES. Therefore, in scenarios where hardware or software support is not available, KFCMetric, constructed from kernel function features, is a novel and robust performance metric for performance monitoring and resource management.

  • Chaoyang Jia, Shi Chen, Jingyu Liu, Li Shen
    Journal of Computer Research and Development. 2026, 63(5): 1209-1223.

    With the continuous advancement of computer hardware and software, graph computing has been widely applied in many fields, including social network analysis, recommendation systems, bioinformatics, and fraud detection. The memory access behavior in graph computing is highly variable: different kernels accessing property arrays exhibit different spatial locality when graph computing is executed on a GPU, and the same kernel shows varying spatial locality across different property arrays. Existing cache optimization strategies in GPU architectures fail to enhance the performance of graph computing effectively. State-of-the-art cache optimization strategies cannot implement distinct management strategies for data with different reusability, which is an essential reason for the poor performance of graph computing. To address this, AB-Cache architecture is proposed, specifically designed for GPU platforms. AB-Cache adopts an adaptive approach that utilizes two cache structures to optimize memory access requests with different spatial locality characteristics. An online automatic classification mechanism compatible with AB-Cache architecture is also proposed, enabling fast classification of memory access requests with different spatial locality with minimal overhead. Comprehensive evaluations across multiple graph computing applications and a wide range of graph datasets show that AB-Cache scheme achieves a 1.14 times speedup over the baseline, demonstrating its effectiveness and practicality in optimizing graph computing performance.

  • Ziwei Deng, Wei Guo, Yaming Xu, Qing Wang, Deshan Zhang, Shengcai Lu, Tao Liu
    Journal of Computer Research and Development. 2026, 63(5): 1224-1237.

    The three-dimensional fast Fourier transform (3D-FFT) algorithm serves as a fundamental computing kernel for numerous high performance computing (HPC) applications, where its efficient implementation critically determines the overall system performance. We propose a heterogeneous computing architecture leveraging CPU-FPGA co-processing to address the performance bottlenecks in conventional 3D-FFT implementations, including inefficient memory access patterns, procedural redundancy, and limited parallelization capabilities. Three key architectural innovations are introduced: 1) a hierarchical data management strategy enabling multi-channel data transmission with optimized bandwidth utilization; 2) a pipelined synchronization mechanism that overlaps matrix transpose operations with FFT computation; 3) a scalable parallel computation architecture supporting up to 128 concurrent FFT processing units. Experimental evaluations demonstrate significant performance improvements of 3D-FFT for common scientific computing scenarios involving 643 and 1283 matrices. Compared with CPU-only solutions, the proposed architecture achieves computation time reductions of 62.7% and 56.6% for 643 and 1283 matrices, respectively. When compared with existing FPGA-accelerated 3D-FFT implementations, the proposed design exhibits performance enhancements of 32.6% and 35.3% for the corresponding matrix sizes. These results validate our architecture’s effectiveness in optimizing memory utilization, improving task synchronization efficiency and enhancing computational parallelism. The solution provides a scalable and energy-efficient acceleration architecture for HPC systems requiring large-scale 3D-FFT computations, particularly in scenarios demanding high throughput and low latency.

  • Dongyang Li, Zeyang Li, Yibin Tang, Bosheng Liu, Jigang Wu
    Journal of Computer Research and Development. 2026, 63(5): 1238-1248.

    Hybrid bit-width block floating point (BFP) offers a flexible solution for low bit-width convolution computations, optimizing storage efficiency and computational precision. By assigning higher bit-widths to numerically sensitive layers while using lower bit-widths for redundant or stable regions, this approach preserves near-floating-point accuracy with substantially reduced computational and storage cost. Recent researches have deployed hardware solutions such as field programmable gate arrays (FPGAs) for hybrid bit-width BFP-based convolution accelerations, but they tend to underutilize FPGA resources by overlooking the full potential of digital signal processors (DSPs). Specifically, the underutilization of DSPs often leads to unnecessary resource waste and limited computational throughput, which restricts the overall performance of FPGA-based BFP convolution accelerators. This work develops a novel FPGA-based BFP convolution processing unit, termed “BE-HB”, capable of coupling two sets of BFP convolution calculations in dual-mode bit-width (i.e., 8 b or 16 b) using a single DSP for high performance. We then introduce a novel mapping method that reuses the shared exponents and private mantissas of BFP representations to perform two sets of BFP convolution computations within 8 b or 16 b DSP data paths. By leveraging the exponent sharing, data packing and data reuse, the proposed approach significantly reduces hardware resource overhead. Compared with representative baseline designs, the proposed design achieves an average reduction of 61.4% in LUT utilization while maintaining model accuracy, thereby delivering superior performance and resource efficiency, which makes it more suitable for resource-constrained FPGA-based edge computing platforms.