Hybrid techniques for early mitigation of platform software migration risks

By employing a hybrid technology combining static code analysis and dynamic behavior detection, OEMs can identify platform software changes early, resolving codebase migration issues under confidentiality agreements and improving software integration efficiency and competitiveness.

CN119053948APending Publication Date: 2024-11-29QORVO US INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202380034822.9
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2022-05-24
Filing Date
2023-05-15
Publication Date
2024-11-29

AI Technical Summary

Technical Problem

OEMs often struggle to detect and resolve risks arising from platform software updates during the product lifecycle, especially as confidentiality agreements prevent timely sharing of changes to third-party code repositories, jeopardizing key milestones.

Method used

Employing a hybrid technology that combines static code analysis and dynamic/runtime behavior change detection, leveraging the platform's compilation and simulation tools and unique framework, it automates the detection of third-party driver code changes and generates encrypted reports, reducing reliance on complete source files.

Benefits of technology

It enables early detection of platform software changes in OEM environments, reduces resource requirements, improves software integration efficiency, provides a competitive advantage, and avoids design losses.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119053948A_ABST
    Figure CN119053948A_ABST
Patent Text Reader

Abstract

Systems and methods are provided for hybrid techniques to mitigate the risk of platform software migration. In some embodiments, a method for mitigating the risk of platform software changes includes one or more of the following: detecting changes using static code analysis; and detecting a dynamic / runtime behavior change. In some embodiments, early detection of codebase migration issues (early before actual hardware is available) reduces OEM resource requirements to solve software integration issues. As an OEM and a platform provider sign an NDA that prohibits the OEM from sharing materials with a third party, some embodiments of the present disclosure allow a platform code library migration problem to be solved as soon as possible during software integration in an OEM environment without accessing most of code libraries; and / or the problem does not need to be actually seen / touched.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Cross-reference to related applications

[0002] This application claims the benefit of Provisional Patent Application No. 63 / 345,146 filed on May 24, 2022, the disclosure of which is hereby incorporated by reference in its entirety. Technical Field

[0003] The present disclosure relates generally to the field of software verification. Background Art

[0004] During the lifecycle of a product, original equipment manufacturers (OEMs) receive several code base updates from platform providers. Typically, such updates involve changes to third-party deliverables caused by interface changes. As the complexity of platform software and radio frequency (RF) front-end (RFFE) components increases, OEMs are increasingly wary of the risks that code base updates from platform vendors pose to third-party software. Some of these updates are known to occur over the air (OTA), even after the product has been launched. OEMs are often bound by non-disclosure agreements (NDAs) signed with platform providers and are unable to share changed files with third parties. This results in OEMs having to wait until the motherboard build is complete before asking third parties to fix code base migration issues. This has the potential to put key milestones at risk.

[0005] Improved systems and methods are needed to mitigate the risks of platform software changes. Summary of the invention

[0006] Systems and methods of hybrid techniques for mitigating the risk of platform software migration are provided. In some embodiments, a method for mitigating the risk of platform software changes includes one or more of: detecting changes using static code analysis; and detecting dynamic / runtime behavior changes. In some embodiments, early detection of code base migration issues (long before actual hardware is available) reduces the original equipment manufacturer (OEM) resource requirements for resolving software integration issues. Because OEMs have non-disclosure agreements (NDAs) with platform providers (e.g., chipset providers) that prohibit the OEMs from sharing materials with third parties, some embodiments of the present disclosure allow platform code base migration issues to be resolved early during software integration in an OEM environment, potentially without access to the vast majority of the code base; and / or potentially without actually seeing / touching the problem.

[0007] In some embodiments, detecting dynamic / runtime behavior changes includes: testing dynamic / runtime behavior changes based on changes detected using static code analysis. In some embodiments, detecting dynamic / runtime behavior changes includes: applying an existing code base and capturing results; applying an updated code base and capturing results; and comparing the captured results.

[0008] Those skilled in the art will appreciate the scope of the present disclosure and understand additional aspects thereof after reading the following detailed description of the preferred embodiments and the related drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] The accompanying drawings incorporated in and forming a part of this specification illustrate several aspects of the disclosure, and together with the description serve to explain the principles of the disclosure.

[0010] Figure 1 A typical scenario of an Original Equipment Manufacturer (OEM) porting a new software code base is shown.

