CN115756627A

CN115756627A - Method, apparatus and storage medium for starting software according to function

Info

Publication number: CN115756627A
Application number: CN202211177505.6A
Authority: CN
Inventors: 林党辉; 徐立丰
Original assignee: Core Huazhang Technology Beijing Co ltd
Current assignee: Core Huazhang Technology Beijing Co ltd
Priority date: 2022-09-26
Filing date: 2022-09-26
Publication date: 2023-03-07

Abstract

The embodiment of the application provides a method for starting software according to functions, which comprises the following steps: receiving a first instruction for starting a first function of the software; generating a first window corresponding to the first function; receiving a second instruction for starting a second function of the software; and in response to receiving a second instruction to start a second function of the software, generating a second window corresponding to the second function.

Description

Method, apparatus and storage medium for starting software according to function

Technical Field

The embodiment of the application relates to the technical field of computer software, in particular to a method, equipment and a storage medium for starting software according to functions.

Background

With the development of computer technology, there are various kinds of relatively large-sized software, and the functions of the software are complicated. Such large software requires the entire software to be run at the time of startup, which results in a long startup time and a large amount of system resources to be consumed. However, in some scenarios, the user does not need to use all functions of the software, but only focuses on one function or a part of functions of the software, and if the software is operated as a whole, the user is not meaningful, and much waiting time and much system resources are consumed.

Disclosure of Invention

A first aspect of the present application provides a method of starting software according to a function, including:

receiving a first instruction for starting a first function of the software;

generating a first window corresponding to the first function;

receiving a second instruction for starting a second function of the software; and

in response to receiving a second instruction to initiate a second function of the software, a second window corresponding to the second function is generated.

A second aspect of the present application provides an electronic device. The electronic device includes a memory for storing a set of instructions; and at least one processor configured to execute the set of instructions to cause the electronic device to perform the method according to the first aspect.

A third aspect of the application provides a non-transitory computer readable storage medium storing a set of instructions of a computer for, when executed, causing the computer to perform the method of the first aspect.

Drawings

In order to more clearly illustrate the technical solutions in the present application or the related art, the drawings needed to be used in the description of the embodiments or the related art will be briefly introduced below, and it is obvious that the drawings in the following description are only embodiments of the present application, and it is obvious for those skilled in the art that other drawings can be obtained according to these drawings without creative efforts.

Fig. 1 shows a schematic diagram of a host according to an embodiment of the application.

FIG. 2 shows a schematic diagram of a simulation tool and a debugging tool according to an embodiment of the application.

FIG. 3A shows a schematic diagram of an exemplary page according to an embodiment of the present application.

FIG. 3B shows a schematic diagram of another exemplary page according to an embodiment of the present application.

FIG. 3C illustrates a schematic diagram of yet another exemplary page according to an embodiment of the present application.

FIG. 3D illustrates a schematic diagram of yet another exemplary page according to an embodiment of the present application.

FIG. 3E illustrates a schematic diagram of yet another exemplary page according to an embodiment of the present application.

A schematic diagram of the interaction between two windows is shown in fig. 3F.

Fig. 4 shows a flowchart of a method for starting software according to a function according to an embodiment of the present application.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is further described in detail below with reference to the accompanying drawings in combination with specific embodiments.

It is to be noted that, unless otherwise defined, technical or scientific terms used herein shall have the ordinary meaning as understood by those of ordinary skill in the art to which this application belongs. As used in this application, the terms "first," "second," and the like do not denote any order, quantity, or importance, but rather are used to distinguish one element from another. The word "comprising" and similar words are intended to mean that the elements or items listed before the word cover the elements or items listed after the word and their equivalents, without excluding other elements or items. "connected," and like terms, are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect.

Simulation testing is the application of various stimuli to a logic system design on a host computer running a simulation test system to detect whether the logic system design can perform a predetermined function.

