Image rendering method, apparatus and server

Abstract

The specification provides an image rendering method, device and server. Based on the method, after receiving a rendering task application request initiated by a first rendering node server, a management node server of a cloud rendering service platform first determines a target resource pool; based on the resource pool dimension, a plurality of candidate task queues are screened from the target resource pool according to a preset priority rule; then based on the job dimension, a target task queue matched with the first rendering node server is determined from the plurality of candidate task queues; further, based on the task dimension, a rendering task meeting a preset task requirement is determined from the target task queue as a target rendering task allocated to the first rendering node server for processing. Thus, by comprehensively utilizing characteristic factors of multiple levels such as the resource pool level, the job level and the task level, appropriate rendering tasks in appropriate rendering task queues can be accurately and efficiently allocated to the rendering node servers in the cluster, and the overall rendering efficiency is improved.

Description

Technical Field

[0001] This manual pertains to the field of cloud computing technology, and in particular relates to image rendering methods, devices, and servers. Background Technology

[0002] Based on existing image rendering service platforms, when faced with image rendering jobs with massive amounts of data, there is often a problem of not being able to effectively and reasonably utilize the computing resources of the service platform, resulting in low overall image rendering processing efficiency, long user waiting times, and poor interactive experience.

[0003] There is currently no effective solution to the above problems. Summary of the Invention

[0004] This manual provides an image rendering method, apparatus, and server. By comprehensively utilizing multi-level features such as resource pool level, job level, and task level, it can accurately and efficiently allocate appropriate rendering tasks from suitable rendering task queues to rendering node servers in the cluster. This effectively improves the overall image rendering processing efficiency of the cloud rendering service platform, shortens user waiting time, and allows users to obtain a better interactive experience.

[0005] This manual provides an image rendering method applied to a management node server, including:

[0006] Receive a rendering task request initiated by the first rendering node server; wherein, the rendering task request carries at least the server identifier of the first rendering node server.

[0007] Based on the server identifier of the first rendering node server, a target resource pool matching the first rendering node server is determined; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks.

[0008] According to preset priority rules, multiple candidate task queues are selected from the target resource pool;

[0009] Based on the feature data of the first rendering node server and the job feature data of the candidate task queue, the target task queue that matches the first rendering node server is determined from multiple candidate task queues.

[0010] The system acquires and identifies rendering tasks that meet preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and uses these as target rendering tasks; then it assigns these target rendering tasks to the first rendering node server for processing.

[0011] In one embodiment, multiple candidate task queues are selected from the target resource pool according to a preset priority rule, including:

[0012] Check whether the target resource pool has a job priority marker set, and obtain the corresponding target detection results;

[0013] Based on the target detection results and the preset priority rules, a matching target priority rule is determined; and based on the target priority rule, multiple candidate task queues are selected from the target resource pool.

[0014] In one embodiment, based on the target detection results and preset priority rules, a matching target priority rule is determined; and based on the target priority rule, multiple candidate task queues are selected from the target resource pool, including:

[0015] Based on the target detection results, if it is determined that the target resource pool has a job priority tag, the first priority rule that matches the preset priority rules is determined as the target priority rule.

[0016] Accordingly, based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including:

[0017] Based on the first priority rule, the job priority indicator parameters for each rendering task queue in the target resource pool are determined;

[0018] Multiple rendering task queues are arranged in descending order of job priority indicator parameters;

[0019] From the sorted rendering task queues, select a predetermined number of rendering task queues that rank highly as candidate task queues.

[0020] In one embodiment, a matching target priority rule is determined based on the target detection results and a preset priority rule; and multiple candidate task queues are selected from the target resource pool according to the target priority rule, further comprising:

[0021] Based on the target detection results, if it is determined that the target resource pool does not have a job priority tag, the matching second priority rule is determined from the preset priority rules as the target priority rule;

[0022] Accordingly, based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including:

[0023] Based on the second priority rule, determine the number of currently executed rendering tasks in each rendering task queue in the target resource pool;

[0024] Arrange multiple rendering task queues in ascending order of the number of currently executed rendering tasks;

[0025] From the sorted rendering task queues, select a predetermined number of rendering task queues that rank highly as candidate task queues.

[0026] In one embodiment, obtaining and determining a target task queue that matches the first rendering node server from multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues includes:

[0027] According to the internal scheduling strategy of the target resource pool, the job feature data of the candidate task queue are matched with the feature data of the first rendering node server one by one in the corresponding order;

[0028] When a candidate task queue is found whose job feature data matches the feature data of the first rendering node server, that candidate task queue is determined as the target task queue.

[0029] In one embodiment, when a candidate task queue whose job feature data matches the feature data of the first rendering node server is found, the method further includes:

[0030] Obtain the user characteristic data of the initiating user of the candidate task queue;

[0031] Based on the user characteristic data of the initiating user, determine whether the candidate task queue meets the preset job requirements;

[0032] If the candidate task queue meets the preset job requirements, the candidate task queue is selected as the target task queue.

[0033] In one embodiment, the user characteristic data of the initiating user includes at least one of the following: the user identifier of the initiating user, the user tag of the initiating user, and the number of rendering tasks currently executed and associated with the initiating user.

[0034] In one embodiment, acquiring and determining, based on the task feature data of rendering tasks in the target task queue, rendering tasks that meet preset task requirements from the target task queue as target rendering tasks includes:

[0035] Determine the currently executed and unexecuted rendering tasks in the target task queue;

[0036] Based on the task feature data of the currently executed rendering task and the task feature data of the currently unexecuted rendering task, a rendering task that matches the currently executed rendering task is determined from the currently unexecuted rendering tasks and used as the target rendering task.

[0037] This specification also provides an image rendering apparatus for use on a management node server, including:

[0038] The receiving module is used to receive a rendering task request initiated by the first rendering node server; wherein the rendering task request carries at least the server identifier of the first rendering node server.

[0039] The first determining module is used to determine a target resource pool that matches the first rendering node server based on the server identifier of the first rendering node server; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks.

[0040] The filtering module is used to filter out multiple candidate task queues from the target resource pool according to preset priority rules.

[0041] The second determining module is used to acquire and determine the target task queue that matches the first rendering node server from multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queue.

[0042] The third determining module is used to acquire and determine, based on the task feature data of the rendering tasks in the target task queue, the rendering tasks that meet the preset task requirements from the target task queue, and use them as target rendering tasks; and assign the target rendering tasks to the first rendering node server for processing.

[0043] This specification also provides a computer-readable storage medium having computer instructions stored thereon, which, when executed by a processor, implement the relevant steps of the image rendering method.

