CN109426529B - Method, device and terminal for drawing graphics based on X window system - Google Patents
Method, device and terminal for drawing graphics based on X window system Download PDFInfo
- Publication number
- CN109426529B CN109426529B CN201710703287.8A CN201710703287A CN109426529B CN 109426529 B CN109426529 B CN 109426529B CN 201710703287 A CN201710703287 A CN 201710703287A CN 109426529 B CN109426529 B CN 109426529B
- Authority
- CN
- China
- Prior art keywords
- instruction
- acceleration
- target
- target instruction
- acceleration instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T1/00—General purpose image data processing
- G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Processing Or Creating Images (AREA)
- Image Generation (AREA)
Abstract
The embodiment of the invention provides a method, a device and a terminal for drawing a graph based on an X window system. According to the embodiment of the invention, a target instruction is obtained, and if the target instruction is a hardware acceleration instruction, a corresponding graph drawing function is called; acquiring a next acceleration instruction, if the next acceleration instruction is still a hardware acceleration instruction, temporarily not calling a hardware synchronization function, and continuously processing the next acceleration instruction; if the next acceleration instruction is a software acceleration instruction, calling a hardware synchronization function, synchronizing system data, and then processing the next acceleration instruction; therefore, when the at least two hardware acceleration instructions are continuously executed, the graph drawing function corresponding to each hardware acceleration instruction is sequentially called, the at least two hardware acceleration instructions are continuously submitted to the GPU, and after the hardware acceleration instructions submitted to the GPU are processed, the hardware synchronization function is called once to complete system data synchronization of the hardware acceleration instructions, the advantages of the GPU are better exerted, and the performance of the X window system is improved.
Description
Technical Field
The embodiment of the invention relates to the technical field of window graphic systems, in particular to a method, a device and a terminal for drawing a graphic based on an X window system.
Background
The X Window System (X Window System) is a bitmap drawing-based Unix-like Window graphics System, provides a basic graphics framework protocol, and has been commonly applied to Linux, unix and other operating systems. The X window system is used to draw and present images and moving program windows on a screen, and also to accept, run, and manage interactive programs with a mouse, keyboard, touch screen, and the like. The hardware acceleration layer in the X-window Graphics system is generally implemented by using a Graphics Processing Unit (GPU). A GPU is a microprocessor that is dedicated to image computing work on personal computers, workstations, game consoles and some mobile devices (e.g., tablet computers, smart phones, etc.). The GPU is specially designed for optimization of a large number of parallel operation cores, can process a plurality of rendering pipelines and RGBA4 color channels in parallel, and can acquire 2 or more secondary textures in parallel in one clock cycle.
In practical application, the upper layer application acquires a graphic output request input by a user through a mouse, a keyboard, a touch screen or the like, calls an X window system and sends a graphic drawing command to the X window system. The X window system converts the graphic drawing command into at least one acceleration instruction, and the acceleration instruction is processed by the following steps: and calling a corresponding graph drawing function according to the acceleration instruction to execute a graph drawing task, and calling a corresponding synchronization function to complete system data synchronization after the graph drawing is completed. After the graphics rendering function responsive to the previous acceleration instruction is executed, the X-windowing system begins processing the next acceleration instruction.
At present, the advantage of GPU parallel processing data cannot be exerted in the process of drawing graphics by an X window system, so that the performance of the X window system is low. Therefore, there is a need for an optimization method of an X window system to improve the performance of the X window system.
Disclosure of Invention
The embodiment of the invention provides a method, a device and a terminal for drawing a graph based on an X window system, which aim to solve the problem that the performance of the X window system is low because the advantage of parallel data processing of a GPU cannot be exerted in the process of drawing the graph of the current X window system.
One aspect of the embodiments of the present invention is to provide a method for drawing a graph based on an X window system, including:
acquiring a target instruction, and judging the instruction type of the target instruction, wherein the instruction type comprises a hardware acceleration instruction and a software acceleration instruction;
according to the instruction type of the target instruction, carrying out drawing processing on the target instruction, and executing the following drawing processing steps:
if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction;
acquiring a next acceleration instruction executed after the target instruction, and judging the instruction type of the next acceleration instruction;
if the next acceleration instruction is a hardware acceleration instruction, performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction;
if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction.
Another aspect of the embodiments of the present invention is to provide an apparatus for drawing a graph based on an X window system, including:
the system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a target instruction and judging the instruction type of the target instruction, and the instruction type comprises a hardware acceleration instruction and a software acceleration instruction;
the drawing processing module is used for drawing the target instruction according to the instruction type of the target instruction and executing the following drawing processing steps:
if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction;
acquiring a next acceleration instruction executed after the target instruction, and judging the instruction type of the next acceleration instruction;
if the next acceleration instruction is a hardware acceleration instruction, performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction;
if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction.
Another aspect of the embodiments of the present invention is to provide a terminal equipped with an X window system, including:
a processor, a memory, and a computer program stored on the memory and executable by the processor,
the computer program run by the processor realizes the method for drawing the graph based on the X window system.
According to the method, the device and the terminal for drawing the graph based on the X window system, provided by the embodiment of the invention, after the target instruction is determined to be a hardware acceleration instruction and the graph drawing task corresponding to the target instruction is completed by calling the graph drawing function corresponding to the target instruction, the next acceleration instruction is continuously obtained, the instruction type of the next acceleration instruction is judged, if the next acceleration instruction is determined to be still a hardware acceleration instruction, at least one hardware acceleration instruction is determined to be required to be continuously processed, a hardware synchronization function is not called temporarily, and the next acceleration instruction is continuously processed; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instructions are not processed continuously, calling a hardware synchronization function after the graphics drawing function corresponding to each hardware acceleration instruction is executed, performing system data synchronization, and processing the next acceleration instruction, so that when at least two hardware acceleration instructions are executed continuously, calling the graphics drawing function corresponding to each hardware acceleration instruction in sequence, submitting at least two hardware acceleration instructions to the GPU continuously, and calling the hardware synchronization function once after the hardware acceleration instructions submitted to the GPU are processed, the system data synchronization of the hardware acceleration instructions can be completed, the advantages of the GPU are better exerted, and the performance of an X window system is improved.
Drawings
Fig. 1 is a flowchart of a method for drawing a graph based on an X window system according to an embodiment of the present invention;
FIG. 2 is a flowchart of a method for drawing graphics based on an X-window system according to a second embodiment of the present invention;
FIG. 3 is a flowchart of a method for drawing graphics based on an X-window system according to a third embodiment of the present invention;
fig. 4 is a schematic structural diagram of an apparatus for drawing a graph based on an X window system according to a fourth embodiment of the present invention;
fig. 5 is a schematic structural diagram of an apparatus for drawing a graph based on an X window system according to a sixth embodiment of the present invention;
fig. 6 is a schematic structural diagram of a terminal according to a seventh embodiment of the present invention.
Detailed Description
In order to make the technical solutions and advantages of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Example one
Fig. 1 is a flowchart of a method for drawing a graph based on an X window system according to an embodiment of the present invention. The embodiment of the invention provides a method for drawing a graph based on an X window system, aiming at the problem that the performance of the X window system is low because the advantage of GPU parallel processing data cannot be exerted in the process of drawing the graph by the current X window system, and as shown in figure 1, the method comprises the following specific steps:
step S101, acquiring a target instruction, and determining the instruction type of the target instruction, wherein the instruction type comprises a hardware acceleration instruction and a software acceleration instruction.
Wherein, the target instruction is an acceleration instruction to be processed.
In this embodiment, the acceleration instruction may include the following instruction information: instruction identification, instruction type, acceleration interface type, graph drawing function parameter, graph drawing function interface and synchronous function interface.
In particular, the instruction type is used to indicate that the acceleration instruction is one of a hardware acceleration instruction and a software acceleration instruction. The graphics drawing function interface is configured to point to a graphics drawing function corresponding to the acceleration instruction, and may be a pointer pointing to the graphics drawing function corresponding to the acceleration instruction. And the X window system calls a graph drawing function corresponding to the acceleration instruction so as to complete the graph drawing task corresponding to the acceleration instruction.
The acceleration interface type corresponds to an instruction type, and the acceleration interface type is used for representing the type of the image drawing function and comprises a hardware type and a software type. Generally, if the acceleration instruction type is a hardware acceleration instruction, the acceleration interface type of the acceleration instruction is a hardware type, and if the acceleration instruction type is a software acceleration instruction, the acceleration interface type of the acceleration instruction is a software type. If the acceleration interface type of the acceleration instruction is the hardware type, the image drawing function of the acceleration instruction is the hardware image drawing function; and if the acceleration interface type of the acceleration instruction is a software type, the image drawing function of the acceleration instruction is a software image drawing function.
The graphic drawing function parameter refers to an input parameter of the graphic drawing function, and the image drawing function parameter can be determined according to the type of an acceleration interface or the type of an acceleration instruction.
The synchronization function interface is configured to point to a synchronization function corresponding to the acceleration instruction, and may be a pointer to the synchronization function corresponding to the acceleration instruction. In practical application, the synchronization function comprises a hardware synchronization function and a software synchronization function, and the X window system completes synchronization of system graph drawing tasks by calling the hardware synchronization function or the software synchronization function.
In this embodiment, if the acceleration instruction is a hardware acceleration instruction, the synchronous function interface in the acceleration instruction points to a hardware synchronous function, and if the acceleration instruction is a software acceleration instruction, the synchronous function interface in the acceleration instruction points to a software synchronous function.
After the instruction type of the target instruction is determined in this step S101, the following steps S102 to S105 are performed to perform drawing processing on the target instruction according to the instruction type of the target instruction. In this embodiment, the process of performing the drawing processing on all the hardware acceleration instructions is the same, and the process of performing the drawing processing on all the software acceleration instructions is the same.
And S102, if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction.
In this embodiment, a graph drawing function corresponding to the target instruction is called according to a graph drawing function interface in the target instruction, and a graph drawing task corresponding to the target instruction is completed by executing the graph drawing function corresponding to the target instruction.
In this step, if the acceleration instruction is a hardware acceleration instruction, the hardware acceleration instruction is submitted to the GPU by calling a drawing and drawing function corresponding to the hardware acceleration instruction, so that the GPU executes a drawing and drawing function corresponding to the hardware acceleration instruction to complete a drawing task of the hardware acceleration instruction.
Calling a graph drawing function corresponding to any acceleration instruction to complete a graph drawing task corresponding to the acceleration instruction, which can be specifically realized by adopting the following method:
firstly, judging the type of an acceleration interface of an acceleration instruction, then filling in corresponding graphic drawing function parameters according to the type of the acceleration interface, and finally calling a graphic drawing function corresponding to the acceleration instruction to realize a graphic drawing task of the instruction. When the graph drawing functions corresponding to the acceleration instructions are called, the graph drawing functions corresponding to different acceleration instructions are different, and the parameters of the graph drawing functions corresponding to different acceleration instructions are different. The graphic rendering function parameters include the following 4 types: a rectangle type drawing parameter, a line type drawing parameter, a no-stretch copy type drawing parameter, and a vector copy type drawing parameter.
In this embodiment, the graphics rendering function corresponding to the acceleration instruction is called to complete the graphics rendering task corresponding to the acceleration instruction, and any one of the graphics rendering functions corresponding to the acceleration instruction may be called in the prior art, or the acceleration instruction is submitted to the GPU, which is not described herein again.
Step S103, acquiring a next acceleration instruction executed after the target instruction, and determining an instruction type of the next acceleration instruction.
If the target instruction is a hardware acceleration instruction, after the graph drawing function corresponding to the target instruction is called, a next acceleration instruction executed after the target instruction can be immediately obtained, and the instruction type of the next acceleration instruction is judged, without waiting for the hardware synchronization function corresponding to the target instruction to be called after the graph drawing function corresponding to the target instruction is executed, and obtaining the next acceleration instruction after the hardware synchronization function corresponding to the target instruction is executed.
In this step, in step S102, it is determined that the target instruction is a hardware acceleration instruction, and after the graphics drawing task corresponding to the target instruction is completed by calling a graphics drawing function corresponding to the target instruction, a next acceleration instruction is continuously obtained, and an instruction type of the next acceleration instruction is determined, if it is determined that the next acceleration instruction is still a hardware acceleration instruction, it is determined that at least one hardware acceleration instruction needs to be continuously processed, a hardware synchronization function is not temporarily called, and the next acceleration instruction is continuously processed; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instruction is not processed continuously, calling a hardware synchronization function after the execution of the graph drawing function corresponding to each hardware acceleration instruction which has been called is completed, carrying out system data synchronization, and then processing the next acceleration instruction.
And step S104, if the next acceleration instruction is a hardware acceleration instruction, drawing the next acceleration instruction according to the instruction type of the next acceleration instruction.
In this step, if it is determined that the next acceleration instruction is still a hardware acceleration instruction, it is determined that at least one hardware acceleration instruction needs to be continuously processed, and the next acceleration instruction continues to be processed without calling the hardware synchronization function for the moment.
In this embodiment, if the next acceleration instruction is a hardware acceleration instruction, the process of performing the drawing processing on the next acceleration instruction is the same as the process of performing the drawing processing on the target instruction. In this step, according to the instruction type of the next acceleration instruction, the next acceleration instruction is subjected to drawing processing, which may be specifically implemented in the following manner:
taking the next acceleration instruction as a new target instruction, and returning to the step S102 to call a graph drawing function corresponding to the new target instruction to complete a graph drawing task corresponding to the new target instruction because the instruction type of the next acceleration instruction is a hardware acceleration instruction, that is, the instruction type of the new target instruction is the hardware acceleration instruction; and continues to step S103, acquires the next acceleration instruction executed after the new target instruction, and determines the instruction type of the next acceleration instruction, and continues to step S104 or step S105.
In this embodiment, when the at least two hardware acceleration instructions are continuously executed, the above steps S102 to S104 are cyclically executed, the graphics drawing function corresponding to each hardware acceleration instruction is sequentially called, and the at least two hardware acceleration instructions are continuously submitted to the GPU, so that the GPU can process the at least two hardware acceleration instructions in parallel until the next acceleration instruction is a software acceleration instruction, and step S105 is executed.
And step S105, if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and drawing the next acceleration instruction according to the instruction type of the next acceleration instruction.
In this step, if the next acceleration instruction is a software acceleration instruction, it indicates that after at least one hardware acceleration instruction is continuously processed, the next acceleration instruction is a software acceleration instruction, a synchronization function corresponding to a target instruction is called, a graph drawing synchronization function corresponding to the target instruction is a hardware synchronization function, system data synchronization is performed by calling the hardware synchronization function, then the next acceleration instruction is used as a new target instruction, and steps S101 to S105 are executed in a loop, and drawing processing is continuously performed on the next acceleration instruction.
In this embodiment, the process of performing the drawing processing on the software acceleration instruction is the same as that in the prior art, that is, a graph drawing function corresponding to the software acceleration instruction is called, the software acceleration instruction is submitted to a corresponding software module, so that the corresponding software module executes the drawing function corresponding to the software acceleration instruction to complete the drawing task of the software acceleration instruction, a software synchronization function is called after the corresponding graph drawing function is executed, and the next acceleration instruction is processed after the software synchronization function is executed, which is not described herein again.
The method comprises the steps of obtaining a target instruction, continuously obtaining a next acceleration instruction after a graph drawing task corresponding to the target instruction is completed by determining that the target instruction is a hardware acceleration instruction and calling a graph drawing function corresponding to the target instruction, judging the instruction type of the next acceleration instruction, and if the next acceleration instruction is determined to be still the hardware acceleration instruction, determining that at least one hardware acceleration instruction needs to be continuously processed, temporarily not calling a hardware synchronization function, and continuously processing the next acceleration instruction; if the next acceleration instruction is determined to be a software acceleration instruction, the hardware acceleration instruction is determined not to be processed continuously, after the graphics drawing function corresponding to each hardware acceleration instruction which is called is executed, the hardware synchronization function is called, system data synchronization is carried out, then the next acceleration instruction is processed, the graphics drawing function corresponding to each hardware acceleration instruction is called in sequence when at least two hardware acceleration instructions are executed continuously, at least two hardware acceleration instructions are submitted to the GPU continuously, and after the hardware acceleration instruction submitted to the GPU is processed, the system data synchronization of a plurality of hardware acceleration instructions can be completed by calling the hardware synchronization function once, the advantages of the GPU are brought into full play, and the performance of an X window system is improved.
Example two
Fig. 2 is a flowchart of a method for drawing a graph based on an X window system according to a second embodiment of the present invention. On the basis of the first embodiment, in this embodiment, if the target instruction is a software acceleration instruction, a graph drawing function corresponding to the target instruction is called, and after the graph drawing function corresponding to the target instruction is executed, a synchronization function corresponding to the target instruction is called; and acquiring a next acceleration instruction executed after the target instruction, judging the instruction type of the next acceleration instruction, and performing drawing processing according to the instruction type of the next acceleration instruction. As shown in fig. 2, the method comprises the following specific steps:
step S201, obtaining a target instruction, and determining an instruction type of the target instruction, where the instruction type includes a hardware acceleration instruction and a software acceleration instruction.
Step S201 is similar to step S101, and is not described herein again.
In this embodiment, if it is determined that the target instruction is a hardware acceleration instruction, steps S202 to S207 are performed; if the target instruction is determined to be a software acceleration instruction, step S208 is executed.
Step S202, if the target instruction is a hardware acceleration instruction, a graph drawing function corresponding to the target instruction is called to complete a graph drawing task corresponding to the target instruction.
Step S202 is similar to step S102, and the description of this embodiment is omitted here.
Step S203, determine whether the target instruction is the last acceleration instruction to be executed.
If the target instruction is determined to be the last acceleration instruction to be executed, executing step S204, and after the graphics drawing function corresponding to the target instruction is executed, calling a synchronization function corresponding to the target instruction; if it is determined that the target instruction is not the last acceleration instruction to be executed, step S205 is executed to obtain the next acceleration instruction executed after the target instruction, and perform the subsequent processing procedure.
And step S204, after the graph drawing function corresponding to the target instruction is executed, calling a synchronous function corresponding to the target instruction.
When the target instruction is determined to be the last acceleration instruction to be executed, after the graph drawing function corresponding to the target instruction is executed, calling a synchronization function corresponding to the target instruction, and after system data synchronization is completed, ending the graph drawing process.
Step S205, a next acceleration instruction executed after the target instruction is acquired, and an instruction type of the next acceleration instruction is determined.
If the target instruction is a hardware acceleration instruction, after the graph drawing function corresponding to the target instruction is called, a next acceleration instruction executed after the target instruction can be immediately obtained, and the instruction type of the next acceleration instruction is judged, without waiting for the hardware synchronization function corresponding to the target instruction to be called after the graph drawing function corresponding to the target instruction is executed, and obtaining the next acceleration instruction after the hardware synchronization function corresponding to the target instruction is executed.
In this step, in step S202, it is determined that the target instruction is a hardware acceleration instruction, and after the graphics drawing task corresponding to the target instruction is completed by calling a graphics drawing function corresponding to the target instruction, a next acceleration instruction is continuously obtained, and an instruction type of the next acceleration instruction is determined, if it is determined that the next acceleration instruction is still a hardware acceleration instruction, it is determined that at least one hardware acceleration instruction needs to be continuously processed, a hardware synchronization function is not temporarily called, and the next acceleration instruction is continuously processed; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instruction is not processed continuously, calling a hardware synchronization function after the execution of the graph drawing function corresponding to each hardware acceleration instruction which has been called is completed, carrying out system data synchronization, and then processing the next acceleration instruction.
Step S206, if the next acceleration instruction is a hardware acceleration instruction, performing a drawing process on the next acceleration instruction according to an instruction type of the next acceleration instruction.
In this step, if it is determined that the next acceleration instruction is still a hardware acceleration instruction, it is determined that at least one hardware acceleration instruction needs to be continuously processed, and the next acceleration instruction continues to be processed without calling the hardware synchronization function for the moment.
In this embodiment, if the next acceleration instruction is a hardware acceleration instruction, the process of performing the drawing processing on the next acceleration instruction is the same as the process of performing the drawing processing on the target instruction. In this step, according to the instruction type of the next acceleration instruction, the next acceleration instruction is subjected to drawing processing, which may be specifically implemented in the following manner:
taking the next acceleration instruction as a new target instruction, and returning to step S202 to call a graph drawing function corresponding to the new target instruction to complete a graph drawing task corresponding to the new target instruction because the instruction type of the next acceleration instruction is a hardware acceleration instruction, that is, the instruction type of the new target instruction is a hardware acceleration instruction; and proceeds to steps S203-207.
In this embodiment, when at least two hardware acceleration instructions are continuously executed, the steps S202 to S206 are cyclically executed, the graphics rendering function corresponding to each hardware acceleration instruction is sequentially called, and the at least two hardware acceleration instructions are continuously submitted to the GPU, so that the GPU can process the at least two hardware acceleration instructions in parallel until the next acceleration instruction is a software acceleration instruction, and step S207 is executed.
Step S207, if the next acceleration instruction is a software acceleration instruction, a synchronization function corresponding to the target instruction is called, and drawing processing is performed on the next acceleration instruction according to the instruction type of the next acceleration instruction.
In this step, if the next acceleration instruction is a software acceleration instruction, which means that after at least one hardware acceleration instruction is continuously processed, the next acceleration instruction is a software acceleration instruction, a synchronization function corresponding to the target instruction is called, a graphics drawing synchronization function corresponding to the target instruction is a hardware synchronization function, system data synchronization is performed by calling the hardware synchronization function, then the next acceleration instruction is used as a new target instruction, and steps S201 to S208 are executed in a loop, so that drawing processing is continuously performed on the next acceleration instruction.
And step S208, if the target instruction is a software acceleration instruction, calling a graph drawing function corresponding to the target instruction, and calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed.
In this embodiment, the process of performing the drawing processing on the software acceleration instruction is the same as that in the prior art, that is, a graph drawing function corresponding to the software acceleration instruction is called, the software acceleration instruction is submitted to a corresponding software module, so that the corresponding software module executes the drawing function corresponding to the software acceleration instruction to complete the drawing task of the software acceleration instruction, and after the corresponding graph drawing function is executed, a software synchronization function is called to perform system data synchronization.
After step S208, a next acceleration instruction executed after the target instruction is acquired as a new target instruction, and steps S201 to S208 are executed in a loop to determine an instruction type of the next acceleration instruction, and drawing processing is performed according to the instruction type of the next acceleration instruction.
The embodiment of the invention provides a more detailed graph drawing process, wherein after a target instruction is determined to be a hardware acceleration instruction and a graph drawing task corresponding to the target instruction is completed by calling a graph drawing function corresponding to the target instruction, a next acceleration instruction is continuously obtained and the instruction type of the next acceleration instruction is judged, if the next acceleration instruction is still determined to be the hardware acceleration instruction, at least one hardware acceleration instruction is determined to be required to be continuously processed, a hardware synchronization function is not called temporarily, and the next acceleration instruction is continuously processed; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instructions are not processed continuously, calling a hardware synchronization function after the graphics drawing function corresponding to each hardware acceleration instruction is executed, performing system data synchronization, and then processing the next acceleration instruction.
EXAMPLE III
Fig. 3 is a flowchart of a method for drawing a graph based on an X window system according to a third embodiment of the present invention. On the basis of any of the above embodiments, in this embodiment, before acquiring the target instruction, the method further includes: creating an instruction queue; and sequentially adding the acceleration instructions to be executed into the instruction queue in real time according to a preset execution sequence.
Specifically, after the X window system is started, an instruction queue may be created, and after a graphics drawing command sent by an upper application is received and converted into at least one acceleration instruction, each acceleration instruction is packaged into a form that the instruction queue can store, and the packaged acceleration instructions are sequentially added to the instruction queue according to a preset execution sequence. The preset execution sequence may be set according to actual needs of the graph drawing process, and this embodiment does not specifically limit this. Each acceleration instruction stored in the instruction queue includes at least the following instruction information: instruction identification, instruction type, acceleration interface type, graph drawing function parameter, graph drawing function interface and synchronous function interface.
Alternatively, the acceleration instructions in the instruction queue may be implemented in the form of a structure.
For example, the acceleration command includes all the graphics drawing command information of the X-window graphics system, including command id, command type, graphics drawing function interface type, graphics drawing function parameters, graphics drawing function interface, and synchronization function interface. Wherein the graphics rendering function parameters include: drawing parameters of a rectangle type, drawing parameters of a line type, drawing parameters of a no-stretch copy type, and drawing parameters of a vector copy type.
In this embodiment, the process of adding each newly generated acceleration instruction to the instruction queue and the process of obtaining the target instruction from the instruction queue and performing the graph drawing are two relatively independent processes, which can be performed in parallel.
Optionally, when the acceleration instruction is added into the instruction queue, if the instruction queue is full (no remaining space) at the moment, an overflow error is returned; otherwise, adding the acceleration instruction to the tail part of the instruction queue, modifying the instruction counter and the queue tail pointer, and finally returning a success message.
It should be noted that, creating the instruction queue may be implemented by using any method for creating a queue in the prior art, and how to create the instruction queue and the length of the created instruction queue are not specifically limited in this embodiment. In addition, the method for obtaining the acceleration instruction from the head of the instruction queue and adding the acceleration instruction to the tail of the instruction queue may be implemented by any method for taking out a queue element from the head of the queue and any method for adding an element to the tail of the queue in the prior art, and details of this embodiment are not described herein again.
As shown in fig. 3, the method comprises the following specific steps:
step S301, judging whether the instruction queue is empty.
If the instruction queue is determined not to be empty, executing step S302, obtaining a target instruction from the instruction queue, and performing a processing process of drawing a graph; and if the instruction queue is determined to be empty, ending the processing process of drawing the graph.
Step S302, a target instruction is obtained from the instruction queue, and the instruction type of the target instruction is determined, wherein the instruction type comprises a hardware acceleration instruction and a software acceleration instruction.
Preferably, the target instruction is fetched from the head of the instruction queue. Accordingly, an acceleration instruction is added to the tail of the instruction queue to process the acceleration instruction in a preset execution order.
Step S302 is similar to step S201, and the description of this embodiment is omitted here.
Step S303, if the target instruction is a hardware acceleration instruction, a graph drawing function corresponding to the target instruction is called to complete a graph drawing task corresponding to the target instruction.
Step S303 is similar to step S202, and the description of this embodiment is omitted here.
Step S304, judging whether the target instruction is the last instruction in the instruction queue.
This step S304 determines whether the target instruction is the last acceleration instruction to be executed by determining whether the target instruction is the last instruction in the instruction queue.
If it is determined that the target instruction is the last instruction in the instruction queue, step S305 is executed to call a synchronization function corresponding to the target instruction after the graphics drawing function corresponding to the target instruction is executed; if it is determined that the target instruction is not the last instruction in the instruction queue, step S306 is executed to obtain the next acceleration instruction from the instruction queue, and perform the subsequent processing procedure.
Step S305, after the graphics drawing function corresponding to the target instruction is executed, a synchronization function corresponding to the target instruction is called.
Step S305 is similar to step S204, and the description of this embodiment is omitted here.
Step S306, obtaining the next acceleration instruction from the instruction queue, and determining the instruction type of the next acceleration instruction.
Step S307, if the next acceleration instruction is a hardware acceleration instruction, performing drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction.
Step S308, if the next acceleration instruction is a software acceleration instruction, a synchronization function corresponding to the target instruction is called, and drawing processing is performed on the next acceleration instruction according to the instruction type of the next acceleration instruction.
The processing procedure of steps S306-S308 is similar to that of steps S205-S207, and the detailed description is omitted here.
Step 309, if the target instruction is a software acceleration instruction, calling a graph drawing function corresponding to the target instruction, and after the graph drawing function corresponding to the target instruction is executed, calling a synchronization function corresponding to the target instruction.
After step S309 is executed, a new target instruction is obtained from the instruction queue, and steps S301 to S309 are executed in a loop, and the acceleration instruction in the instruction queue continues to be processed.
Preferably, before the target instruction is obtained, the method further comprises: an instruction dispatch thread is created. In this embodiment, after the X window system is started, a command scheduling thread may be created, and the command scheduling thread executes the graphics drawing process in steps S301 to S309, so as to implement uniform scheduling and system data synchronization of the acceleration commands in the command queue by using a special command scheduling thread.
The embodiment of the invention sequentially adds the acceleration instructions to be executed to the instruction queue in real time according to the preset execution sequence by creating the instruction queue; and creating an instruction scheduling thread, and uniformly scheduling the acceleration instructions in the instruction queue and synchronizing system data by the instruction scheduling thread.
Example four
Fig. 4 is a schematic structural diagram of an apparatus for drawing a graph based on an X window system according to a fourth embodiment of the present invention. The apparatus for drawing a graph based on an X window system according to the embodiment of the present invention may execute the processing procedure provided in the method for drawing a graph based on an X window system, as shown in fig. 4, where the apparatus 40 includes: an acquisition module 401 and a drawing processing module 402.
Specifically, the obtaining module 401 is configured to obtain a target instruction and determine an instruction type of the target instruction, where the instruction type includes a hardware acceleration instruction and a software acceleration instruction;
the drawing processing module 402 is configured to perform drawing processing on the target instruction according to the instruction type of the target instruction, and perform the following drawing processing steps:
if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction;
acquiring a next acceleration instruction executed after the target instruction, and judging the instruction type of the next acceleration instruction;
if the next acceleration instruction is a hardware acceleration instruction, drawing the next acceleration instruction according to the instruction type of the next acceleration instruction;
and if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and drawing the next acceleration instruction according to the instruction type of the next acceleration instruction.
The apparatus provided in the embodiment of the present invention may be specifically configured to execute the method embodiment provided in the first embodiment, and specific functions are not described herein again.
The method comprises the steps of obtaining a target instruction, after the target instruction is determined to be a hardware acceleration instruction and a graph drawing function corresponding to the target instruction is called to complete a graph drawing task corresponding to the target instruction, continuously obtaining a next acceleration instruction, judging the instruction type of the next acceleration instruction, if the next acceleration instruction is still determined to be the hardware acceleration instruction, determining that at least one hardware acceleration instruction needs to be continuously processed, temporarily not calling a hardware synchronization function, and continuously processing the next acceleration instruction; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instructions are not processed continuously, calling a hardware synchronization function after the graphics drawing function corresponding to each hardware acceleration instruction is executed, performing system data synchronization, and processing the next acceleration instruction, so that when at least two hardware acceleration instructions are executed continuously, calling the graphics drawing function corresponding to each hardware acceleration instruction in sequence, submitting at least two hardware acceleration instructions to the GPU continuously, and calling the hardware synchronization function once after the hardware acceleration instructions submitted to the GPU are processed, the system data synchronization of the hardware acceleration instructions can be completed, the advantages of the GPU are better exerted, and the performance of an X window system is improved.
EXAMPLE five
On the basis of the fourth embodiment, in this embodiment, the drawing processing module is further configured to:
if the target instruction is a software acceleration instruction, calling a graph drawing function corresponding to the target instruction, and calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed; and acquiring a next acceleration instruction executed after the target instruction, judging the instruction type of the next acceleration instruction, and performing drawing processing according to the instruction type of the next acceleration instruction.
The drawing processing module is also used for determining whether the target instruction is the last acceleration instruction to be executed; if the target instruction is the last acceleration instruction to be executed, calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed; and if the target instruction is determined not to be the last acceleration instruction to be executed, acquiring the next acceleration instruction executed after the target instruction.
The apparatus provided in the embodiment of the present invention may be specifically configured to execute the method embodiment provided in the second embodiment, and specific functions are not described herein again.
The embodiment of the invention provides a more detailed graph drawing process, wherein a target instruction is obtained, after the target instruction is determined to be a hardware acceleration instruction and a graph drawing task corresponding to the target instruction is completed by calling a graph drawing function corresponding to the target instruction, the next acceleration instruction is continuously obtained, the instruction type of the next acceleration instruction is judged, if the next acceleration instruction is determined to be still a hardware acceleration instruction, at least one hardware acceleration instruction needs to be continuously processed, a hardware synchronization function is not called temporarily, and the next acceleration instruction is continuously processed; if the next acceleration instruction is determined to be a software acceleration instruction, determining that the hardware acceleration instructions are not processed continuously, calling a hardware synchronization function after the graphics drawing function corresponding to each hardware acceleration instruction is executed, performing system data synchronization, and then processing the next acceleration instruction.
EXAMPLE six
Fig. 5 is a schematic structural diagram of an apparatus for drawing a graph based on an X window system according to a sixth embodiment of the present invention. On the basis of the fourth or fifth embodiment, as shown in fig. 5, the apparatus 40 further includes: a queue creation module 403 and an instruction addition module 404.
In particular, the queue creation module 403 is used to create an instruction queue.
The instruction adding module 404 is configured to sequentially add the acceleration instructions to be executed to the instruction queue according to a preset execution sequence in real time.
The fetch module 401 is further configured to fetch a target instruction from the instruction queue.
Optionally, as shown in fig. 5, the apparatus 40 further comprises a thread creation module 405. The thread creation module 405 is used to create instruction dispatch threads.
The obtaining module 401 is further configured to instruct the scheduling thread to obtain a target instruction and determine an instruction type of the target instruction, where the instruction type includes a hardware acceleration instruction and a software acceleration instruction;
the drawing processing module 402 is further configured to perform drawing processing on the target instruction by the instruction scheduling thread according to the instruction type of the target instruction.
The apparatus provided in the embodiment of the present invention may be specifically configured to execute the method embodiment provided in the third embodiment, and specific functions are not described herein again.
The embodiment of the invention sequentially adds the acceleration instructions to be executed to the instruction queue in real time according to the preset execution sequence by creating the instruction queue; and creating an instruction scheduling thread, and uniformly scheduling the acceleration instructions in the instruction queue and synchronizing system data by the instruction scheduling thread.
EXAMPLE seven
Fig. 6 is a schematic structural diagram of a terminal according to a seventh embodiment of the present invention. The terminal provided by the embodiment of the invention is provided with the X window system, and can execute the processing flow provided by the method embodiment based on the drawing of the X window system graph. As shown in fig. 6, the terminal 60 includes: a processor 601, a memory 602, and computer programs stored on said memory 602 and executable by said processor 601.
When the computer program is run by the processor 601, the processing flow corresponding to any one of the above method embodiments is implemented, and details of this embodiment are not repeated here.
The method comprises the steps of obtaining a target instruction, after the target instruction is determined to be a hardware acceleration instruction and a graph drawing function corresponding to the target instruction is called to complete a graph drawing task corresponding to the target instruction, continuously obtaining a next acceleration instruction, judging the instruction type of the next acceleration instruction, if the next acceleration instruction is still determined to be the hardware acceleration instruction, determining that at least one hardware acceleration instruction needs to be continuously processed, temporarily not calling a hardware synchronization function, and continuously processing the next acceleration instruction; if the next acceleration instruction is determined to be a software acceleration instruction, the hardware acceleration instruction is determined not to be processed continuously, after the graphics drawing function corresponding to each hardware acceleration instruction which is called is executed, the hardware synchronization function is called, system data synchronization is carried out, then the next acceleration instruction is processed, the graphics drawing function corresponding to each hardware acceleration instruction is called in sequence when at least two hardware acceleration instructions are executed continuously, at least two hardware acceleration instructions are submitted to the GPU continuously, and after the hardware acceleration instruction submitted to the GPU is processed, the system data synchronization of a plurality of hardware acceleration instructions can be completed by calling the hardware synchronization function once, the advantages of the GPU are brought into full play, and the performance of an X window system is improved.
In the several embodiments provided in the present invention, it should be understood that the disclosed apparatus and method may be implemented in other manners. For example, the above-described apparatus embodiments are merely illustrative, and for example, a division of a unit is merely a logical division, and an actual implementation may have another division, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
Units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit may be implemented in the form of hardware, or in the form of hardware plus a software functional unit.
The integrated unit implemented in the form of a software functional unit may be stored in a computer-readable storage medium. The software functional unit is stored in a storage medium and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to execute some steps of the methods according to the embodiments of the present invention. And the aforementioned storage medium includes: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.
It is obvious to those skilled in the art that, for convenience and simplicity of description, the foregoing division of the functional modules is merely used as an example, and in practical applications, the above function distribution may be performed by different functional modules according to needs, that is, the internal structure of the device is divided into different functional modules to perform all or part of the above described functions. For the specific working process of the device described above, reference may be made to the corresponding process in the foregoing method embodiment, which is not described herein again.
Finally, it should be noted that: the above embodiments are only used to illustrate the technical solution of the present invention, and not to limit the same; while the invention has been described in detail and with reference to the foregoing embodiments, it will be understood by those skilled in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and these modifications or substitutions do not depart from the spirit of the corresponding technical solutions of the embodiments of the present invention.
Claims (11)
1. A method for graphics rendering based on an X-window system, wherein execution is scheduled by a thread of instructions, the method comprising:
acquiring a target instruction, and judging the instruction type of the target instruction, wherein the instruction type comprises a hardware acceleration instruction and a software acceleration instruction;
according to the instruction type of the target instruction, drawing processing is carried out on the target instruction, and the following drawing processing steps are carried out:
if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction;
if the target instruction is a software acceleration instruction, calling a graph drawing function corresponding to the target instruction, and calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed; acquiring a next acceleration instruction executed after the target instruction, and judging the instruction type of the next acceleration instruction;
if the next acceleration instruction is a hardware acceleration instruction, performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction;
and if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction, wherein the software acceleration instruction is realized in a structural body form.
2. The method of claim 1, wherein the fetching further comprises, prior to a next acceleration instruction executed after the target instruction:
determining whether the target instruction is the last acceleration instruction to be executed;
if the target instruction is the last acceleration instruction to be executed, calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed;
accordingly, if it is determined that the target instruction is not the last acceleration instruction to be executed, a next acceleration instruction to be executed after the target instruction is fetched.
3. The method of any of claims 1-2, wherein prior to fetching the target instruction, further comprising:
creating an instruction queue;
and sequentially adding the acceleration instructions to be executed to the instruction queue in real time according to a preset execution sequence.
4. The method of claim 3, wherein said fetching a target instruction comprises:
and acquiring a target instruction from the instruction queue.
5. The method of any of claims 1-2, wherein prior to fetching the target instruction, further comprising:
creating an instruction scheduling thread;
executing, by the instruction dispatch thread, the following graphics rendering process:
acquiring a target instruction, and judging the instruction type of the target instruction, wherein the instruction type comprises a hardware acceleration instruction and a software acceleration instruction;
and according to the instruction type of the target instruction, carrying out the drawing processing on the target instruction.
6. An apparatus for graphics rendering based on an X-window system, wherein execution is scheduled by a thread of instructions, the apparatus comprising:
the system comprises an acquisition module, a processing module and a processing module, wherein the acquisition module is used for acquiring a target instruction and judging the instruction type of the target instruction, and the instruction type comprises a hardware acceleration instruction and a software acceleration instruction;
the drawing processing module is used for drawing the target instruction according to the instruction type of the target instruction and executing the following drawing processing steps:
if the target instruction is a hardware acceleration instruction, calling a graph drawing function corresponding to the target instruction to complete a graph drawing task corresponding to the target instruction; the graph drawing functions corresponding to different acceleration instructions are different;
if the target instruction is a software acceleration instruction, calling a graph drawing function corresponding to the target instruction, and calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed;
acquiring a next acceleration instruction executed after the target instruction, and judging the instruction type of the next acceleration instruction;
if the next acceleration instruction is a hardware acceleration instruction, performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction;
and if the next acceleration instruction is a software acceleration instruction, calling a synchronization function corresponding to the target instruction, and performing the drawing processing on the next acceleration instruction according to the instruction type of the next acceleration instruction, wherein the software acceleration instruction is realized in a structural body form.
7. The apparatus of claim 6,
the graphics processing module is further configured to:
determining whether the target instruction is the last acceleration instruction to be executed; if the target instruction is the last acceleration instruction to be executed, calling a synchronous function corresponding to the target instruction after the graph drawing function corresponding to the target instruction is executed;
accordingly, if it is determined that the target instruction is not the last acceleration instruction to be executed, a next acceleration instruction to be executed after the target instruction is fetched.
8. The apparatus of any of claims 6-7, further comprising:
the queue creating module is used for creating an instruction queue;
and the instruction adding module is used for sequentially adding the acceleration instructions to be executed into the instruction queue in real time according to a preset execution sequence.
9. The apparatus of claim 8,
the obtaining module is further configured to obtain a target instruction from the instruction queue.
10. The apparatus of claim 9, further comprising:
the thread creating module is used for creating an instruction scheduling thread;
the obtaining module is further configured to obtain a target instruction by the instruction scheduling thread, and determine an instruction type of the target instruction, where the instruction type includes a hardware acceleration instruction and a software acceleration instruction;
the drawing processing module is further configured to perform, by the instruction scheduling thread, the drawing processing on the target instruction according to an instruction type of the target instruction.
11. A terminal, characterized in that, installed with an X window system, comprising: a processor, a memory, and a computer program stored on the memory and executable by the processor,
said computer program when executed by said processor implements the method of X-window system graphics based rendering as claimed in any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710703287.8A CN109426529B (en) | 2017-08-16 | 2017-08-16 | Method, device and terminal for drawing graphics based on X window system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710703287.8A CN109426529B (en) | 2017-08-16 | 2017-08-16 | Method, device and terminal for drawing graphics based on X window system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109426529A CN109426529A (en) | 2019-03-05 |
| CN109426529B true CN109426529B (en) | 2023-03-21 |
Family
ID=65497791
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710703287.8A Active CN109426529B (en) | 2017-08-16 | 2017-08-16 | Method, device and terminal for drawing graphics based on X window system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109426529B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111445381A (en) * | 2020-03-20 | 2020-07-24 | 福州瑞芯微电子股份有限公司 | RGA (graphics processing architecture) graphics acceleration method based on EXA (extensible markup language) and storage device |
| CN113674132B (en) * | 2021-07-23 | 2024-05-14 | 中标软件有限公司 | Method for managing rendering back end by detecting display card capability switching window |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103164215A (en) * | 2011-08-30 | 2013-06-19 | 三星电子株式会社 | Data processing system and method for switching between heterogeneous accelerators |
| CN105786449A (en) * | 2014-12-26 | 2016-07-20 | 龙芯中科技术有限公司 | Instruction scheduling method and device based on graphic processing |
| CN106778015A (en) * | 2016-12-29 | 2017-05-31 | 哈尔滨工业大学（威海） | One kind is based on FPGA isomery accelerated gene computational methods in cloud platform |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101217017A (en) * | 2007-12-28 | 2008-07-09 | 彩虹集团公司 | A dynamic signal generation method for PDP display unit measurement |
| CN101582890B (en) * | 2009-06-09 | 2012-04-18 | 中国科学院计算技术研究所 | Method and system for realizing connection between X11 client and X11 server |
| US9424089B2 (en) * | 2012-01-24 | 2016-08-23 | Samsung Electronics Co., Ltd. | Hardware acceleration of web applications |
| CN103034729B (en) * | 2012-12-20 | 2016-09-21 | 深圳Tcl新技术有限公司 | web page rendering system and method |
-
2017
- 2017-08-16 CN CN201710703287.8A patent/CN109426529B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103164215A (en) * | 2011-08-30 | 2013-06-19 | 三星电子株式会社 | Data processing system and method for switching between heterogeneous accelerators |
| CN105786449A (en) * | 2014-12-26 | 2016-07-20 | 龙芯中科技术有限公司 | Instruction scheduling method and device based on graphic processing |
| CN106778015A (en) * | 2016-12-29 | 2017-05-31 | 哈尔滨工业大学（威海） | One kind is based on FPGA isomery accelerated gene computational methods in cloud platform |
Non-Patent Citations (1)
| Title |
|---|
| 基于飞腾平台的GPU图形加速驱动设计与实现;李荣振等;《计算机工程与应用》;第126-131页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109426529A (en) | 2019-03-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN102597950B (en) | Hardware-based scheduling of GPU work | |
| US10078882B2 (en) | Priority-based command execution | |
| KR101855311B1 (en) | Workload batch submission mechanism for graphics processing unit | |
| KR101900172B1 (en) | Intelligent gpu scheduling in a virtualization environment | |
| CN109213607B (en) | Multithreading rendering method and device | |
| CN112529995B (en) | Image rendering calculation method and device, storage medium and terminal | |
| CN113704301B (en) | Data processing method, device, system, equipment and medium of heterogeneous computing platform | |
| CN110968415B (en) | Scheduling method and device of multi-core processor and terminal | |
| US20240160474A1 (en) | Multi-core processor task scheduling method, and device and storage medium | |
| KR20170125881A (en) | Provides asynchronous display shader functionality on shared shader cores | |
| CN110008027B (en) | Process running method and device, terminal and storage medium | |
| US20190324783A1 (en) | Synchronous operation method performance in context of asynchronous event loop | |
| CN109426529B (en) | Method, device and terminal for drawing graphics based on X window system | |
| WO2006123546A1 (en) | Graphic processor and information processing device | |
| WO2006123547A1 (en) | Information processing unit, system and method, and processor | |
| JP7482223B2 (en) | APPLET PAGE RENDERING METHOD, DEVICE, ELECTRONIC DEVICE, AND STORAGE MEDIUM | |
| CN114168301A (en) | Thread scheduling method, processor and electronic device | |
| CN116243983A (en) | Processor, integrated circuit chip, instruction processing method, electronic device, and medium | |
| CN111124655A (en) | Network request scheduling method, terminal device and storage medium | |
| CN108073338B (en) | Cursor display method and system | |
| CN109983435A (en) | Graphic processing method and relevant apparatus and equipment | |
| CN116991600B (en) | Method, device, equipment and storage medium for processing graphic call instruction | |
| CN111714879B (en) | Physical state updating method and device, storage medium and electronic device | |
| JP5842029B2 (en) | Information processing support apparatus, information processing apparatus, and information processing support program for caching image data | |
| CN112540711B (en) | Control method, device and equipment for selecting three-dimensional space object at webpage end |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| CB02 | Change of applicant information |
Address after: 100095 Building 2, Longxin Industrial Park, Zhongguancun environmental protection technology demonstration park, Haidian District, Beijing Applicant after: Loongson Zhongke Technology Co.,Ltd. Address before: 100095 Building 2, Longxin Industrial Park, Zhongguancun environmental protection technology demonstration park, Haidian District, Beijing Applicant before: LOONGSON TECHNOLOGY Corp.,Ltd. |
|
| CB02 | Change of applicant information | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |