Function offloading method and system based on java language runtime

Abstract

The application provides a Java language runtime-based function offloading method and system, which comprises the following steps: loading and reading a bytecode class file to obtain a screened file; screening a user-defined function through an annotation, plugging the function, adding code for collecting runtime information, and converting the plugged user-defined function into a byte array; converting the byte array into a new byte array and saving the new byte array; determining whether CPU resource occupation is higher than a preset value during function runtime; if the result is yes, screening and marking a candidate function and offloading; and if the result is no, not processing. The application utilizes the characteristics of a server non-perception computing platform, can quickly expand and shrink the capacity of an application on demand without caring about the underlying server operation and maintenance, saves local system resources, and enables the CPU utilization rate to be saved by more than 60% after offloading the user function, thereby increasing the scalability.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of server-agnostic computing function offloading, and particularly relates to a function offloading method and system based on Java language runtime. BACKGROUND

[0002] The development of cloud computing has given rise to new technologies that change traditional IT architecture and operation methods, such as virtual machines, containers, and microservices. The advent of server-agnostic computing has outsourced host management, operating system management, resource allocation, expansion, and even all components of application logic, bringing about new changes.

[0003] Existing systems are based on server-agnostic computing and automatically offload functions that consume more local resources to server-agnostic computing platforms, thereby improving the scalability of existing applications. Existing work mainly includes analysis and optimization of server-agnostic computing systems, server-agnosticization of existing applications, and construction and training of server-agnostic computing models designed for specific scenarios.

[0004] Currently, existing technical solutions analyze and optimize server-agnostic computing systems from multiple aspects.

[0005] For example, the Photons system implemented by Vojislav et al. places multiple instances of the same function in server-agnostic computing in the same runtime, thereby improving cross-function communication performance and reducing function memory overhead. The IceBreaker system implemented by Rohan et al. is based on heterogeneous nodes to improve the hot start performance of server-agnostic computing, thereby reducing service time and saving cost overhead.

[0006] Such work improves the start, execution, and communication performance of server-agnostic computing systems, providing a basic guarantee for existing applications to use server-agnostic platforms for computing. Regarding server-agnosticization of existing applications, the main work is to design specialized computing frameworks for computationally intensive and resource-consuming applications, and to complete the work by rewriting applications for server-agnostic computing to take advantage of server-agnostic computing to accelerate existing applications and reduce computing costs.

[0007] For example, the gg framework designed and implemented by Sadjad et al. designs an execution engine and provides an easy-to-use command line tool to help users use server-agnostic computing to execute daily applications such as software compilation. The ExCamera system designed and implemented by the Sadjad team applies server-agnostic computing in the video processing field, reducing the delay of video-related operations such as encoding videos.

[0008] However, for complex stateful and tightly coupled with the framework online services, similar methods need to introduce a large number of code modification and refactoring, which cannot be easily implemented. Therefore, it is necessary to add a more reasonable selection mechanism to guide the system to select a more reasonable and efficient offload target when performing function offloading.

[0009] In the calculation of offloading selection strategy, some existing calculation offloading works include selection strategy and mechanism. For example, the MAUI system proposed by Eduardo et al. attempts to offload the functions executed in the mobile terminal device to the edge computing node, and abstracts the function selection strategy as a linear programming problem based on certain rules. The CloneCloud system proposed by Byung introduces static analysis and more complex linear programming conditions to achieve more accurate function selection.

[0010] In general, for the scenario of high-concurrency requests of the client, the user end delay will increase with the number of requests, resulting in an increase in request delay. Moreover, there is no related work that is specifically designed to select functions suitable for offloading to the server non-aware computing platform, so the collection of runtime information, such as what information should be collected, how to collect the information in this paper, and how to use the collected information to select the user functions that are truly suitable for offloading, still needs to be analyzed and explored. Although the existing solutions such as the Photons system implemented by Vojislav and the gg framework designed and implemented by Sadjad have improved the performance to some extent, they are not a general solution for the scenario of high-concurrency requests of the client. In addition, the existing solutions need to introduce a large number of code modifications and refactoring, and cannot provide a general solution for similar needs and scenarios. This problem needs to be solved urgently. SUMMARY

[0011] In view of the defects in the prior art, the purpose of the present application is to provide a function offloading method and system based on Java language runtime.