[0044] Based on the image rendering method, apparatus, and server provided in this specification, after receiving a rendering task request initiated by a first rendering node server, the management node server of the cloud rendering service platform first determines a target resource pool matching the first rendering node server based on the server identifier of the first rendering node server. The target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks. Based on the resource pool dimension, multiple candidate task queues are selected from the target resource pool according to preset priority rules. Then, based on the job dimension, the target task queue matching the first rendering node server is determined from the multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues. Further, based on the task dimension, the rendering task that meets the preset task requirements is obtained and determined from the target task queue according to the task feature data of the rendering tasks in the target task queue, and this target rendering task is assigned to the first rendering node server for processing. By comprehensively utilizing multi-level feature factors such as resource pool level, job level, and task level, appropriate rendering tasks in the suitable rendering task queue can be accurately and efficiently allocated to the rendering node server. This effectively improves the overall image rendering processing efficiency of the cloud rendering service platform, shortens user waiting time, and provides users with a relatively better interactive experience. Furthermore, by introducing and utilizing user-level feature factors related to the initiating user, and combining them with the aforementioned multi-level feature factors such as resource pool level, job level, and task level, rendering tasks in the rendering task queue can be allocated to the rendering node server more accurately and reasonably, resulting in a relatively better interactive experience for users. Attached Figure Description

[0045] To more clearly illustrate the embodiments of this specification, the accompanying drawings used in the embodiments will be briefly introduced below. The drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0046] Figure 1 A flowchart illustrating an image rendering method provided in one embodiment of this specification;

[0047] Figure 2 This is a schematic diagram illustrating an embodiment of the image rendering method provided in this specification, applied in a scene example.

[0048] Figure 3 This is a schematic diagram illustrating an embodiment of the image rendering method provided in this specification, applied in a scene example.

[0049] Figure 4 This is a schematic diagram illustrating an embodiment of the image rendering method provided in this specification, applied in a scene example.

[0050] Figure 5 This is a schematic diagram illustrating an embodiment of the image rendering method provided in this specification, applied in a scene example.

[0051] Figure 6 This is a schematic diagram of the structural composition of a server provided in one embodiment of this specification;

[0052] Figure 7 This is a schematic diagram of the structural composition of an image rendering apparatus provided in one embodiment of this specification. Detailed Implementation

[0053] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments in this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0054] See Figure 1 As shown in the embodiments of this specification, an image rendering method is provided, wherein the method is specifically applied to the management node server side. In specific implementation, the method may include the following:

[0055] S101: Receive a rendering task request initiated by the first rendering node server; wherein, the rendering task request carries at least the server identifier of the first rendering node server.

[0056] S102: Based on the server identifier of the first rendering node server, determine the target resource pool that matches the first rendering node server; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; the rendering task queue includes one or more rendering tasks;

[0057] S103: Select multiple candidate task queues from the target resource pool according to preset priority rules;

[0058] S104: Obtain and determine the target task queue that matches the first rendering node server from multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queue.

[0059] S105: Obtain and determine the rendering task that meets the preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and use it as the target rendering task; and assign the target rendering task to the first rendering node server for processing.

[0060] In one embodiment, the image rendering method described above can be applied to the management node server side. Specifically, the management node server can be the management node server of a cloud rendering service platform.

[0061] See Figure 2 As shown, the aforementioned cloud rendering service platform can be understood as a network platform that provides users with automatic image rendering job services based on cloud computing technology.

[0062] Specifically, the aforementioned cloud rendering service platform may include at least the following structures: management node server (or management node), rendering node server (or rendering node), storage node server (or storage node), and resource pool.

[0063] Specifically, the aforementioned rendering node servers can be used to execute specific rendering tasks in image rendering jobs. The aforementioned cloud rendering service platform can include multiple distributed rendering node servers, and multiple rendering server nodes can be combined to form a corresponding distributed server cluster.

[0064] Specifically, the aforementioned rendering node servers may include one or more of the following: CPU-based rendering node servers, GPU-based rendering node servers, and CPU+GPU heterogeneous dual-mode rendering node servers. By combining these different types of rendering node servers in the cloud rendering service platform, diverse rendering needs of users can be met, and image rendering jobs can be completed more efficiently and accurately.

[0065] The aforementioned management node server can be used to allocate idle rendering node servers to perform specific rendering tasks.

[0066] The resource pool described above is used to store rendering task queues. Each rendering task queue corresponds to a specific image rendering job, and each rendering task queue may include one or more rendering tasks. A rendering task can be understood as the smallest unit of work in an image rendering job.

[0067] The aforementioned storage node server can be used to store relevant attribute data. Specifically, for example, the storage node server can be used to store attribute data of the user who initiated the image rendering job, attribute data of the resource pool, attribute data of the rendering task queue, and attribute data of the rendering task.

[0068] In this embodiment, the aforementioned management node server, rendering node server, and storage node server may specifically include a backend server applied to one side of the cloud rendering service platform, capable of data transmission, data processing, and other functions. Specifically, the management node server, rendering node server, and storage node server may be, for example, an electronic device with data processing, storage, and network interaction capabilities. Alternatively, the management node server, rendering node server, and storage node server may also be software programs running on the electronic device, providing support for data processing, storage, and network interaction. In this embodiment, the number of servers included in the management node server, rendering node server, and storage node server is not specifically limited. The management node server, rendering node server, and storage node server may be a single server, several servers, or a server cluster formed by several servers.

[0069] For specific implementation, please refer to Figure 2 As shown, when a user has an image rendering job requirement, they can use a terminal device to initiate an image rendering job request to the cloud rendering service platform; wherein, the image rendering job request carries at least the user identifier of the initiating user and one or more images to be rendered.

[0070] Specifically, the aforementioned image rendering can be understood as the image processing process that uses a 3D model containing information such as material, texture, color, and light source to generate an image with a realistic effect through calculation.

[0071] In this embodiment, the terminal device may specifically include a front-end applied to the user side, capable of data collection, data transmission, and other functions. Specifically, the terminal device may be an electronic device such as a desktop computer, tablet computer, laptop computer, or mobile phone. Alternatively, the terminal device may also be a software application that can run on the aforementioned electronic devices. For example, it could be an XX cloud rendering app running on a mobile phone.

[0072] Correspondingly, the management node server can receive image rendering job requests initiated by users; respond to the image rendering job request, and according to the preset splitting rules and the image frame number in the image, split the image rendering job indicated by the image rendering job request into multiple rendering tasks; and use the above multiple rendering tasks to construct a rendering task queue corresponding to the image rendering job.

[0073] Furthermore, the management node server can also store the rendering task queue into the corresponding resource pool according to the corresponding storage rules.

[0074] Specifically, the aforementioned image rendering job request can also carry rendering parameters set by the initiating user (e.g., rendering mode, rendering type, etc.). Accordingly, the management node server can predict the job type and scale of the image rendering job indicated by the image rendering job request based on the rendering parameters and the number of images to be rendered; and then, based on the job type and scale, store the rendering task queue corresponding to the image rendering job into the matching resource pool.

[0075] For each resource pool, the management node server can pre-configure a matching server cluster based on the job type and scale of the rendering task queue stored in that resource pool, and establish a configuration relationship table for the resource pool. This configuration relationship table can include the server identifiers of each rendering node server in the server cluster configured for that resource pool.

[0076] This can be understood as a resource pool corresponding to a configured server cluster. It's also worth noting that in certain special cases, rendering node servers within the server cluster can be called to temporarily handle rendering tasks in the rendering task queues of other resource pools. Furthermore, rendering node servers from different server clusters can be combined and called across server clusters to jointly execute rendering task queues from a specific resource pool.

[0077] In the above manner, the management node server can first receive and construct multiple rendering task queues based on the image rendering job requests initiated by the user; and store the rendering task queues in the corresponding resource pools to await allocation and processing.

[0078] In practice, the aforementioned rendering node server can be set to automatically detect the amount of remaining local resources at preset time intervals. When the amount of remaining local resources is detected to be greater than the preset threshold, it is determined that the server is relatively idle and can accept and execute rendering tasks. At this time, the rendering node server can be recorded as the first rendering node server and can then send a rendering task request to the management node server.

[0079] Accordingly, the management node server receives and responds to the above-mentioned rendering task request. Based on the method provided in this specification, by comprehensively utilizing the feature factors of multiple levels such as resource pool level, job level, and task level, it determines a suitable rendering task in the appropriate rendering task queue as the target rendering task for the first rendering node server; and then assigns the target rendering task to the first rendering node server for specific execution.

[0080] In the above manner, the management node server can efficiently and accurately allocate suitable target rendering tasks to the currently relatively idle first rendering node server, thereby making reasonable and effective use of the computing resources of the cloud rendering service platform, efficiently processing the image rendering jobs requested by users, and reducing the user's waiting time.

[0081] In one embodiment, during specific implementation, the management node server can determine the resource pool that matches the first rendering node server by querying the resource pool configuration relationship table based on the server identifier of the first rendering node server, and use it as the target resource pool.

[0082] In one embodiment, the above-mentioned selection of multiple candidate task queues from the target resource pool according to a preset priority rule may include the following:

[0083] S1: Detect whether the target resource pool has a job priority marker set, and obtain the corresponding target detection result;

[0084] S2: Based on the target detection results and the preset priority rules, determine the matching target priority rules; and based on the target priority rules, select multiple candidate task queues from the target resource pool.

[0085] Specifically, the aforementioned job priority marker can be understood as an indicator used to indicate how to process the task queues in the resource pool based on their priority.

[0086] Specifically, for resource pools with job priority flags, the task queues in the resource pool will also be set with corresponding job priority indicator parameters when they are stored; accordingly, when processing the task queues in the resource pool, the job priorities of different task queues need to be considered.

[0087] For resource pools without job priority flags, no corresponding job priority indicator parameters will be set when task queues are added to the resource pool. Consequently, when processing task queues in the resource pool, it is not necessary to consider the job priority of the task queues, but it is necessary to consider the execution status of tasks in each task queue to avoid affecting the user's interactive experience due to a certain task queue not being processed for a long time.

[0088] The aforementioned preset priority rules may specifically include: a first priority rule and a second priority rule. Specifically, the first priority rule may be designed for resource pools with job priority tags set. The second priority rule may be designed for resource pools without job priority tags set.

[0089] In one embodiment, the above-mentioned determination of a matching target priority rule based on the target detection result and the preset priority rule; and the selection of multiple candidate task queues from the target resource pool based on the target priority rule. In specific implementation, the following may be included: based on the target detection result, if it is determined that the target resource pool has a job priority mark, the matching first priority rule is determined from the preset priority rules as the target priority rule.

[0090] Accordingly, see Figure 3 As shown, the above method selects multiple candidate task queues from the target resource pool based on target priority rules. In practice, this may include the following:

[0091] S1: Determine the job priority indicator parameters for each rendering task queue in the target resource pool according to the first priority rule;

[0092] S2: Arrange multiple rendering task queues in descending order of job priority indicator parameters;

[0093] S3: Select a preset number of rendering task queues from the sorted rendering task queues as candidate task queues.

[0094] Based on the above embodiments, when the target resource pool is set with job priority tags, a preset number (e.g., 5) of rendering task queues with higher job priority can be selected from the target resource pool as candidate task queues that meet the requirements.

[0095] In one embodiment, the above-mentioned determination of a matching target priority rule based on the target detection result and the preset priority rule; and the selection of multiple candidate task queues from the target resource pool based on the target priority rule. In a specific implementation, the following may also be included: based on the target detection result, if it is determined that the target resource pool has no job priority mark, a matching second priority rule is determined from the preset priority rules as the target priority rule.

[0096] Accordingly, see Figure 4 As shown, the above method selects multiple candidate task queues from the target resource pool based on target priority rules. In practice, this may include the following:

[0097] S1: Determine the number of currently executed rendering tasks in each rendering task queue in the target resource pool according to the second priority rule;

[0098] S2: Arrange multiple rendering task queues in ascending order of the number of currently executed rendering tasks;

[0099] S3: Select a preset number of rendering task queues from the sorted rendering task queues as candidate task queues.

[0100] Based on the above embodiments, if no job priority flag is set in the target resource pool, a preset number of rendering task queues that have not yet started executing or have a small number of currently executed rendering tasks can be selected from the target resource pool as candidate task queues that meet the requirements.

[0101] In one embodiment, the process of obtaining and determining the target task queue that matches the first rendering node server from multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues may include the following:

[0102] S1: According to the internal scheduling strategy of the target resource pool, match the job feature data of the candidate task queue with the feature data of the first rendering node server one by one in the corresponding order;

[0103] S2: When a candidate task queue whose job feature data matches the feature data of the first rendering node server is found, the candidate task queue is determined as the target task queue.

[0104] Specifically, the job characteristic data of the required candidate task queues can be obtained by querying the attribute data of the rendering task queues stored on the storage node server.

[0105] The job characteristic data of the aforementioned candidate task queue may specifically include at least one of the following: the creation time of the candidate task queue, the hardware resource requirement parameters of the candidate task queue, the software resource requirement parameters of the candidate task queue, and the correlation parameters between the image rendering job corresponding to the candidate task queue and other image rendering jobs. Specifically, the correlation parameters between the image rendering job corresponding to the candidate task queue and other image rendering jobs may refer to parameters used to characterize the dependencies between different image rendering jobs. For example, image rendering job A requires image rendering job B to be completed before it can begin. Or, image rendering job C needs to use a parameter generated during the intermediate execution of image rendering job D, etc.

[0106] Furthermore, the aforementioned job characteristic data may also include: the upper limit of the number of rendering node servers that the image rendering job corresponding to the candidate task queue is allowed to occupy simultaneously, the special type of the image rendering job corresponding to the candidate task queue (e.g., whether it needs to utilize distributed rendering supported by the renderer), etc.

[0107] Specifically, the characteristic data of the first rendering node server may include at least one of the following: the remaining resources of the first rendering node server, the operating status of the first rendering node server, and the application identifier of the software application installed on the first rendering node server.

[0108] Furthermore, the characteristic data of the first rendering node server may also include: the license information of the software, renderers and plugins supported by the first rendering node server, the machine model information of the first rendering node server, the available disk space, available memory, number of graphics cards, etc. of the first rendering node server.

[0109] In practice, the management node server can obtain the job characteristic data of the candidate task queue and the characteristic data of the first rendering node server by querying the storage node server based on the queue identifier of the candidate task queue and the server identifier of the first rendering node server.

[0110] Specifically, the aforementioned internal scheduling strategies include at least one of the following: global cyclic scheduling strategy, priority-based multiple job cyclic scheduling strategy, priority-based first-in-first-out scheduling strategy, etc.

[0111] Specifically, the global round-robin scheduling strategy can mean ignoring the job priority of image rendering jobs and uniformly allocating rendering node servers to all rendering task queues within the same resource pool in a round-robin manner. The priority-based multi-job round-robin scheduling strategy can mean that the rendering task queues corresponding to all image rendering jobs within the same resource pool are first arranged in descending order of job priority, and rendering task queues with the same priority are then uniformly allocated to rendering node servers in a round-robin manner. The priority-based first-in-first-out scheduling strategy can mean that the rendering task queues corresponding to all image rendering jobs within the same resource pool are first arranged in descending order of job priority, and rendering task queues with the same priority are sorted according to the time the image rendering job request was received; the earlier the request was received and the earlier the rendering task queue was established, the higher the priority for allocation to rendering node servers.

[0112] Based on the above embodiments, the management node server can match the job feature data of each candidate task queue with the feature data of the first rendering node server one by one according to the internal scheduling strategy of the target resource pool. When the job feature data of a certain candidate task queue is successfully matched with the feature data of the first rendering node server, the candidate task queue can be determined as a task queue suitable for processing by the first rendering node server. Then, the matching can be stopped and the candidate task queue can be determined as the target task queue suitable for processing by the first rendering node server.

[0113] In one embodiment, see Figure 5As shown, when a candidate task queue is found whose job feature data matches the feature data of the first rendering node server, the method may further include the following in its specific implementation:

[0114] S1: Obtain the user characteristic data of the initiating user of the candidate task queue;

[0115] S2: Based on the user characteristic data of the initiating user, determine whether the candidate task queue meets the preset job requirements;

[0116] S3: If the candidate task queue meets the preset job requirements, the candidate task queue is determined as the target task queue.

[0117] Specifically, the user characteristic data of the initiating user may include at least one of the following: the user identifier of the initiating user, the user tag of the initiating user, the number of rendering tasks currently executed and associated with the initiating user, etc.

[0118] Furthermore, the user characteristic data of the initiating user may also include: the initiating user's remaining resource value, the initiating user's membership level, the initiating user's credit score, etc.

[0119] In practice, the management node server can obtain the user characteristic data of the initiating user of the candidate task queue in the following way: based on the queue identifier of the candidate task queue, the user identifier of the initiating user of the image rendering job request corresponding to the candidate task queue is determined by querying the storage node server; based on the user identifier of the initiating user, the user characteristic data of the initiating user is obtained by querying the storage node server.

[0120] In practice, each time the management node server matches a candidate task queue based on the job characteristic data of the candidate task queue and the characteristic data of the first rendering node server, it can first obtain the user characteristic data of the initiating user of the candidate task queue. Then, based on the user characteristic data of the initiating user, it can determine whether the candidate task queue meets the preset job requirements by checking whether the initiating user meets the requirements. If it is determined that the candidate task queue does not meet the preset job requirements, the next candidate task queue can be matched in the target resource pool based on the job characteristic data of the candidate task queue and the characteristic data of the first rendering node server. Conversely, if it is determined that the candidate task queue meets the preset job requirements, the candidate task queue is determined as the target task queue.

[0121] Specifically, for example, if the user's credit score is low, below a preset threshold, based on the user's characteristic data, the user can be identified as a defaulter and no further requests will be made. Consequently, the candidate task queue does not meet the preset job requirements. Based on the corresponding processing rules, the candidate task queue will be delayed by one round of processing.

[0122] For example, if, based on the user's characteristic data, the number of currently executed rendering tasks associated with that user is large, exceeding a preset threshold, it can be determined that a significant amount of computing resources are being consumed in processing the image rendering job initiated by that user, and multiple rendering tasks involving that user are already in progress. In this case, to ensure a better user experience for other users, their image rendering jobs can be prioritized. Therefore, it can be determined that the candidate task queue does not meet the preset job requirements. Based on the corresponding processing rules, the candidate task queue can be deferred for one round before further processing.

[0123] Based on the above embodiments, by further introducing and utilizing user-level feature factors, it is possible to better consider the interactive experience of more users, select candidate task queues that meet the current user needs and prioritize their allocation, thereby enabling users to obtain a relatively better interactive experience.

[0124] In one embodiment, the process of acquiring and determining rendering tasks that meet preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and using these as target rendering tasks, may specifically include the following:

[0125] S1: Determine the currently executed and unexecuted rendering tasks in the target task queue;

[0126] S2: Based on the task feature data of the currently executed rendering task and the task feature data of the currently unexecuted rendering task, determine the rendering task that matches the currently executed rendering task from the currently unexecuted rendering tasks, and use it as the target rendering task.

[0127] Specifically, the task feature data of the above-mentioned rendering task may include at least one of the following: preprocessing parameters of the rendering task, test parameters of the rendering task, processing order indication parameters of the rendering task, correlation parameters between the rendering task and other rendering tasks in the rendering task pair column, and lower limit requirements parameters of the rendering task for the GPU and graphics card, etc.

[0128] Specifically, the aforementioned preprocessing refers to localizing the rendering scene before executing a specific rendering task. This could involve modifying the output path of the channel files or adjusting the maximum memory limit available to the renderer. The parameters involved in these modifications can be set according to user-defined local environment parameters within the rendering scene.

[0129] The aforementioned testing specifically refers to the rendering test calculations performed after localizing the rendering scene to ensure the correctness of the rendering results and the effective use of resources. Specifically, rendering test calculations for image rendering jobs generally refer to the process where, after a user submits multiple images to be rendered, to ensure the correctness and reliability of the rendering results, the user first renders the first, middle, and last three frames (e.g., the three images with the highest, middle, and lowest frame numbers in the order of the first, middle, and last frames) for testing. Only after confirming that the rendering test results of these three frames meet the user's requirements are the remaining frames in the rendering task, as well as other rendering tasks in the rendering task queue, processed.

[0130] In one embodiment, the first rendering node server can be a rendering node server that is currently capable of handling rendering tasks. Specifically, the first rendering node server can be a rendering node server with remaining resources greater than a preset remaining resource threshold, or a rendering node server that is currently idle.

[0131] In one embodiment, the above method may further include the following: receiving an image rendering job request initiated by the user through a terminal device; wherein the image rendering job request carries at least the user identifier of the initiating user and the image to be rendered; responding to the image rendering job request, splitting multiple rendering tasks according to a preset splitting rule and the image frame number in the image to construct a corresponding rendering task queue.

[0132] In one embodiment, after assigning the target rendering task to the first rendering node server for processing, the method may further include the following: the first rendering node server executes and processes the assigned target rendering task. Specifically, the first rendering node server may execute a preset script text to perform rendering calculations for the rendering task, while simultaneously reading scene materials stored in the node server, and using the aforementioned scene materials to process the image targeted by the target rendering task to complete the target rendering task and obtain the rendered image as the target processing result.

[0133] Furthermore, the first rendering node server can store the target processing results in the storage node server; at the same time, it can send a notification to the management node server about the completion of the target rendering task.

[0134] The management node server receives and responds to the notification, updating the status information of the target rendering tasks in the target task queue. Simultaneously, based on the status information of each rendering task in the target task queue, it checks whether all rendering tasks in the queue have been completed. If it is determined that all rendering tasks in the target task queue have been completed, the server can confirm that the image rendering job corresponding to the target task queue has been completed. The server can then generate and send a notification message to the terminal device, indicating that the image rendering job requested by the user has been completed.