Fig. 1 shows a schematic diagram of a host 100 according to an embodiment of the application. The host 100 may be an electronic device running an emulation system. As shown in fig. 1, the host 100 may include: a processor 102, a memory 104, a network interface 106, a peripheral interface 108, and a bus 110. Wherein the processor 102, the memory 104, the network interface 106, and the peripheral interface 108 are communicatively coupled to each other within the host via a bus 110.

The processor 102 may be a Central Processing Unit (CPU), an image processor, a neural Network Processor (NPU), a Microcontroller (MCU), a programmable logic device, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), or one or more Integrated circuits. The processor 102 may be used to perform functions associated with the techniques described herein. In some embodiments, processor 102 may also include multiple processors integrated into a single logic component. As shown in FIG. 1, the processor 102 may include a plurality of processors 102a, 102b, and 102c.

The memory 104 may be configured to store data (e.g., a set of instructions, computer code, intermediate data, etc.). In some embodiments, the simulation test system for simulating a test design may be a computer program stored in memory 104. As shown in fig. 1, the data stored by the memory may include program instructions (e.g., for implementing the method of the present application to launch software in terms of functionality) and data to be processed (e.g., the memory may store temporary code generated during the compilation process). The processor 102 may also access memory-stored program instructions and data and execute the program instructions to operate on the data to be processed. The memory 104 may include volatile memory devices or non-volatile memory devices. In some embodiments, the memory 104 may include Random Access Memory (RAM), read Only Memory (ROM), optical disks, magnetic disks, hard disks, solid State Disks (SSDs), flash memory, memory sticks, and the like.

The network interface 106 may be configured to provide communications with other external devices to the host 100 via a network. The network may be any wired or wireless network capable of transmitting and receiving data. For example, the network may be a wired network, a local wireless network (e.g., bluetooth, wiFi, near Field Communication (NFC), etc.), a cellular network, the internet, or a combination of the above. It is to be understood that the type of network is not limited to the specific examples described above. In some embodiments, network interface 106 may include any combination of any number of Network Interface Controllers (NICs), radio frequency modules, transceivers, modems, routers, gateways, adapters, cellular network chips, and the like.

The peripheral interface 108 may be configured to connect the host 100 with one or more peripheral devices to enable information input and output. For example, the peripheral devices may include input devices such as keyboards, mice, touch pads, touch screens, microphones, various sensors, and output devices such as displays, speakers, vibrators, indicator lights, and the like.

The bus 110 may be configured to transfer information between various components of the host 100 (e.g., the processor 102, the memory 104, the network interface 106, and the peripheral interface 108), such as an internal bus (e.g., a processor-memory bus), an external bus (e.g., a USB port, a PCI-E bus), and so forth.

It should be noted that although the host architecture only shows the processor 102, the memory 104, the network interface 106, the peripheral interface 108, and the bus 110, in a specific implementation, the host architecture may also include other components necessary for normal operation. Furthermore, those skilled in the art will appreciate that the above-described host architecture may also include only the components necessary to implement the embodiments of the present application, and need not include all of the components shown in the figures.

FIG. 2 shows a schematic diagram of a simulation tool 202 and a debugging tool 200 according to an embodiment of the application. Simulation tool 202 and debugging tool 200 may be computer programs running on host 100.

In the field of chip design, a design may be simulated using a simulation tool. The simulation tool may be, for example, a GalaxSim simulation tool available from Chihua chapter science and technology, inc. The example simulation tool 202 shown in FIG. 2 may include a compiler 120 and a simulator 220. Compiler 120 may compile a design (e.g., verification system 210) into object code 204, simulator 220 may simulate from object code 204, and output simulation results 206. For example, the simulation tool 202 may output simulation results (e.g., a simulation waveform diagram) onto an output device (e.g., displayed on a display) via the peripheral interface 108 of fig. 1. Verification system 210 may include a logic system design 210a and a verification environment 210b. The verification environment 210b may also be referred to as a test bench (testbench). For example, verification environment 210b may be a UVM environment.