[0011] Figure 2 An updated loop using the disclosed method is shown.Now, according to some embodiments of the present disclosure, the OEM runs a hybrid technique to determine third-party impact.

[0012] Figure 3 An example embodiment for mitigating the risk of platform software changes according to some embodiments of the present disclosure is shown.

[0013] Figure 4 Additional details on the proposed method according to some embodiments of the present disclosure are shown.

[0014] Figure 5 is a block diagram of a system suitable for implementing the examples according to one example. DETAILED DESCRIPTION

[0015] The embodiments set forth below represent information necessary to enable those skilled in the art to practice the embodiments and to illustrate the best mode for practicing the embodiments. Upon reading the following description in light of the accompanying drawings, those skilled in the art will understand the concepts of the present disclosure and will recognize the applications of these concepts not specifically described herein. It should be understood that these concepts and applications fall within the scope of the present disclosure and the appended claims.

[0016] As discussed above, during the life cycle of a product, the original equipment manufacturer (OEM) receives several code base updates from the platform provider. Typically, such updates involve changes in third-party deliverables caused by interface changes. As the complexity of platform software and radio frequency (RF) front-end (RFFE) components increases, OEMs are increasingly wary of the risks that platform vendors' code base updates pose to third-party software. Some of these updates are known to occur over the air (OTA), even after the product is launched. OEMs are often bound by non-disclosure agreements (NDAs) signed with platform providers and are unable to share changed files with third parties. This results in OEMs having to wait until the motherboard is built before asking third parties to fix code base migration issues. This can put key milestones at risk. OEMs often view this as a major risk factor in selecting third-party components. As a result, OEMs continue to use reference designs provided by the platform. This risk can result in design losses.

[0017] Figure 1 A typical scenario of an OEM porting a new software code base is shown. This can take a long time, as shown by the calendar symbol. The OEM tests the new software on the hardware, and if it passes, the process is complete. However, if the test fails, the system is debugged while explaining the problem, and a solution is requested. If the RFFE vendor does not have enough information, more information is requested. This process can take a significant amount of time. Even if sufficient information is provided, a solution must be provided and implemented. The testing cycle is then repeated. These steps take a significant amount of time.

[0018] RFFE vendors work closely with many OEMs around the world to design and integrate software drivers to support many different front-end (FE) components (e.g., power amplifiers (PA), low noise amplifiers (LNA), antenna switch modules (ASM), tuners, LNAs, and power amplifiers with integrated duplexers (LPAMiDs)) on different platforms. Deliverables range from source code to platform-agnostic / adaptable libraries with appropriate interface code customizable for the platform. The hybrid technology described in this article is applicable to all platforms / RFICs that OEMs utilize in their products.

[0019] Some embodiments of the present disclosure include hybrid techniques for mitigating the risk of platform software migration. Some embodiments include a combination of techniques that enable OEMs to detect early changes that affect third-party driver code using automated tools running in the OEM environment. Early detection using automated tools and techniques provides OEMs with risk mitigation and the ability to differentiate from competing RFFE suppliers.

[0020] In some embodiments, the apparatus for these methods / techniques utilizes the platform's various compilation and simulation tools, combined with a unique and powerful framework. This provides capabilities that the platform tools alone cannot provide.

[0021] Figure 2 An updated cycle using the disclosed method is shown. Now, according to some embodiments of the present disclosure, the OEM runs a hybrid technique to determine third-party impact. This enables report sharing and review so that any required resolution can be obtained or avoided more quickly. In these embodiments, the OEM / third-party cycle may be shorter because the report contains all necessary information.

[0022] Figure 3 An example embodiment for mitigating the risk of platform software changes according to some embodiments of the present disclosure is shown. In some embodiments, the method consists of the following processes and techniques: detecting changes using static code analysis (step 300); and detecting dynamic / runtime behavior changes (step 302).

[0023] Figure 4 Additional details about the proposed method according to some embodiments of the present disclosure are shown. In some embodiments, static code analysis (step 300) involves comparing any source code released by the platform vendor with the OEM. The comparison analyzes the source code files and libraries of interest, focusing on structures and other data types, function signatures, class definitions, etc. between the new and old code bases. In some embodiments, this analysis is automated. The code base version (i.e., from the platform vendor) contains a mix of source code and libraries. The header files corresponding to many classes in the library are not disclosed. This may make static code analysis more complicated. In some embodiments, this is achieved by using a combination of several different methods.