[0135] Correspondingly, the initiating user can use their terminal device to obtain the final image rendering job result file from the storage node server through the corresponding data download interface.

[0136] As can be seen from the above, based on the image rendering method provided in the embodiments of this specification, after receiving a rendering task application request initiated by the first rendering node server, the management node server of the cloud rendering service platform first determines the target resource pool matching the first rendering node server according to the server identifier of the first rendering node server; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; each rendering task queue includes one or more rendering tasks; based on the resource pool dimension, multiple candidate task queues are selected from the target resource pool according to a preset priority rule; then, based on the job dimension, the target task queue matching the first rendering node server is determined from the multiple candidate task queues according to the feature data of the first rendering node server and the job feature data of the candidate task queues; further, based on the task dimension, the rendering task that meets the preset task requirements is obtained and determined from the target task queue according to the task feature data of the rendering tasks in the target task queue, and is used as the target rendering task; and the target rendering task is assigned to the first rendering node server for processing. By comprehensively utilizing multi-level feature factors such as resource pool level, job level, and task level, appropriate rendering tasks from the suitable rendering task queue can be accurately and efficiently allocated to the rendering node server. This effectively improves the overall image rendering processing efficiency of the cloud rendering service platform, shortens user waiting time, and provides users with a better interactive experience. Furthermore, by introducing and utilizing user-level feature factors related to the initiating user, combined with the aforementioned multi-level feature factors such as resource pool level, job level, and task level, rendering tasks from the rendering task queue can be allocated to the rendering node server more accurately and reasonably, resulting in a better user interactive experience.

[0137] This specification also provides a server, including a processor and a memory for storing processor-executable instructions. Specifically, the processor can perform the following steps according to the instructions: receiving a rendering task request initiated by a first rendering node server; wherein the rendering task request carries at least a server identifier of the first rendering node server; determining a target resource pool matching the first rendering node server based on the server identifier of the first rendering node server; wherein the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; each rendering task queue includes one or more rendering tasks; selecting multiple candidate task queues from the target resource pool according to a preset priority rule; acquiring and determining a target task queue matching the first rendering node server from the multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues; acquiring and determining a rendering task that meets preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, as the target rendering task; and allocating the target rendering task to the first rendering node server for processing.

[0138] To execute the above instructions more accurately, please refer to... Figure 6 As shown in the embodiments of this specification, another specific server is also provided, wherein the server includes a network communication port 601, a processor 602 and a memory 603, and the above structures are connected by internal cables so that the various structures can perform specific data interaction.

[0139] Specifically, the network communication port 601 can be used to receive a rendering task request initiated by the first rendering node server; wherein the rendering task request carries at least the server identifier of the first rendering node server.

[0140] The processor 602 is specifically configured to: determine a target resource pool matching the first rendering node server based on the server identifier of the first rendering node server; wherein the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; each rendering task queue includes one or more rendering tasks; select multiple candidate task queues from the target resource pool according to a preset priority rule; obtain and determine a target task queue matching the first rendering node server from the multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues; obtain and determine a rendering task that meets the preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and use it as a target rendering task; and assign the target rendering task to the first rendering node server for processing.

[0141] The memory 603 can be used to store the corresponding instruction program.

[0142] In this embodiment, the network communication port 601 can be a virtual port bound to different communication protocols, thereby enabling the sending or receiving of different data. For example, the network communication port can be a port responsible for web data communication, a port responsible for FTP data communication, or a port responsible for email data communication. Furthermore, the network communication port can also be a physical communication interface or communication chip. For example, it can be a wireless mobile network communication chip, such as GSM or CDMA; it can also be a Wi-Fi chip; or it can be a Bluetooth chip.

[0143] In this embodiment, the processor 602 can be implemented in any suitable manner. For example, the processor can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers, etc. This specification is not limiting.

[0144] In this embodiment, the memory 603 may include multiple layers. In a digital system, anything that can store binary data can be a memory. In an integrated circuit, a circuit with storage function but no physical form is also called a memory, such as RAM, FIFO, etc. In a system, a storage device with a physical form is also called a memory, such as a memory stick or TF card.

[0145] This specification also provides a computer-readable storage medium based on the above-described image rendering method. The computer-readable storage medium stores computer program instructions that, when executed, implement the following steps: receiving a rendering task request initiated by a first rendering node server; wherein the rendering task request carries at least a server identifier of the first rendering node server; determining a target resource pool matching the first rendering node server based on the server identifier of the first rendering node server; wherein the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; each rendering task queue includes one or more rendering tasks; selecting multiple candidate task queues from the target resource pool according to a preset priority rule; acquiring and determining a target task queue matching the first rendering node server from the multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queues; acquiring and determining a rendering task that meets preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, as the target rendering task; and allocating the target rendering task to the first rendering node server for processing.

[0146] In this embodiment, the storage medium includes, but is not limited to, Random Access Memory (RAM), Read-Only Memory (ROM), cache, hard disk drive (HDD), or memory card. The memory can be used to store computer program instructions. The network communication unit can be an interface configured according to standards specified in the communication protocol for network connection communication.

[0147] In this embodiment, the specific functions and effects implemented by the program instructions stored in the computer-readable storage medium can be explained in comparison with other embodiments, and will not be repeated here.

[0148] See Figure 7 As shown, at the software level, this specification also provides an image rendering apparatus, which may specifically include the following structural modules:

[0149] The receiving module 701 is specifically used to receive a rendering task request initiated by the first rendering node server; wherein the rendering task request carries at least the server identifier of the first rendering node server.

[0150] The first determining module 702 is specifically used to determine a target resource pool that matches the first rendering node server based on the server identifier of the first rendering node server; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks.

[0151] The filtering module 703 can be used to filter out multiple candidate task queues from the target resource pool according to preset priority rules.

[0152] The second determining module 704 can be used to acquire and determine the target task queue that matches the first rendering node server from multiple candidate task queues based on the feature data of the first rendering node server and the job feature data of the candidate task queue.

[0153] The third determining module 705 can be used to acquire and determine, based on the task feature data of the rendering tasks in the target task queue, the rendering tasks that meet the preset task requirements from the target task queue, and use them as target rendering tasks; and assign the target rendering tasks to the first rendering node server for processing.

[0154] In one embodiment, when the above-mentioned screening module 703 is specifically implemented, it can screen multiple candidate task queues from the target resource pool according to a preset priority rule in the following manner: detect whether the target resource pool has a job priority mark and obtain the corresponding target detection result; determine the matching target priority rule according to the target detection result and the preset priority rule; and screen multiple candidate task queues from the target resource pool according to the target priority rule.

[0155] In one embodiment, when the above-mentioned filtering module 703 is specifically implemented, it can determine the matching target priority rule according to the target detection result and the preset priority rule in the following manner; and filter out multiple candidate task queues from the target resource pool according to the target priority rule: according to the target detection result, if it is determined that the target resource pool has a job priority mark, determine the matching first priority rule from the preset priority rules as the target priority rule; accordingly, filter out multiple candidate task queues from the target resource pool according to the target priority rule, including: determining the job priority indication parameter of each rendering task queue in the target resource pool according to the first priority rule; arranging multiple rendering task queues in descending order of job priority indication parameters; and filtering out a preset number of rendering task queues with the highest ranking from the arranged rendering task queues as candidate task queues.

