Iterators are a fundamental programming abstraction for traversing and modifying elements in containers in mainstream imperative languages such as C++. Iterators provide a uniform access mechanism that hides low-level implementation details of the underlying data structure. However, iterators over mutable containers suffer from well-known hazards including invalidation, aliasing, data races, and subtle side effects. Immutable data structures, as used in functional programming languages, avoid the pitfalls of mutation but rely on a very different programming model based on recursion and higher-order combinators (map, foldl, traverse, etc.) rather than iteration. However, these combinators are not always well-suited to expressing certain algorithms, and recursion can expose implementation details of the underlying data structure. In this paper, we propose persistent iterators---a new abstraction that reconciles the familiar iterator-based programming style of imperative languages with the semantics of persistent data structures. A persistent iterator snapshots the version of its underlying container at creation, ensuring safety against invalidation and aliasing. Iterator operations (++, erase, etc.) operate on the iterator-local copy of the container, giving true value semantics: variables can be rebound to new persistent values while previous versions remain accessible. We implement our approach in the form of LibFpp---a C++ container library providing persistent vectors, maps, sets, strings, and other abstractions as persistent counterparts to the Standard Template Library (STL). Our evaluation shows that LibFpp retains the expressiveness of iterator-based programming, eliminates iterator-invalidation, and achieves asymptotic complexities comparable to STL implementations---albeit with the higher constant-factor overheads of persistence. Our design targets use cases where persistence and safety are desired, while allowing developers to retain familiar iterator-based programming patterns.

Large Language Models (LLMs) have emerged as a promising alternative to traditional static program analysis methods, such as symbolic execution, offering the ability to reason over code directly without relying on theorem provers or SMT solvers. However, LLMs are also inherently approximate by nature, and therefore face significant challenges in relation to the accuracy and scale of analysis in real-world applications. Such issues often necessitate the use of larger LLMs with higher token limits, but this requires enterprise-grade hardware (GPUs) and thus limits accessibility for many users. In this paper, we propose LLM-based symbolic execution —a novel approach that enhances LLM inference via a path-based decomposition of the program analysis tasks into smaller (more tractable) subtasks. The core idea is to generalize path constraints using a generic code-based representation that the LLM can directly reason over, and without translation into another (less-expressive) formal language. We implement our approach in the form of AutoBug , an LLM-based symbolic execution engine that is lightweight and language-agnostic, making it a practical tool for analyzing code that is challenging for traditional approaches. We show that AutoBug can improve both the accuracy and scale of LLM-based program analysis, especially for smaller LLMs that can run on consumer-grade hardware.

With the continuous development of artificial intelligence (AI) technology, AI applications will play an increasingly important role in the sixth generation (6G) networks. At the same time, the emergence of technologies such as cloud computing has led to a growing number of AI models being applied in the Internet-of-Things (IoT). However, increasing sizes of AI models cause heavy burden on networks. In this paper, a multipath transmission scheme for the model slices based on the network function virtualization (NFV) is proposed. First, an optimization problem is formulated to decide the storage nodes for the model slices and the routing. With the physical network resource constraints, the problem is formulated as a mixed integer linear programming (MILP) to minimize the transmission cost. Second, a heuristic algorithm based on the steiner tree problem is designed to solve the optimization problem. Finally, based on the transfer learning method we get one generic slice and two specific slices from VGG16 for simulation. The results show when the destination nodes number and the network size are large, the transmission scheme for model slices has better performance in bandwidth utilization.

This paper investigates the uplink secure transmission in an intelligent reflecting surface (IRS) aided Cell-Free Multiple Input Multiple Output network. To maximize the minimum secrecy rate (SR) among legitimate users, we jointly optimize the uplink power control vector and the passive beamforming vector at IRS with consideration of resource allocation fairness. We propose an alternating optimization based SR max-min fairness algorithm to solve the non-convex problem. Based on semidefinite relaxation, the sub-problem of phase optimization at IRS is solved. Geometric programming is utilized to handle the optimization of power control with the assist of condensation method. Simulation results verify that the proposed algorithm can converge to obtain the solution. The minimum SR of the proposed scheme is increased by 14% compared with random phase scheme and the max-min fairness among users is realized.