[0024] In some embodiments, static code analysis (step 300) does not require the OEM / customer to purchase or license any other off-the-shelf products or tools. Instead, static code analysis leverages the platform's commonly available build tool framework.

[0025] In some embodiments, a secure and / or encrypted report is generated by comparing data types and functions of interest against several source files and libraries. In some embodiments, this report highlights the differences between code libraries.

[0026] Receiving encrypted and / or encoded reports can enable a competitive advantage over other RFFE vendors.In some embodiments, the customer / OEM does not have to share the complete source files of the platform with a third party in order for the third party to update the code.

[0027] This enables the RFFE vendor to make any updates to their interface code. Updating the interface code helps resolve any compile / link time errors caused by migrating to the new platform code base. In some embodiments, "self-healing" can be provided for various problems that may occur during software integration. For example, if static code analysis (step 300) indicates a type mismatch, a version of the code can be tested with variable types automatically corrected to match.

[0028] In some embodiments, the static code analysis is captured in the form of a binary / executable file for use by the customer / OEM in their platform build environment. In some embodiments, once the customer / OEM is ready to integrate the new platform code base, the customer / OEM can run the static code analysis portion of the automated method / tool. This process can be seamlessly integrated into the customer / OEM workflow without the need for additional support.

[0029] In some embodiments, the dynamic / runtime behavior change detection step (step 302) is run in two steps. Using the simulator capabilities of the platform, techniques are developed and the libraries and source code of interest for a specific RFFE component are exercised against test cases. The first step of the dynamic / runtime behavior change detection step is exercised on an existing code base and the results are captured.

[0030] This exercise does not require any special hardware, as this can be achieved through the simulator capabilities of the platform. In some embodiments, the proposed method / apparatus is run on the OEM's code build computer. In some embodiments, dynamic / runtime behavior analysis does not require the customer / OEM to purchase or license any other off-the-shelf products.

[0031] The second step of the dynamic / runtime behavior change detection step (step 302) is applied using the new code base. If the static code analysis (step 300) does not show any changes that affect the RFFE interface code or library; or the RFFE resolves the identified changes.

[0032] The comparison of the results of the two dynamic behavior runs is recorded in a report for analysis by the RFFE supplier. In some embodiments, the report is secure and / or encrypted. Such security and / or encryption can achieve a competitive advantage over other RFFE suppliers.

[0033] In some embodiments, dynamic / behavioral analysis techniques / methods are captured in the form of binary / executable files for use by customers / OEMs in their platform build environments.

[0034] In some embodiments, customers / OEMs can apply dynamic / runtime behavior detection methods / tools without support, long before the hardware is ready. Like static analysis, this method / tool ​​can be easily integrated into the customer / OEM new code base migration workflow without any support from the RFFE vendor.

[0035] In some embodiments, the proposed toolkit runs in a customer build environment where platform code, OEM code, and third-party code are integrated for the final modem image. The toolkit may leave signatures / markers in the relevant code that goes into the modem image / binary on the phone. This can help with detection and additional debugging.

[0036] Figure 5 is a block diagram of a system 26 suitable for implementing an example according to one example. The system 26 may include any computing or electronic device capable of including firmware, hardware and / or executing software instructions to implement the functions described herein, such as a computer server, a desktop computing device, a laptop computing device, a smart phone, a computing tablet, etc. The system 26 includes a processor device 78, a system memory 80, and a system bus 84. The system memory 80 may include a non-volatile memory 86 and a volatile memory 88. The non-volatile memory 86 may include a read-only memory (ROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), etc. The volatile memory 88 typically includes a random access memory (RAM). A basic input / output system (BIOS) 90 may be stored in the non-volatile memory 86 and may include basic routines that facilitate the transfer of information between elements within the system 26.

[0037] The system bus 84 provides an interface for system components including, but not limited to, the system memory 80 and the processor device 78. The system bus 84 may be any of several types of bus structures, which may further interconnect to a memory bus (with or without a memory controller), a peripheral bus, and / or a local bus using any of a variety of commercially available bus architectures. The processor device 78 may be any commercially available or proprietary processor, central processing unit (CPU), microcontroller, etc.

