With the rapid development of vehicle edge offloading technology, smart device owners' quality of experience (QoE) requirements for computing offloading are gradually increasing. However, some dynamic or uncertain factors in the edge offloading scenario, such as the fluctuating network environment, battery energy consumption and other conditions, will affect users. Based on the multi-armed bandit theory, this paper proposes an adaptive learning algorithm that can dynamically sense environmental changes. Finally, the failure rate and offloading performance of large, medium and small tasks are simulated on the EdgeCloudSim simulation platform. The results show that the proposed algorithm has lower latency and energy consumption performance.

In the ramp merging area, the forced merging behavior of ramp vehicles will lead to the emergency deceleration of vehicles in the main lane, affecting the normal traffic flow. Based on the technical framework of the Internet of Vehicles and edge computing, this paper proposes a ramp merging algorithm for coordinated control of main lane change and speed planning of multilane highways to improve passenger comfort and reduce traffic congestion in the ramp merge area. The research results show that compared with the uncontrolled natural confluence, the algorithm proposed in this paper significantly improved stationary speed and traffic efficiency. At the same time, the vehicle track is optimized, and the ride comfort is enhanced by smoothing the speed curve.

The development of the intelligent transportation system has the potential to improve traffic management considerably. This paper research the car-following control of the autonomous vehicle in high way scenario. The given traditional car-following model does not consider the lateral lane change of the leader vehicle; Besides, the traditional control directly takes the related motion in the platoon of the leader vehicle as the system input of the following vehicle. But this paper combines the lateral and longitudinal movement of the vehicle as to the following control method. In addition, vehicle communication is taken as the way of platoon exchange between vehicles. Therefore, considering the influence of communication delay on the following control of vehicle platoon. The relevant simulation is carried out through Matlab/Simulink.

This paper presents behavior contracts as a new assertion mechanism and a tool that uses such contracts to support the testing of object-oriented (OO) systems. A behavior contract models how the scenarios for performing a designated task are expected to be implemented. Based on this contract, our tool can automatically monitor the program execution for checking important properties related to these scenarios. This capability can help testers to determine whether the scenarios have been implemented correctly. Our tool can also collect test coverage information w.r.t. the scenarios modeled by a behavior contract. Such information can be used to direct the testing efforts towards the less-covered scenarios, and to determine whether the implementation of these scenarios has been adequately tested. Therefore, using this tool should improve both the efficiency and effectiveness of testing OO systems

Use cases often capture the expected behaviors of a system and its components. During requirements analysis, it is important to understand and model the relationship among different use cases. The information of such relationship can guide the design of object collaboration for realizing these use cases. In this paper, we analyze the limitations with the existing approaches for modeling the use-case relationship, and present a new modeling approach that addresses these limitations

UML sequence diagrams are widely used during requirements analysis and design for specifying the expected message exchanges among a set of objects in various scenarios for the program to perform a certain task. In this paper, we present the behavior view diagrams, a type of extended sequence diagrams, to facilitate execution monitoring during debugging. Using a behavior view diagram, software developers can precisely specify the runtime objects whose behaviors will be monitored during debugging. Software developers can also specify the important message exchanges to be observed among these objects during the progress of various scenarios, and may further define the monitoring actions to be performed for inspecting the program state when a message exchange is observed. We also present a debugger that can automatically monitor the program execution using the information specified in a behavior view diagram. Through this monitoring, the debugger can not only check whether the scenarios are progressed as intended, but also check whether the actions performed by the program have the the desired effects on the program states. Therefore, it will be useful for detecting and localizing bugs.

When using tools to automatically generate tests-suites from a specification, the selection of coverage criterion that guides the generation process is of imperative importance. In a previous study that evaluated test generation with model checking, we observed that although a coverage criterion may seem reasonable when instrumenting a model or code to measure the adequacy of a test suite, it may be unsuitable when formalized and used to guide the model checker to generate a test suite; the generated tests technically provide adequate coverage according to the formalization, but do so in a way that exercises only small portions of the system under study and finds few faults. Based on those results, we concluded that fully automated test-suite generation techniques must be pursued with great caution and that coverage criteria specifically addressing test-suite generation from formal specifications are needed. In this report, we attempt to better understand these concerns by evaluating several coverage criteria that bring together aspects from condition and control based criteria. We evaluate the fault finding capability of the criteria on a close to production flight guidance system and discuss the opportunities and challenges that arise from the increased use of fully automated model-based testing.

Program analysis and program optimization of Java programs require reference information that estimates the instances of classes that may be accessed through dereferences. Recent work has presented several approaches for adapting Andersen's algorithm [1]---the most precise flow-insensitive and context-insensitive points-to analysis algorithm developed for C--- for analyzing Java programs (e.g., [5, 9, 12]). Studies in our previous work [6] indicate that this algorithm may compute very imprecise reference information for Java programs.

Program analyses and optimizations of Java programs require reference information that determines the instances that may be accessed through dereferences. Reference information can be computed using reference analysis. This paper presents a set of studies that evaluate the precision of two existing approaches for identifying instances and one approach for computing reference information in a reference analysis. The studies use dynamic reference information collected during run-time as a lower bound approximation to the precise reference information. The studies measure the precision of an existing approach by comparing the information computed using the approach with the lower bound approximation. The paper also presents case studies that attempt to identify the cases under which an existing approach is not effective. The presented studies provide information that may guide the usage of existing reference-analysis techniques and the development of new reference analysis techniques.