Debug tool 200 may also read simulation results 206. The debugging tool 200 may be, for example, a Fusion Debug tool available from ChaoHuachapter technologies, inc. For example, the debugging tool 200 may read the simulation results 206 stored in a waveform file and generate corresponding simulation waveforms for debugging. Debug tool 200 can also read the description of verification system 210 (typically SystemVerilog and Verilog code) and display to the user. The debugging tool 200 may also generate various graphical interfaces (e.g., debugging windows) to facilitate the user's debugging effort. The user may issue a debug command to the debug tool 200 (e.g., run the verification system 210 to a certain point), which the debug tool 200 then applies to the simulation tool 202 to execute accordingly. Debug tool 200 may also read the log file. Various information of the simulation process can be included in the log file, including information of simulation errors, a row number of error reporting, a time when the simulation errors occur, and the like.

It will be appreciated that in addition to interfacing with simulation tool 202, debug tool 200 may also interface with a hardware simulator (emulator).

Before the logic system design is put into practical operation, the compiled logic system design needs to be debugged in operation by using the debugging tool 200. The debugging tool 200 may receive user instructions 212 from a user and make corresponding debugging actions. In some embodiments, the user may issue the user instruction 212 in the graphical interface by clicking a mouse; in some embodiments, a user may enter a command line in the command line interface to issue user instructions 212. If the logic system design is found to be abnormal in the debugging process, further diagnosis needs to be performed on the found abnormality, the reason and the specific source position of the abnormality need to be found, and correction is performed, so that the robustness of the logic system design is ensured.

As mentioned above, large software has more functional modules, which results in longer startup time. And the aforementioned debugging tools also belong to such software. For example, during logic system design debugging, conventional debugging tools can typically provide a number of functions, such as waveform debugging, coverage debugging, source code debugging, circuit diagram debugging, and the like. These debugging functions are coordinated but can also be used independently. This requires that the debugging tool should have various functional modules required for debugging, resulting in a large number of functional modules of the debugging software as the debugging tool and a slow start speed. It is noted that there is rarely software such as EDA debugging tools, requiring that so many independent and associated functions be provided in one piece of software.

Usually, the debugging software needs to start all the functional modules of the software when being started for the first time, but some functional modules may not be used in a single debugging, so that the unused functional modules are started together, the starting time is prolonged, and more system CPU resources are occupied, so that the running speed of the computer is slowed down.

As an alternative solution, a dedicated software may be designed that has only some of the functionality of a large piece of software, for example, a waveform viewer that has only the functionality to view waveforms. By the method, the requirement that a user only checks the waveform is met, the software starting speed can be increased, and meanwhile, the consumption of CPU resources can be reduced. However, when the user needs to check the source code according to the waveform, the user still needs to reopen the complete debugging software, and the operation becomes complicated.

Therefore, how to enable the user to use a part of the functions of the software and the whole functions of the software is a technical problem worthy of research.

In view of this, embodiments of the present application provide a method, an apparatus, and a storage medium for starting software according to functions, so that the whole software may start only one or part of functions by generating only a first window corresponding to a first function of the software when receiving a first instruction to start the first function and generating a second window corresponding to a second function of the software after receiving a second instruction to start the second function, thereby reducing start time and system resources required to be consumed.

FIG. 3A illustrates a schematic diagram of an exemplary page 300 according to an embodiment of the application.

In the initial state, the user may open the debugging software in any manner of opening the software (e.g., double-clicking the software icon), and may enter the page 300, as shown in fig. 3A.

In some embodiments, host 100, in response to the instruction to open the debug software, may first load the base program resources for running the debug software. The base program resources may be framework (frame) resources for supporting underlying logic of specific functional modules of the debugging software, which may not include program resources of the specific functional modules. In this way, by loading only the underlying program resources and not the program resources of a particular functional module, consumption of system resources may be reduced while the speed of opening the software may be increased (e.g., the time from double-clicking a software icon to opening page 300 can be appreciably reduced). It will be appreciated that in order to present an interface for a user to select a particular functional module in an initial state, the underlying program resources may also include program resources that are rendered to generate the page 300 shown in FIG. 3A.

With continued reference to FIG. 3A, it can be seen that in the initial state, page 300 may not have any particular functional windows open, but rather a blank page is displayed. At this time, the user can select a certain function to turn on according to actual needs.