[0038] The system 26 may further include or be coupled to a non-transitory computer-readable storage medium, such as a storage device 92, which may represent an internal or external hard disk drive (HDD), flash memory, etc. The storage device 92 and other drives associated with computer-readable and computer-usable media may provide non-volatile storage of data, data structures, computer-executable instructions, etc. Although the above description of computer-readable media refers to an HDD, it should be understood that other types of media that can be read by a computer, such as optical disks, magnetic tapes, flash memory cards, cartridges, etc., may also be used in the operating environment, and further, any such media may contain computer-executable instructions for performing the novel methods of the disclosed embodiments.

[0039] An operating system 94 and any number of application programs 96 may be stored in the volatile memory 88, wherein the application programs 96 represent various computer executable instructions corresponding to programs, applications, functions, etc. that may implement all or part of the functionality described herein. The application programs 96 may also reside on a storage mechanism provided by the storage device 92. In this way, all or part of the functionality described herein may be implemented as a computer program product stored on a transient or non-transient computer-usable or computer-readable storage medium, such as the storage device 92, the volatile memory 88, the non-volatile memory 86, etc. The computer program product contains complex programming instructions, such as complex computer-readable program code, to cause the processor device 78 to perform the steps necessary to implement the functionality described herein. The processor device 78 may act as a controller or control system of the system 26 to implement the functionality described herein based on the computer program product.

[0040] An operator such as a user may also be able to input one or more configuration commands via a keyboard, a pointing device such as a mouse, or a touch-sensitive surface such as a display device, via the input device interface 98 or remotely via a web interface, a terminal program, etc. via the communication interface 100. A display device coupled to the system bus 84 may be driven via a video port 102. The communication interface 100 may be wired or wireless and facilitates communication with any number of devices in a direct or indirect manner. In some embodiments, there are also one or more ultra-wideband (UWB) sensors 104.

[0041] Those skilled in the art will recognize improvements and modifications to the preferred embodiments of the present disclosure. All such improvements and modifications are considered to be within the scope of the concepts disclosed herein and the following claims.

Claims

1. A method for mitigating the risk of platform software changes, the method comprising: Use static code analysis to detect (300) changes; as well as Dynamic / runtime behavior changes are detected (302).

2. The method of claim 1, wherein detecting (302) the dynamic / runtime behavior change comprises: The dynamic / runtime behavior changes are tested based on changes detected using static code analysis (300).

3. The method according to any one of claims 1 to 2, wherein detecting (300) the change using static code analysis comprises: Analyze existing code base and capture results; Analyze the updated code base and capture the results; as well as Compare the captured results.

4. The method of claim 3, wherein the existing code base and the updated code base include source code files and libraries of interest.

5. The method of any one of claims 3 to 4, wherein comparing the captured results comprises focusing on one or more of: structure; data type; function signature; and class definition.

6. The method according to any one of claims 1 to 5, wherein the static code analysis utilizes a commonly available build tool framework of the platform.

7. The method according to any one of claims 1 to 5, wherein detecting (302) the dynamic / runtime behavior change comprises: Apply said existing code base and capture the results; Apply the updated code base and capture the results; as well as Compare the captured results.

8. The method according to any one of claims 1 to 7, wherein the method is performed in a customer build environment integrated with platform code.

9. The method according to any one of claims 1 to 8, further comprising: Prepare a report containing information about the dynamic / runtime behavior changes.

10. The method of claim 9, wherein the report containing the information about the dynamic / runtime behavior change is encrypted.

11. The method of any one of claims 9 to 10, wherein the report highlights differences between the existing code base and the updated code base.

12. The method of any one of claims 1 to 10, wherein the static code analysis is captured in the form of a binary / executable file.

13. The method of claim 12, wherein the static code analysis is usable in the customer build environment.

14. The method according to any one of claims 1 to 13, further comprising: Upon any code changes, signatures and / or tags are included with the relevant code.

15. The method according to any one of claims 1 to 14, wherein the static code analysis (300) does not require the purchase and / or licensing of any other off-the-shelf products or tools.

16. The method according to any one of claims 1 to 15, wherein the static code analysis (300) utilizes the commonly available build tool framework of the platform.

17. The method according to any one of claims 1 to 16, further comprising: After the static code analysis (300) indicates a type mismatch, a version of the code is tested with variable types automatically corrected to match.

18. The method according to claim 17, further comprising: After successfully testing the version of the code with the automatic correction to matching variable types, the updated code base is changed to include matching variable types.

19. The method of any one of claims 1 to 18, wherein the software changes are related to radio frequency (RF) front end (RFFE) components.