[0156] In one embodiment, when the above-mentioned filtering module 703 is specifically implemented, it can determine the matching target priority rule according to the target detection result and the preset priority rule in the following manner; and filter out multiple candidate task queues from the target resource pool according to the target priority rule: according to the target detection result, if it is determined that the target resource pool has no job priority mark, determine the matching second priority rule from the preset priority rule as the target priority rule; accordingly, filter out multiple candidate task queues from the target resource pool according to the target priority rule, including: determining the number of currently executed rendering tasks in each rendering task queue in the target resource pool according to the second priority rule; arranging multiple rendering task queues in ascending order of the number of currently executed rendering tasks; and filtering out a preset number of rendering task queues with the highest ranking from the arranged rendering task queues as candidate task queues.

[0157] In one embodiment, when the second determining module 704 is specifically implemented, it can obtain and determine the target task queue that matches the first rendering node server from multiple candidate task queues in the following manner, based on the feature data of the first rendering node server and the job feature data of the candidate task queue: according to the internal scheduling strategy of the target resource pool, the job feature data of the candidate task queue is matched with the feature data of the first rendering node server one by one in the corresponding order; when a candidate task queue whose job feature data matches the feature data of the first rendering node server is matched, the candidate task queue is determined as the target task queue.

[0158] In one embodiment, when the second determining module 704 is specifically implemented, when a candidate task queue whose job feature data matches the feature data of the first rendering node server is found, it can also be used to obtain the user feature data of the initiating user of the candidate task queue; based on the user feature data of the initiating user, determine whether the candidate task queue meets the preset job requirements; if it is determined that the candidate task queue meets the preset job requirements, determine the candidate task queue as the target task queue.

[0159] In one embodiment, the user characteristic data of the initiating user may specifically include at least one of the following: the user identifier of the initiating user, the user tag of the initiating user, the number of rendering tasks currently executed and associated with the initiating user, etc.

[0160] In one embodiment, when the third determining module 705 is specifically implemented, it can obtain and determine the rendering task that meets the preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and use it as the target rendering task: determine the currently executed rendering tasks and the currently unexecuted rendering tasks in the target task queue; based on the task feature data of the currently executed rendering tasks and the task feature data of the currently unexecuted rendering tasks, determine the rendering task that matches the currently executed rendering task from the currently unexecuted rendering tasks, and use it as the target rendering task.

[0161] It should be noted that the units, devices, or modules described in the above embodiments can be implemented by computer chips or physical entities, or by products with certain functions. For ease of description, the above devices are described by dividing them into various modules according to their functions. Of course, in implementing this specification, the functions of each module can be implemented in one or more software and / or hardware, or the module that implements the same function can be implemented by a combination of multiple sub-modules or sub-units, etc. The device embodiments described above are merely illustrative. For example, the division of units is only a logical functional division, and there may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection between the devices or units shown or discussed can be through some interfaces, and the indirect coupling or communication connection between devices or units can be electrical, mechanical, or other forms.

[0162] As can be seen from the above, the image rendering apparatus provided in the embodiments of this specification, by comprehensively utilizing the feature factors of multiple levels such as resource pool level, job level, and task level, accurately and efficiently allocates appropriate rendering tasks in the appropriate rendering task queue to the rendering node server, effectively improving the overall image rendering processing efficiency of the cloud rendering service platform, shortening the user's waiting time, and enabling the user to obtain a better interactive experience.

[0163] In a specific scenario example, the image rendering methods provided in this manual can be applied to complete a specific image rendering task using a cluster rendering system. For detailed implementation procedures, please refer to the following content.

[0164] The management node (e.g., the management node server) can break down all user-submitted jobs (e.g., image rendering jobs) into rendering tasks, add them to a task queue (e.g., a rendering task queue), and maintain and update this task queue in real time. Rendering nodes (e.g., the first rendering node) can proactively initiate task requests (e.g., rendering task request) to the management node. Based on the hardware and software environment information carried by the rendering nodes, the management node comprehensively considers various factors in the task queue, such as user level (e.g., user hierarchy), resource pool level (e.g., resource pool level), job level (e.g., job level), and task level (e.g., task level), and performs priority sorting and traversal, matching and querying the corresponding factors of the rendering nodes, and assigning suitable tasks (e.g., rendering tasks) to the relevant node for processing.

[0165] In the aforementioned cluster rendering system, servers can be functionally categorized into three types: management nodes, rendering nodes, and storage nodes. Management nodes are primarily responsible for task allocation and scheduling within the cluster. Rendering nodes request tasks from the management node and then perform rendering calculations. Storage nodes store rendering assets and resulting image files. As the core of the cluster, the management node constantly updates the task queue information for the entire cluster and accepts requests from computing nodes. It allocates and schedules tasks based on a comprehensive matching of multiple factors related to nodes and tasks. Its automatic scheduling efficiency determines the machine utilization and task completion efficiency of the entire cluster system, making it of paramount importance.

[0166] Based on the aforementioned cluster rendering system, the specific implementation may include the following steps: Users submit rendering jobs (e.g., image rendering jobs) through an interface tool; the management node splits the submitted jobs into tasks and updates them to its maintained task queue; idle rendering nodes request rendering tasks from the management node, carrying their hardware and software environment information; the management node's scheduling system, according to the priority of the resource pool to which the node belongs and various attributes of the job and task, finds a task in the task queue that matches the hardware and software environment information of the requesting node and assigns it to the rendering node; the rendering node executes a script to calculate the rendering task; specifically, after reading the scene materials from the storage node, it writes the rendering result to the storage node and notifies the management node; the management node updates the task status and other information in the task queue and notifies the user's interface tool to automatically download the rendered result image file.

[0167] Based on this method, considering the multi-factor characteristics of cluster rendering scheduling tasks, the task factors to be considered when the management node allocates tasks are divided into four layers: user level, resource pool level, job level, and task level. These factors are further broken down and arranged according to the specific requirements of each layer based on the actual business scenario. When a rendering node requests a task, the management node needs to perform a comprehensive fusion and matching of various factors at different levels with the hardware and software environment of the rendering node, ultimately allocating the most suitable task to the rendering node.

[0168] The cluster rendering system supports simultaneous use by multiple users, allowing them to submit their rendering tasks to the corresponding resource pools. Each resource pool includes a number of job queues and corresponds to a number of rendering nodes. Jobs from different users can share the same resource pool, while each user can also submit jobs to different resource pools. Jobs are typically further broken down into rendering tasks according to the frame numbers set in the scene. Therefore, the task queues maintained by the management node contain information at four levels: user, resource pool, job, and task.

[0169] The first tier (corresponding to the user tier) consists of user level factors. These mainly include the user's level, status, balance, and the maximum number of rendering nodes the user is allowed to occupy simultaneously. Different levels affect the amount of resources the user is allowed to occupy simultaneously, and its upper limit, along with the user's status and balance, are necessary constraints within this tier.