[0012] According to the function offloading method based on Java language runtime provided by the present application, the method comprises the following steps:

[0013] Step S1: loading and reading the bytecode class file, and screening according to the class name to obtain a screened file;

[0014] Step S2: screening and inserting a user-defined function through annotation according to the screened file, and converting the inserted user-defined function into a byte array;

[0015] Step S3: converting the byte array into a new byte array; the new byte array is represented by the bytecode of the Java class, and the new byte array is saved.

[0016] Step S4: judging whether the CPU resource occupation is higher than the preset value during function runtime; if yes, screening and marking the candidate function, and storing the candidate function into the constant level array and unloading; if no, not processing.

[0017] Preferably, in the step S1, the bytecode class file is loaded and read through the ClassReader class in the ASM framework.

[0018] Judging whether the class name contains the user-specified prefix; if yes, converting the bytecode class file into a byte stream, i.e. the screened file; if no, skipping and not processing.

[0019] Preferably, in the step S2, the ClassVisitor class is used to screen the user-defined function according to the annotation.

[0020] The annotation is determined according to the framework, i.e. the software tool set.

[0021] The framework includes the spring framework.

[0022] The annotation includes @GetMapping, @PostMapping and @PutMapping.

[0023] Preferably, in the step S3, the toByteArray method of the ClassWriter class is called, so as to obtain a new byte array, and the new byte array is saved into the.class file; the.class file collects the information during Java program runtime.

[0024] Preferably, in the step S4, the preset value is 20%, and whether the CPU resource occupation is higher than 20% is judged; if no, not processing; if yes and less than 50%, the candidate function to be unloaded is screened, and the candidate function is stored into the constant level array; further judging whether the CPU resource occupation is greater than or equal to 50%; if yes, marking the candidate function, and unloading the candidate function according to the user-set unloading rate; if no, not processing.

[0025] The candidate function includes the user function recently run or the function with the longest average running time.

[0026] According to the application, a function unloading system based on Java language runtime is provided, which includes:

[0027] The information collection module: loads and reads the bytecode class file, and filters according to the class name to obtain a filtered file; according to the filtered file, the user-defined function is filtered and instrumented, the instrumented user-defined function is converted into a byte array, and the byte array is converted into a new byte array; the new byte array is represented by the bytecode of the Java class; save the new byte array;

[0028] The function uninstallation strategy module: determines whether the CPU resource occupation is higher than the preset value during the function running; if the result is yes, the candidate function is marked and unloaded; if the result is no, no processing is performed.

[0029] Preferably, in the information collection module, the bytecode class file is loaded and read through the ClassReader class in the ASM framework;

[0030] Determine whether the class name contains a user-specified prefix; if the result is yes, the bytecode class file is converted into a byte stream, i.e. a filtered file; if the result is no, skip and do not process.

[0031] Preferably, in the information collection module, the ClassVisitor class is used to filter the user-defined function according to the annotation;

[0032] The annotation is determined according to the framework, i.e. the software tool set;

[0033] The framework includes the spring framework;

[0034] The annotation includes @GetMapping, @PostMapping, and @PutMapping.

[0035] Preferably, in the function uninstallation strategy module, the toByteArray method of the ClassWriter class is called to obtain a new byte array.

[0036] Preferably, in the function uninstallation strategy module, the new byte array is saved to a.class file; the.class file collects information during Java program running;

[0037] Let the preset value be 20%, determine whether the CPU resource occupation is higher than 20%; if the result is no, do not process; if the result is yes and less than 50%, select the candidate function to be unloaded, and store the candidate function in a constant array, further determine whether the CPU resource occupation is greater than or equal to 50%; if the result is yes, mark the candidate function, and uninstall the candidate function according to the uninstallation rate set by the user; if the result is no, do not process;

[0038] The candidate function includes a user function recently run or a function with the longest average running time.

[0039] Compared with the prior art, the application has the following beneficial effects:

[0040] 1、 The application utilizes the server non-perception computing platform characteristics, and can quickly expand and shrink the capacity of the application on demand without caring about the underlying server operation, so as to save local system resources, and after the user function is unloaded, the CPU utilization rate can be saved by more than 60%, and the scalability is increased.