FIG. 3B illustrates a schematic diagram of another exemplary page 310 according to an embodiment of the application.

As an alternative embodiment, as shown in FIG. 3B, when the user opens the debug software, host 100, in response to the instruction, may present a function selection window 302 in the page 310 at the same time as the main window, as shown in FIG. 3B. The function selection window 302 may provide a plurality of selectable options 3022 to 3028 of the function. The user may send an instruction to the host 100 to start a function to be started by selecting the function to be started among the options 3022 to 3028 (e.g., double-clicking the option 3026 to issue an instruction to start the corresponding function). In some embodiments, as shown in fig. 3B, the options 3022 to 3028 may be presented in the window 302 in the form of icons, so that the user can intuitively know what the function corresponding to the option is, and the use is more convenient. For example, if the user selects option 3026, which corresponds to the function of displaying the circuit diagram of the chip design, as shown in fig. 3C, the circuit diagram of the chip design currently being debugged by the debugging software may be displayed in window 3041 of page 320.

FIG. 3C illustrates a schematic diagram of yet another exemplary page 320 according to an embodiment of the present application.

In some embodiments, the manner of opening a certain function of the software may be to send an instruction to the host 100 to start the function by calling out a command line input window (not shown in the figure) to input a corresponding command line, for example, a parameter of the corresponding function may be attached to the command when the command to start the function is input, so that the host 100 can know which function should be started after receiving the command. For example, xschematic-schdb xnlllib. As shown in FIG. 3C, debug tool 200 displays page 320, which includes a view circuitry function 304, in accordance with the commands described above. Wherein xshiematic is the product name of the functional module, -schdb is the specified parameter, and xnllib. In response to the command, the host 100 may activate the functional module corresponding to the corresponding chip design.

After receiving an instruction to start a certain function (first function) of the debugging software, the host 100 may load a program resource (first program resource) for executing the function to start the function, the execution of the program resource of the function being dependent on the aforementioned basic program resource.

As can be seen from fig. 3C, since a function can be started independently, the debugging software does not need to start all functional modules, so that the starting speed can be increased. And, because only the started functional module can be run and other functions of the debugging software can not be started when not needed, the resource consumption is reduced.

The user may then continue to activate the second function upon activation of the first function. For example, the user may initiate the second function by inputting an instruction (e.g., a command line) to initiate the second function. For another example, the window 302 in fig. 3B can be called up by inputting a shortcut instruction, and then a second function to be activated is selected from the window to activate the corresponding function. For a specific implementation manner, reference is made to the foregoing embodiment for starting the first function, which is not described herein again.

Thus, in response to receiving a second instruction to initiate a second function of the debugging software, the host 100 may load a second program resource for executing the second function, the execution of the second program resource being dependent on the aforementioned base program resource. Thus, when the second function is started, the basic program resource does not need to be reloaded, but the second program resource of the second function can be further loaded on the loaded basic program resource, so that the second function can be started, and the starting time can be reduced. And, because there is no need to reload the basic program resource, the resource consumption is also reduced.

After loading the second program resource, a second window corresponding to the second function may be further generated.

FIG. 3D illustrates a schematic diagram of yet another exemplary page 330 according to an embodiment of the present application.

As an alternative embodiment, taking the second function to be started as the source code of the chip design as an example, as shown in FIG. 3D, a function 306 for exposing the source code may be further provided in the page 330 and may be exposed in the window 3061. In this way, the user can view the circuit diagram and the source code of the chip design in the page 330, so that the user can debug the chip design conveniently. Since only the second function is additionally activated, the activation time can also be shortened, and the resource consumption can also be reduced.

It can be understood that, under the idea of this embodiment, the user can further start the third function, the fourth function, and the like of the debugging software in a similar manner, so that the corresponding functions can be started in a shorter starting time, and a relatively lower resource consumption rate can be maintained in the case of starting a plurality of functions.