In this paper, we present the GAMMA system, which facilitates remote monitoring of deployed software using a new approach that exploits the opportunities presented by a software product being used by many users connected through a network. GAMMA splits monitoring tasks across different instances of the software, so that partial information can be collected from different users by means of light-weight instrumentation, and integrated to gather the overall monitoring information. This system enables software producers (1) to perform continuous, minimally intrusive analyses of their software's behavior, and (2) to use the information thus gathered to improve and evolve their software.

Existing methods for handling pointer variables during dataflow analyses can make such analyses inefficient in both time and space because the data-flow analyses must store and propagate large sets of data facts that are introduced by dereferences of pointer variables. This article presents equivalence analysis , a general technique to improve the efficiency of data-flow analyses in the presence of pointer variables. The technique identifies equivalence relations among the memory locations accessed by a procedure, and ensures that two equivalent memory locations share the same set of data facts in a procedure and in the procedures that are called by that procedure. Thus, a data-flow analysis needs to compute the data-flow information for only a representative memory location in an equivalence class. The data-flow information for other memory locations in the equivalence class can be derived from that of the representative memory location. The article also shows the extension to an interprocedural slicing algorithm that uses equivalence analysis to improve the efficiency of the algorithm. Our empirical studies suggest that equivalence analysis may effectively improve the efficiency of many data-flow analyses.

Regression testing is applied to modified software to provide confidence that the changed parts behave as intended and that the unchanged parts have not been adversely affected by the modifications. To reduce the cost of regression testing, test cases are selected from the test suite that was used to test the original version of the software---this process is called regression test selection. A safe regressiontest -selection algorithm selects every test case in the test suite that may reveal a fault in the modified software. Safe regression-test-selection techniques can help to reduce the time required to perform regression testing because they select only a portion of the test suite for use in the testing but guarantee that the faults revealed by this subset will be the same as those revealed by running the entire test suite. This paper presents the first safe regression-test-selection technique that, based on the use of a suitable representation, handles the features of the Java language. Unlike other safe regression test selection techniques, the presented technique also handles incomplete programs. The technique can thus be safely applied in the (very common) case of Java software that uses external libraries or components

This paper presents extensions to Steensgaard's and Andersen's algorithms to handle Java features. Without careful consideration, the handling of these features may affect the correctness, precision, and efficiency of these algorithms. The paper also presents the results of empirical studies. These studies compare the precision and efficiency of these two algorithms and evaluate the effectiveness of handling Java features using alternative approaches. The studies also evaluate the impact of the points-to information provided by these two algorithms on client analyses that use the information.

To compute accurate information efficiently for programs that use pointer variables, a program analysis must account for the fact that a procedure may access different sets of memory locations when the procedure is invoked under different callsites. This paper presents light-weight context recovery, a technique that can efficiently determine whether a memory location is accessed by a procedure under a specific callsite. The paper also presents a technique that uses this information to improve the precision and efficiency of program analyses. Our empirical studies show that (1) light-weight context recovery can be quite precise in identifying the memory locations accessed by a procedure under a specific call-site and (2) distinguishing memory locations accessed by a procedure under different callsites can significantly improve the precision and the efficiency of program analyses on programs that use pointer variables.

Program slicing, a technique to compute the subset of program statements that can affect the value of a program variable at a specific program point, is widely used in tools to support maintenance activities. To be useful for supporting these activities, a slicing technique must be sufficiently precise and efficient. Harrold and Ci (1998) proposed a method for improving the efficiency of slicing by reusing slicing information for subsequent slicing. This paper presents an interprocedural slicing algorithm that improves the efficiency and precision of Harrold and Ci's algorithm for programs with pointer variables and recursion. Our empirical results show that our improvements can effectively achieve more reuse in slice computation, for programs with pointers, and can significantly reduce the sizes of slices, for programs with recursion.

Existing methods to handle pointer variables during data-flow analyses can make such analyses inefficient both in time and space because the data-flow analyses must store and propagate large sets of data facts that are introduced by dereferences of pointer variable. This paper presents equivalence analysis, a general technique to improve the efficiency of data-flow analyses in the presence of pointers. The technique identifies equivalence relations among the memory locations accessed by a procedure and ensures that two equivalent memory locations share the same set of data facts in a procedure and in the procedures that are called by that procedure. Thus, a data-flow analysis needs to compute the data-flow information only for a representative memory location in an equivalence class. The data-flow information for other memory locations in the equivalence class can be derived from that of the representative memory location. Our empirical studies indicate that equivalence analysis may effectively improve the efficiency of many data-flow analyses.

We present an SDG for object oriented software that is more precise than previous representations and is more efficient to construct than previous approaches. The new SDG distinguishes data members for different objects, provides a way to represent object parameters, represents the effects of polymorphism on parameters and parameter bindings, represents incomplete classes efficiently, and provides a way to represent class libraries. Based on this system dependence graph, we introduce the concept of object slicing and an algorithm to implement this concept. Object slicing enables the user to inspect the statements in the slice, object-by-object, and is helpful for debugging and impact analysis.