[0041] 2、 The application is a non-perception function unloading, which can automatically unload the function to the remote server non-perception platform for running without modifying the business code.

[0042] 3、 After the system CPU utilization rate reaches 50%, the application can automatically unload the user function candidate traversal and mark accordingly, and when the function is run again, the function unloading is directly performed, and after the automatic unloading, the average end-to-end delay can be reduced by 50%, the request delay of the high-concurrency request scenario of the client is reduced, and the efficiency is improved.

[0043] 4、 The application can increase the scalability, is transparent to the user, and can automatically select the function suitable for unloading, provides a general and automatic solution for similar scenarios, and does not need to introduce cumbersome targeted code modification and reconstruction. DETAILED DESCRIPTION

[0044] Other features, objects and advantages of the application will become more apparent from the following detailed description of non-limiting embodiments with reference to the attached drawings:

[0045] Figure 1 An execution flow diagram of the runtime information collection module provided by the application is shown.

[0046] Figure 2 An execution flow diagram of the function unloading strategy module provided by the application is shown. DETAILED DESCRIPTION

[0047] The application will be described in detail below with reference to specific embodiments. The following embodiments will help those skilled in the art to further understand the application, but do not limit the application in any form. It should be pointed out that, for those skilled in the art, without departing from the concept of the application, a number of changes and improvements can be made. These all belong to the protection scope of the application.

[0048] The application provides a function unloading method based on Java language runtime, which can automatically screen out functions consuming large resources during program runtime without changing user code, and unload the functions to a server non-aware computing platform. The function unloading strategy collects runtime information of the user program, and then selects functions according to the information, screens out functions consuming large resources, and finally writes the target functions to the remote server non-aware computing platform.

[0049] As shown in Figure 1 The execution flow of the runtime information collection module of the application.

[0050] The Figure 1 The overall execution flow of the runtime information collection module is described in detail.

[0051] Step S1: load the bytecode class file, i.e.class file, through the ClassReader class in the ASM framework, read the content, and preliminarily screen the user functions according to the classname. The classname is the class name.

[0052] Specifically, the.class file of the user is obtained through the ClassReader instance, and the screening is performed according to whether the class name contains the prefix specified by the user; that is, whether the class name contains the prefix specified by the user is judged, and the result is yes, the bytecode class file is converted into a byte stream, i.e.array of bytes; the result is no, the class is skipped and not processed.

[0053] The successfully screened class is converted into a byte stream and will be processed by the subsequent module. A ClassVisitor instance is used for processing.

[0054] The ASM framework in step (1) is a Java bytecode manipulation framework, which can be used to dynamically generate classes or enhance the functions of existing classes. The ClassReader class is used to parse the compiled bytecode class file.

[0055] The Java bytecode class file, i.e.class file, is the target file generated by the Java compiler when compiling the Java source file, i.e.java file.

[0056] Step S2: according to the screened file, screen out the user-defined functions through annotations, and insert the functions to increase the code for collecting runtime information, and convert the user-defined functions into an array of bytes.

[0057] Specifically, the ClassVisitor class is used to screen out the user-defined functions according to the annotations, convert the parsed array of bytes, insert the Java instructions, and increase the code for collecting runtime information.

[0058] The ClassVisitor class in step (2) is a class visitor in Java, which provides a series of methods called by ClassReader.

[0059] Specifically, at the Class level of the user code, each method under the Class is preliminarily screened. The screening method is: according to the attributes provided by the original method class, it is judged whether the method meets the attributes. If the result is yes, it will be further screened by the Method level; if the result is no, it will be skipped and not processed.

[0060] For example, it is judged whether the method is an abstract method, a Java native method, a constructor method init or a static constructor clinit, etc. The range of a user function is screened out, and the subsequent work is then sunk to the Method level for further processing.

[0061] When entering a specific method, further screening is done according to the annotations of the method.

[0062] The further screening standard depends on which framework the user uses. The framework is a set of software tools that provides basic structures and existing functions, aiming to help developers build applications more easily. The annotations are a way to provide metadata for Java code, which can be used to provide additional information about the code, telling the compiler, tools or frameworks how to process the code. Frameworks widely use annotations to simplify the development process, and different frameworks define different annotations.

[0063] In other words, the annotation @GetMapping is one of the annotations used by the spring framework to handle HTTP GET requests, which can map HTTP GET requests to specific processing methods, such as Controller methods.