In some embodiments, when the user continues to start the second function based on the first function, it may be considered that the user wants to use the complete debugging software to complete more complicated debugging work, and therefore, in response to receiving a second instruction to start the second function of the debugging software, the host 100 may load all program resources of the debugging software and start the complete function of the debugging software, then generate a third window corresponding to the debugging software, and include, in the third window, the first window corresponding to the first function and the second window corresponding to the second function.

FIG. 3E shows a schematic diagram of yet another exemplary page 340 according to an embodiment of the application.

As shown in fig. 3E, taking the example that the complete software includes four functions, a function 304 of viewing a circuit diagram, a function 306 of viewing source code, a function 308 of viewing a waveform diagram, and a function 310 of viewing signal coverage are shown in a page 340. It is understood that the functions in fig. 3E are only exemplary, and in fact, the debugging software may include more functions and may correspondingly exhibit more functions according to different requirements, for example, viewing a schematic diagram of a chip design, and the like.

Thus, the debugging software is completely started under the trigger of the second instruction for starting the second function, so that a user can carry out more complicated and specific debugging work and better use the debugging software.

In some scenarios, a user may wish to have more flexible operation possible with debugging software. For example, some degree of interaction is achieved between different functional windows. Thus, in some embodiments, a functional window may include objects operable to enable interaction with other functional windows. As shown in fig. 3E, the functional window 304 is taken as an example, and the operable objects may include circuit elements 3042 to 3048 in the circuit diagram.

A schematic diagram of the interaction between the two

windows

304 and 308 is shown in fig. 3F. As shown in fig. 3F, the user selects a circuit element 3044 in the window 304 and drags it into the window 308 in the direction indicated by the arrow. In response to receiving an instruction to drag circuit element 3044 to window 308, host 100 may accordingly present a waveform diagram corresponding to circuit element 3044 in window 308, as shown in fig. 3F. Therefore, the user can display the other function of the object in a certain function window in the corresponding function window in the interactive operation mode, the operation is convenient, and the user experience is improved.

It is to be understood that the above examples only schematically illustrate the interaction manner of the operable objects in the window with other windows, and based on similar ideas, the operable objects in other functional windows of the present application may also implement interaction with other windows in a similar manner, and these modified embodiments also should fall into the scope of the present application.

The embodiment of the application also provides a method for starting the software according to the function.

FIG. 4 shows a flow diagram of a method 400 of launching software per function according to an embodiment of the application. Method 400 may be performed by host 100 of fig. 1, and more specifically, by debug tool 200 running on host 100. The method 400 may include the following steps.

At step 402, debug tool 200 receives a first instruction (e.g., user instruction 212 of FIG. 2) to initiate a first function (e.g., function 304 of FIG. 3C) of the software (e.g., debug software).

In some embodiments, the method 400 further comprises: the debugging tool 200 loads basic program resources for running the software; and loading a first program resource for operating the first function, wherein the operation of the first program resource depends on the basic program resource, and the basic program resource can be used for providing an operating environment for the first function and ensuring the operation of the first function.

At step 404, the debugging tool 200 generates a first window (e.g., window 3041 of fig. 3C) corresponding to the first function, so that the user can view and use the first function based on the first window, and at the same time, the software does not need to be completely started, thereby shortening the starting time and reducing the resource consumption.

At step 406, debug tool 200 receives a second instruction that initiates a second function of the software (e.g., function 306 of FIG. 3D).

In some embodiments, prior to generating the second window corresponding to the second function, the method 400 further comprises: the debugging tool 200 loads a second program resource for operating the second function, the operation of the second program resource depends on the basic program resource, the operation of the second program resource also depends on the basic program resource, and the basic program resource can be used for providing an operating environment for the second function to ensure the operation of the second function. Meanwhile, basic program resources do not need to be reloaded, starting time is shortened, and resource consumption is reduced.

At step 408, in response to receiving a second instruction to initiate a second function of the software, debugging tool 200 generates a second window (e.g., window 3061 of FIG. 3D) corresponding to the second function.

In some embodiments, to generate a second window corresponding to the second function, debugging tool 200 may further: in response to receiving a second instruction for starting a second function of the software, a third window corresponding to the software is generated, where the third window includes the first window and the second window, as shown in fig. 3E.