[0170] The second level (corresponding to the resource pool level) consists of resource pool-level factors. As the central hub for user-submitted jobs and a collection of rendering nodes, the resource pool shares many common requirements regarding the hardware and software environment needed for job rendering tasks. Therefore, it encompasses numerous specific factors, including: resource pool status, resource pool priority, cyclic scheduling strategy for jobs within the resource pool, disk letter mappings required by jobs within the resource pool, software environment requirements for jobs within the resource pool, and hardware requirements for jobs within the resource pool.

[0171] The resource pools are categorized into positive priority (e.g., resource pools with job priority flags) and zero priority (e.g., resource pools without job priority flags). For positive priority resource pools, they are sorted in descending order of priority, ensuring that jobs in higher priority resource pools are rendered first. For zero priority node pools, they are sorted in ascending order of the total number of currently running tasks, ensuring that jobs in resource pools with fewer currently running tasks are rendered first. This aims to distribute resources as evenly as possible across these resource pools, preventing some resource pools from being left without a rendering node.

[0172] The scheduling strategies among jobs within a resource pool can be divided into three types, which can be configured according to different user needs. These include: global cyclic scheduling, priority-based cyclic scheduling of multiple jobs, and priority-based first-in-first-out (FIFO). The first type, global cyclic scheduling, ignores job priority attributes, and all jobs within the same resource pool are evenly allocated rendering nodes in a cyclical manner. The second type, priority-based cyclic scheduling of multiple jobs, first sorts all jobs within the same resource pool in descending order of priority, and then evenly allocates resources to jobs with the same priority in a cyclical manner. The third type, priority-based FIFO, first sorts all jobs within the same resource pool in descending order of priority, and then sorts jobs with the same priority according to their submission time, with earlier submitted jobs receiving node resources first.

[0173] In addition to checking whether the main rendering software is installed on the rendering nodes, the software environment required for jobs within the resource pool also provides a flexible license management method. Since rendering involves numerous types of software, renderers, and plugins, and the licensing of these software programs differs on each node, this scheme allows for the labeling of various software licenses on each rendering node. This informs the system whether the node supports the licenses for these software programs, renderers, and plugins. If not, jobs within the resource pool that require this software environment cannot be assigned to the node.

[0174] The hardware environment required for jobs within the resource pool specifies the available disk space, available memory, and number of graphics cards for the rendering nodes. This is to prevent rendering nodes from encountering hardware incompatibilities when rendering these jobs, thus reducing the success rate of rendering.

[0175] The third level (corresponding to the job level) consists of job-level factors. Besides common requirements, jobs within the resource pool may also have specific differences at the job level. These include the maximum number of rendering nodes a job can occupy simultaneously, dependencies between jobs (a child job cannot start rendering until the parent job has finished rendering), and special job types (whether distributed rendering supported by the renderer is required).

[0176] Furthermore, rendering nodes have varying hardware configurations, categorized into high-end and low-end models based on factors such as memory size and graphics card type, each with a different unit price. In addition to assigning nodes with different configurations to different resource pools, allowing users to submit jobs to different pools based on their needs, the system also supports nodes of various models within a resource pool. During task scheduling, the system compares machine types at the job level to achieve precise task allocation to nodes. The scheduling system provides a flexible machine type tag management method. Each rendering node is labeled with a corresponding machine type tag based on its hardware configuration. When submitting jobs, users can choose a low-end machine for ordinary rendering jobs and a high-end machine for complex scene rendering jobs. Even within the same resource pool, the scheduling system can accurately allocate tasks by matching the machine type tag of the requesting rendering node with the required machine type for the job.

[0177] The fourth level (corresponding to the task level) is the task-level factor. User-submitted rendering jobs are broken down into independent rendering tasks according to frame numbers, etc. This is the smallest unit in the task queue within the scheduling system and the basic unit that a rendering node may be assigned when requesting a task. Task-level factors mainly include: whether the job requires preprocessing, whether the job requires pre-rendering, and the number of tasks a node needs to request. These factors affect the task scheduling system's allocation order and quantity at the task level.

[0178] Preprocessing for rendering jobs typically involves localizing the rendering scene before rendering. This includes modifying parameters such as the output path of channel files and the maximum memory limit available to the renderer. These parameters are set according to the user's local environment. To ensure the correctness of the rendering results and efficient resource utilization, preprocessing is necessary to modify these parameters based on the cluster environment before rendering calculations are performed. If a job requires preprocessing, all its tasks must wait until preprocessing is complete before they can be assigned. Pre-rendering for rendering jobs generally refers to rendering the first, middle, and last three frames of a multi-frame job first to check the correctness of the rendering results. After confirming the rendering results, the job status is manually set, and tasks for other frames can then be assigned. For GPU rendering tasks, the number of GPUs required for each task varies, and the scheduling system also needs to calculate the number of tasks that can be allocated to the requesting rendering node based on its available resources.

[0179] These four layers of machine factors are progressive and intertwined. For example, between user factors and resource pool factors, a single user can submit jobs to multiple resource pools, while multiple users can share the same resource pool. When a node requests a task, it first traverses the task queue using the resource pool as an index. When dealing with each specific job, it must consider whether the user factor requirements are met. Between resource pools and jobs, a resource pool may contain many jobs, and different jobs have different requirements for resource permissions, machine types, etc., which not all rendering nodes within the resource pool can satisfy.

[0180] When implementing a cluster rendering system, various factors at multiple levels, such as users, resource pools, jobs, and tasks, can be fully considered and utilized. Based on the correlation between these factors, and through fusion processing during the allocation process, appropriate tasks can be determined for each rendering node, thereby effectively improving resource utilization and the overall rendering efficiency of the cluster.

[0181] Based on the above scenario examples, the image rendering method provided in this manual can combine cloud computing with rendering technology via the internet. Specifically, virtualized hardware resources can be provided to users as a service. Users only need to use the cloud rendering client or API to analyze scene parameter information, and the rendering scene and its files will be automatically uploaded to the cloud. The rendering system allocates and schedules tasks according to scene parameters and configuration information, and the rendering computation will be executed in parallel in the cloud rendering cluster, automatically sending the generated image sequence back to the client's local machine.

[0182] Based on the aforementioned rendering cluster system, the cloud-based rendering service can effectively meet the diverse market and business needs of the rendering industry. Specifically, it can accommodate the varying hardware configurations, software environments, resource quantities, rendering cycles, job priorities, and differences in pricing and revenue requirements across different clients' projects. During scheduling, the rendering cluster system can intelligently allocate tasks based on multiple factors. This ensures the compatibility of rendering nodes and tasks, meets the project schedule requirements of various users as much as possible, and maximizes the overall resource utilization of the system. Ultimately, this results in a better user experience.

[0183] While this specification provides the steps of operation for the methods described in the embodiments or flowcharts, more or fewer steps may be included based on conventional or non-inventive means. The order of steps listed in the embodiments is merely one possible order of execution among many steps and does not represent the only possible order. In actual device or client product execution, the methods shown in the embodiments or drawings may be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment, or even a distributed data processing environment). The terms "comprising," "including," or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, product, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, product, or apparatus. Without further limitations, the presence of other identical or equivalent elements in a process, method, product, or apparatus that includes said elements is not excluded. The terms "first," "second," etc., are used to denote names and do not indicate any particular order.