[0064] For example, if the user uses the classic Spring framework, the annotations of the user request function are @GetMapping, @PostMapping, @PutMapping, etc. The user filters the user-defined function according to the annotations.

[0065] After completing the screening work, the scheme further adds some temporary variables of the function and class members to the user functions, records the runtime time, and completes the function reflection to obtain the method variable, and finally passes these data as parameters to the runtime information collector.

[0066] The function temporary variable is a variable declared in the function, which only exists during the function execution, and is destroyed after the function execution, used to record the function start running time and end running time;

[0067] The class member variable is a variable defined in the class, which belongs to the part of the class, and the life cycle of the class member variable is the same as the instance of the class, used to record the function running time.

[0068] Considering the huge overhead brought by reflection, the method instance of the user function cannot be obtained by reflection every time, so the static field of the class where the user function is located is added to save the method instance of the user function.

[0069] Step S3: using the ClassWriter class to convert the byte array processed in step S2 into a new content byte stream, and storing the newly generated content into a specific.class file, so that the new.class file has the function of collecting runtime information, and the workflow of ASM ends here.

[0070] Specifically, the toByteArray method of the ClassWriter class is called to obtain the new content byte stream. The new content byte stream, i.e. the byte array, contains the bytecode representation of the Java class generated by the ClassWriter class.

[0071] The ClassWriter class in step 3 is used to reconstruct the compiled class, such as modifying the class name, attributes and methods, and can generate the bytecode file of the new class.

[0072] The.class file in step 3 is the bytecode file generated by the Java compiler from the Java source code.

[0073] Step S4: judging whether the CPU resource occupation is higher than the preset value during the function running; if yes, screening and marking the candidate function, and storing the candidate function into the constant array and unloading; if no, not processing.

[0074] Specifically, when the Java program application starts running, a daemon thread is started as a resource monitor to obtain the local resource usage at regular intervals. The resource monitor accesses the / proc related file on the Linux system to obtain the local resource.

[0075] If the CPU resource occupation is found to be higher than 20% and less than 50%, the selection of the offloading candidate function is carried out and stored in a constant level array; if the CPU resource occupation is found to be lower than or equal to 20%, no processing is carried out. If the CPU resource occupation is found to be greater than or equal to 50%, the candidate function is marked and offloaded. There are two selection strategies for the function: the first one is to select the user function that is recently run for offloading; the second one is to select the function with longer average running time for offloading.

[0076] Specifically, when the user sets the offloading rate to 50%, the candidate functions are sorted according to the average running time, and the candidate functions with the top 50% of the offloading duration are offloaded.

[0077] The method adopts the second selection scheme of the average running time by default.

[0078] Specifically, if the CPU resource occupation is found to be higher than 50%, the user function is directly marked by traversing the candidate function array maintained. If the CPU resource occupation is found to be lower than or equal to 50% and higher than 20%, the candidate function selected by the candidate function selection strategy is marked, and the function is offloaded to the serverless platform by the application layer.

[0079] Specifically, at the application layer, the application checks whether the function is marked according to the instructions injected by steps 1 to 4. If the function is already marked, the system offloads the user function according to the specific offloading rate. Specifically, the default offloading rate is set to a fixed 50%, that is, when the function offloading starts, half of the user functions are offloaded to the remote serverless computing platform.

[0080] A function offloading strategy and technology based on Java language runtime, comprising: a runtime information collection module and a function offloading strategy module.

[0081] Specifically, at runtime, the information collection module is used to screen the user functions and record the running times and running durations of the user functions, and the function offloading strategy module selects and offloads the candidate functions according to the data collected by the runtime information collection module.

[0082] The information collection module comprises: a user function screening module, a user function timing module and an information collection transmission module.

[0083] The user function screening module uses the built-in attributes of the method in the JVM, or the transfer function for function reflection in the application framework, or directly reads the.class file through the related library to obtain the corresponding annotations, screens all Java functions, and selects the functions written by the user.

[0084] The user function timing module is used for timing the running of the user function at the nanosecond level.

[0085] The information collection and transmission module adds corresponding native methods in the JVM and exposes the interface to the outside.

[0086] The function offloading strategy module comprises an information storage design module, a local resource monitoring module and a user function selection module.

[0087] The information storage design module uses a double-linked list to store relevant information, and the list nodes are divided into two parts, one part is the pointer of the method method, and the other part is the runtime information of the method.

[0088] The local resource monitoring module can monitor the CPU usage of the local machine.

[0089] The user function selection module can offload the candidate functions one by one to the server non-perception computing platform when the local machine resource usage exceeds the set threshold.

[0090] As shown in Figure 2 The function offloading strategy module flow chart of the application.

[0091] The overall execution process will be described in detail below: Figure 2 The overall execution process will be described in detail below:

[0092] Step S1: The JVM provides a runtime information collector externally connected manner, mainly used to transmit the method instance and related runtime information to the runtime information collector inside the JVM.

[0093] In other words, in step S1, the method instance and related runtime information are transmitted to the runtime information collector inside the JVM;

[0094] Step S2: The local resource monitoring thread monitors the resource consumption of the local machine in a timely manner; access the / proc related file on the Linux system to obtain the local resources.

[0095] Step S3: The runtime information collector uses a double-linked list data structure to store the corresponding user function runtime information, and provides an interface to trigger the local resource monitoring thread in a timely manner.

[0096] A double-linked list is used as the specific data structure of the collector;

[0097] In the implementation, first, a method instance and its related runtime information are wrapped into a linked list node, and a time stamp is added to each linked list node, and a specific setting of a time window is added to the linked list structure, and the data structure of the linked list is set as a friend of the node data structure, so that the member functions of the two are inline functions, avoiding excessive function stack switching, thereby improving the overall running efficiency of the system.

[0098] Specifically, the specific process of information collection is as follows:

[0099] First, the information collector judges whether the user function exists in the double-linked list, and if the result is yes, that is, the user function exists, step (2) is entered; if the result is no, that is, the user function does not exist, step (3) is entered.

[0100] Step (2): If the user function exists, the runtime information and the time stamp of the node are updated, and after the update, the node is moved to the head of the double-linked list.

[0101] Step (3): If the user function does not exist in the existing double-linked list, a user function runtime information record node is newly created, including the method instance of the user function, the running frequency and running time of the user function, and a corresponding time stamp, and after the record node is newly created, the node is inserted into the head of the double-linked list, and the basic process of collecting user function runtime information is completed.

[0102] It can be seen that the double-linked list of the runtime information collector is an ordered double-linked list with the most recent running time stamp as the sorting standard, that is, the functions that are recently run are located at the head of the double-linked list, and the functions that are not run for a long time are located at the tail of the double-linked list.

[0103] Step S4: When the local resource monitoring thread is triggered, the offload function picker in the application maintains a candidate list of functions to be offloaded according to the information in the collector.

[0104] The offload function picker includes a selection strategy part of the offload function and a function offload execution part, for selecting and executing the offload function. After the local machine resource load reaches fifty percent, the user function to be offloaded is directly obtained from the offload function candidate list, and finally the task of offloading the user function consuming high resources to the remote server non-perception computing platform is completed.

[0105] Specifically, after the CPU utilization is higher than 20%, the unloading candidate function is selected and stored in a constant level array, and then when the CPU utilization is higher than 50%, the user function is marked by traversing the candidate function array, which is also a constant level operation.

[0106] The application further provides a function unloading system based on a Java language runtime, which can be realized by executing the flow steps of the function unloading method based on the Java language runtime, i.e., the function unloading method based on the Java language runtime can be understood as a preferred embodiment of the function unloading system based on the Java language runtime by those skilled in the art.

[0107] Those skilled in the art know that, in addition to implementing the system provided by the application and each device, module and unit thereof in a pure computer readable program code manner, the system provided by the application and each device, module and unit thereof can also be realized in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers and embedded microcontrollers by logically programming the method steps to achieve the same functions. Therefore, the system provided by the application and each device, module and unit thereof can be considered as a hardware component, and the devices, modules and units included therein for realizing various functions can also be considered as structures in the hardware component; the devices, modules and units for realizing various functions can also be considered as both software modules realizing the method and structures in the hardware component.

[0108] The specific embodiments of the application are described above. It should be understood that the application is not limited to the specific embodiments described above, and those skilled in the art can make various changes or modifications within the scope of the claims, which does not affect the essential content of the application. The embodiments of the present application and the features in the embodiments can be arbitrarily combined with each other without conflict, provided that they do not conflict.