In some embodiments, the first window includes an operable object (e.g., circuit elements 3042-3048 of FIG. 3E); the method 400 further comprises: in response to receiving a third instruction to drag the object to the second window, presenting the second function corresponding to the object in the second window, as shown with reference to fig. 3F. Therefore, the user can display the other function of the object in a certain function window in the corresponding function window in the interactive operation mode, the operation is convenient, and the user experience is improved.

In some embodiments, the software is chip debug software, and the first function or the second function includes at least one of a waveform diagram, source code, a circuit diagram, and a schematic diagram showing a chip design.

Thus, with the method 400, only the first window corresponding to the first function is generated when the first instruction for starting the first function of the software is received, and the second window corresponding to the second function is generated after the second instruction for starting the second function of the software is received, so that the whole software can only start one or part of functions, and the starting time and the consumed system resources are reduced. The second function may be a complete function of the software. In addition to speeding up the start-up of the first function, since the underlying resources of the software are already loaded when the second function is started, it is not necessary to shut down the first function or reload the underlying resources when the second function or the complete function of the software is started, which also speeds up the start-up of the second function.

The embodiment of the application also provides the electronic equipment. The electronic device may be the host 100 of fig. 1. The electronic device may include a memory to store a set of instructions; and at least one processor configured to execute the set of instructions to cause the electronic device to perform method 400.

Embodiments of the present application also provide a non-transitory computer-readable storage medium. The non-transitory computer-readable storage medium stores a set of instructions for a computer that, when executed, cause the computer to perform the method 400.

Some embodiments of the present application are described above. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.

Those of ordinary skill in the art will understand that: the discussion of any embodiment above is meant to be exemplary only, and is not intended to intimate that the scope of the disclosure, including the claims, is limited to these examples; within the context of the present application, features from the above embodiments or from different embodiments may also be combined, steps may be implemented in any order, and there are many other variations of the different aspects of the present application as described above, which are not provided in detail for the sake of brevity.

While the present application has been described in conjunction with specific embodiments thereof, many alternatives, modifications, and variations of these embodiments will be apparent to those skilled in the art in light of the foregoing description. For example, other memory architectures, such as Dynamic RAM (DRAM), may use the discussed embodiments.

The present application is intended to embrace all such alternatives, modifications and variances which fall within the broad scope of the appended claims. Therefore, any omissions, modifications, substitutions, improvements, and the like that may be made without departing from the spirit and principles of the application are intended to be included within the scope of the application.

Claims

1. A method of launching software in accordance with a function, comprising:

receiving a first instruction for starting a first function of the software;

generating a first window corresponding to the first function;

and generating a second window corresponding to a second function of the software in response to receiving a second instruction for starting the second function.

2. The method of claim 1, wherein prior to generating the first window corresponding to the first function, the method further comprises:

loading basic program resources for running the software; and

loading a first program resource for executing the first function, the execution of the first program resource being dependent on the base program resource.

3. The method of claim 2, wherein prior to generating the second window corresponding to the second function, the method further comprises:

loading a second program resource for executing the second function, the execution of the second program resource being dependent on the base program resource.

4. The method of claim 1, wherein generating a second window corresponding to a second function of the software in response to receiving a second instruction to initiate the second function further comprises:

and generating a third window corresponding to the software in response to receiving a second instruction for starting a second function of the software, wherein the third window comprises the first window and the second window.

5. The method of claim 1, wherein the first window comprises an actionable object, the method further comprising:

in response to receiving a third instruction to drag the object to the second window, presenting the second function corresponding to the object in the second window.

6. The method of claim 1, wherein the software is chip debug software, and the first function or the second function comprises displaying at least one of a waveform diagram, source code, a circuit diagram, and a schematic diagram of a chip design.

7. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable by the processor, the processor implementing the method of any one of claims 1 to 6 when executing the program.

8. A non-transitory computer-readable storage medium storing computer instructions for causing a computer to perform the method of any one of claims 1-6.