[0184] Those skilled in the art will also know that, besides implementing the controller using purely computer-readable program code, the same functions can be achieved by logically programming the method steps, making the controller function as logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers (PLCs), and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the devices within it used to implement various functions can also be considered structures within that hardware component. Alternatively, the devices used to implement various functions can be considered as both software modules implementing the method and structures within a hardware component.

[0185] This specification can be described in the general context of computer-executable instructions that are executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, classes, etc., that perform a specific task or implement a specific abstract data type. This specification can also be practiced in distributed computing environments, where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer-readable storage media, including storage devices.

[0186] As can be seen from the above description of the embodiments, those skilled in the art can clearly understand that this specification can be implemented by means of software plus necessary general-purpose hardware platforms. Based on this understanding, the technical solutions of this specification can essentially be embodied in the form of a software product. This computer software product can be stored in a storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, mobile terminal, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments of this specification.

[0187] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on its differences from other embodiments. This specification can be used in numerous general-purpose or special-purpose computer system environments or configurations. Examples include: personal computers, server computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable electronic devices, network PCs, minicomputers, mainframe computers, and distributed computing environments including any of the above systems or devices, etc.

[0188] Although this specification has been described by way of examples, those skilled in the art will recognize that many variations and modifications are possible without departing from the spirit of this specification, and it is intended that the appended claims cover such variations and modifications without departing from the spirit of this specification.

Claims

1. An image rendering method, characterized in that, Applied to management node servers, including: Receive a rendering task request initiated by a first rendering node server; wherein the rendering task request carries at least the server identifier of the first rendering node server; wherein the first rendering node server includes one of the following: a CPU-based rendering node server, a GPU-based rendering node server, or a CPU+GPU heterogeneous dual-server rendering node server. Based on the server identifier of the first rendering node server, a target resource pool matching the first rendering node server is determined; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks. According to preset priority rules, multiple candidate task queues are selected from the target resource pool; Based on the feature data of the first rendering node server, the job feature data of the candidate task queue, and the user feature data of the initiating user, a target task queue that matches the first rendering node server and meets the preset job requirements is determined from multiple candidate task queues; wherein, the user feature data includes at least: the number of rendering tasks currently executed and associated with the initiating user; when the number of rendering tasks currently executed and associated with the initiating user is detected to be greater than a preset threshold based on the user feature data of the initiating user in the candidate task queue, it is determined that the candidate task queue does not meet the preset job requirements; The system acquires and identifies rendering tasks that meet preset task requirements from the target task queue based on the task feature data of the rendering tasks in the target task queue, and uses these as target rendering tasks; then it assigns these target rendering tasks to the first rendering node server for processing.

2. The method according to claim 1, characterized in that, Based on preset priority rules, multiple candidate task queues are selected from the target resource pool, including: Detect whether the target resource pool has a job priority marker set, and obtain the corresponding target detection results; Based on the target detection results and the preset priority rules, a matching target priority rule is determined; and based on the target priority rule, multiple candidate task queues are selected from the target resource pool.

3. The method according to claim 2, characterized in that, Based on the target detection results and the preset priority rules, a matching target priority rule is determined; Based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including: Based on the target detection results, if it is determined that the target resource pool has a job priority tag, the first priority rule that matches the preset priority rules is determined as the target priority rule. Accordingly, based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including: Based on the first priority rule, the job priority indicator parameters for each rendering task queue in the target resource pool are determined; Multiple rendering task queues are arranged in descending order of job priority indicator parameters; From the sorted rendering task queues, select a predetermined number of rendering task queues that rank highly as candidate task queues.

4. The method according to claim 3, characterized in that, Based on the target detection results and the preset priority rules, a matching target priority rule is determined; Based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including: Based on the target detection results, if it is determined that the target resource pool does not have a job priority tag, the matching second priority rule is determined from the preset priority rules as the target priority rule; Accordingly, based on the target priority rules, multiple candidate task queues are selected from the target resource pool, including: Based on the second priority rule, determine the number of currently executed rendering tasks in each rendering task queue in the target resource pool; Arrange multiple rendering task queues in ascending order of the number of currently executed rendering tasks; From the sorted rendering task queues, select a predetermined number of rendering task queues that rank highly as candidate task queues.

5. The method according to claim 1, characterized in that, Based on the feature data of the first rendering node server and the job feature data of the candidate task queues, determine the target task queue that matches the first rendering node server from multiple candidate task queues, including: According to the internal scheduling strategy of the target resource pool, the job feature data of the candidate task queue are matched with the feature data of the first rendering node server one by one in the corresponding order; When a candidate task queue is found whose job feature data matches the feature data of the first rendering node server, that candidate task queue is determined as the target task queue.

6. The method according to claim 5, characterized in that, When a candidate task queue is found whose job feature data matches the feature data of the first rendering node server, the method further includes: Obtain the user characteristic data of the initiating user of the candidate task queue; Based on the user characteristic data of the initiating user, determine whether the candidate task queue meets the preset job requirements; If the candidate task queue meets the preset job requirements, the candidate task queue is determined as the target task queue.

7. The method according to claim 6, characterized in that, The user characteristic data of the initiating user also includes at least one of the following: the user identifier of the initiating user, and the user tag of the initiating user.

8. The method according to claim 1, characterized in that, Acquire and, based on the task feature data of the rendering tasks in the target task queue, determine the rendering tasks that meet the preset task requirements from the target task queue, and use them as the target rendering tasks, including: Determine the currently executed and unexecuted rendering tasks in the target task queue; Based on the task feature data of the currently executed rendering task and the task feature data of the currently unexecuted rendering task, a rendering task that matches the currently executed rendering task is determined from the currently unexecuted rendering tasks and used as the target rendering task.

9. An image rendering apparatus, characterized in that, Applied to management node servers, including: A receiving module is used to receive a rendering task request initiated by a first rendering node server; wherein the rendering task request carries at least the server identifier of the first rendering node server; wherein the first rendering node server includes one of the following: a CPU-based rendering node server, a GPU-based rendering node server, or a CPU+GPU heterogeneous dual-server rendering node server. The first determining module is used to determine a target resource pool that matches the first rendering node server based on the server identifier of the first rendering node server; wherein, the target resource pool stores multiple rendering task queues; each rendering task queue corresponds to an image rendering job; and each rendering task queue includes one or more rendering tasks. The filtering module is used to filter out multiple candidate task queues from the target resource pool according to preset priority rules. The second determining module is used to acquire and determine, based on the feature data of the first rendering node server, the job feature data of the candidate task queue, and the user feature data of the initiating user, a target task queue that matches the first rendering node server and meets the preset job requirements from multiple candidate task queues; wherein, the user feature data includes at least: the number of rendering tasks currently executed and associated with the initiating user; when, based on the user feature data of the initiating user in the candidate task queue, it is detected that the number of rendering tasks currently executed and associated with the initiating user is greater than a preset number threshold, it is determined that the candidate task queue does not meet the preset job requirements; The third determining module is used to acquire and determine, based on the task feature data of the rendering tasks in the target task queue, the rendering tasks that meet the preset task requirements from the target task queue, and use them as target rendering tasks; and to assign the target rendering tasks to the first rendering node server for processing.

10. A server, characterized in that, It includes a processor and a memory for storing processor-executable instructions, wherein the processor, when executing the instructions, implements the steps of the method according to any one of claims 1 to 8.

Images