Claims

1. A function unloading method based on the Java language runtime, characterized in that, include: Step S1: Load and read the bytecode class files, and filter them according to the class name to obtain the filtered files; Step S2: Based on the filtered files, filter by annotations and instrument user-defined functions, then convert the instrumented user-defined functions into byte arrays; Step S3: Convert the byte array into a new byte array; the new byte array is represented by the bytecode of a Java class, and the new byte array is saved; In step S3, the toByteArray method of the ClassWriter class is called to obtain a new byte array, which is then saved to a .class file; the .class file collects information about the Java program's runtime. Step S4: During function execution, determine whether CPU resource usage is higher than a preset value; if the result is yes, filter and mark candidate functions, store the candidate functions in a constant array, and unload them; If the result is negative, no action will be taken. In step S4, the preset value is set to 20%, and it is determined whether the CPU resource usage is higher than 20%. If the result is negative, no action will be taken. If the result is yes and less than 50%, then candidate functions to be unloaded are selected and stored in a constant-level array, and it is further determined whether the CPU resource usage is greater than or equal to 50%. If the result is yes, then the candidate function is marked, and the candidate function is uninstalled according to the uninstallation rate set by the user. If the result is negative, no action will be taken. The candidate functions include: the most recently run user function or the function with the longest average running time; After filtering, tagging, and determining the candidate functions to be uninstalled, the candidate functions are uninstalled onto the server-invisible computing platform.

2. The function unloading method based on the Java language runtime according to claim 1, characterized in that, In step S1, the bytecode class file is loaded and read using the ClassReader class in the ASM framework; Determine whether the class name contains a user-specified prefix; if yes, convert the bytecode class file into a byte stream, i.e., the filtered file; if no, skip it and do not process it.

3. The function unloading method based on the Java language runtime according to claim 2, characterized in that, In step S2, the ClassVisitor class is used to filter user-defined functions based on annotations; The annotations are determined based on the framework, i.e., the software toolset; The framework includes: the Spring framework; The annotations include: @GetMapping, @PostMapping, and @PutMapping.

4. A function unloading system based on the Java language runtime, characterized in that, include: Information gathering module: Loads and reads bytecode class files, filters them according to class name, and obtains the filtered files; Based on the filtered files, user-defined functions are filtered by annotations and instrumented. The instrumented user-defined functions are then converted into byte arrays, and the byte arrays are converted into new byte arrays. The new byte arrays are represented by the bytecode of Java classes. Save the new byte array; Function unloading strategy module: When a function is running, it checks whether the CPU resource usage is higher than a preset value; if the result is yes, the candidate function is marked and unloaded; if the result is no, no action is taken. In the function unloading strategy module, the toByteArray method of the ClassWriter class is called to obtain a new byte array; In the function unloading strategy module, the new byte array is saved to a .class file; the .class file collects information about the Java program's runtime. Let the preset value be 20%, and determine whether the CPU resource usage is higher than 20%. If the result is negative, no action will be taken. If the result is yes and less than 50%, then candidate functions to be unloaded are selected and stored in a constant-level array, and it is further determined whether the CPU resource usage is greater than or equal to 50%. If the result is yes, then the candidate function is marked, and the candidate function is uninstalled according to the uninstallation rate set by the user. If the result is negative, no action will be taken. The candidate functions include: the most recently run user function or the function with the longest average running time; After filtering, tagging, and determining the candidate functions to be uninstalled, the candidate functions are uninstalled onto the server-invisible computing platform.

5. The function unloading system based on the Java language runtime according to claim 4, characterized in that, In the information collection module, bytecode class files are loaded and read using the ClassReader class in the ASM framework; Determine whether the class name contains a user-specified prefix; if yes, convert the bytecode class file into a byte stream, i.e., the filtered file; if no, skip it and do not process it.

6. The function unloading system based on the Java language runtime according to claim 5, characterized in that, In the information collection module, the ClassVisitor class is used to filter user-defined functions based on annotations; The annotations are determined based on the framework, i.e., the software toolset; The framework includes: the Spring framework; The annotations include: @GetMapping, @PostMapping, and @PutMapping.

Images