CN111045797A - Task scheduling execution method, related device and medium - Google Patents
Task scheduling execution method, related device and medium Download PDFInfo
- Publication number
- CN111045797A CN111045797A CN201911053851.1A CN201911053851A CN111045797A CN 111045797 A CN111045797 A CN 111045797A CN 201911053851 A CN201911053851 A CN 201911053851A CN 111045797 A CN111045797 A CN 111045797A
- Authority
- CN
- China
- Prior art keywords
- task
- executed
- control service
- execution
- queue
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 156
- 230000008569 process Effects 0.000 claims abstract description 104
- 230000004044 response Effects 0.000 claims abstract description 64
- 238000011084 recovery Methods 0.000 claims description 5
- 230000009286 beneficial effect Effects 0.000 abstract 1
- 238000012545 processing Methods 0.000 description 20
- 230000006870 function Effects 0.000 description 13
- 230000008901 benefit Effects 0.000 description 7
- 238000004364 calculation method Methods 0.000 description 7
- 238000010586 diagram Methods 0.000 description 6
- 238000013461 design Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 5
- 238000012986 modification Methods 0.000 description 5
- 230000000977 initiatory effect Effects 0.000 description 4
- 238000007726 management method Methods 0.000 description 4
- 238000011161 development Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000004927 fusion Effects 0.000 description 2
- 239000013307 optical fiber Substances 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 238000005067 remediation Methods 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000003999 initiator Substances 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 238000004064 recycling Methods 0.000 description 1
- 238000013468 resource allocation Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
- 239000002699 waste material Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The application discloses a task scheduling execution method, a related device and a medium. The method comprises the following steps: acquiring a task to be executed: starting a task control service thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the task control service thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation; receiving the execution state response of each computing node participating in the computation in the task execution process from the task control service process through the task control service thread; and responding and recovering the task control service thread according to the execution state of each computing node. The embodiment of the disclosure is beneficial to function expansion in multi-party security computing and realizes high availability.
Description
Technical Field
The present invention relates to the field of secure computing technologies, and in particular, to a task scheduling execution method, a related apparatus, and a medium.
Background
Multi-party secure computing (MPC) is a process that allows multiple non-mutually trusted databases to perform data computation or fusion on the premise that data are kept secret from each other. It is generated based on such a background: the traditional encryption protection strategy is only limited in the transmission or storage process, and when the server or the platform needs to use the data for calculation, the server or the platform can decrypt the data to obtain the plaintext of the information, and then perform corresponding calculation and other processing on the data. In this case, there is also a hidden information security risk, and therefore, multi-party security calculation is generated, so that data calculation is performed between a plurality of non-mutually trusted databases on the premise that data are mutually confidential.
In MPC, multiple functions are often integrated into one application, for example, various tasks to be executed are put into one unified application to be implemented, and each computing node executes the application to implement multi-party secure computing. A single application may increase the development difficulty because one application may integrate multiple functions, which is not conducive to expansion, and may not meet the performance requirements of high performance, high availability, etc.
Disclosure of Invention
In view of the above problems, the present invention is directed to improving the high availability of MPC and facilitating the expansion of functions.
According to an aspect of the present disclosure, there is provided a task scheduling execution method, where the multiparty security computation is executed by a task scheduling platform scheduling computing node, the method including:
acquiring a task to be executed:
starting a task control service thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the task control service thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation;
receiving the execution state response of each computing node participating in the computation in the task execution process from the task control service process through the task control service thread;
and responding and recovering the task control service thread according to the execution state of each computing node.
Optionally, the recovering the task control service thread according to the execution state response of each computing node includes:
and if all the execution state responses of the computing nodes are successful responses, recovering the task control service thread.
Optionally, the acquiring the task to be executed includes: acquiring a task to be executed from a task queue, wherein the task to be executed in the task queue has a task execution state; starting a task control service thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the task control service thread, and after sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation, the method further comprises the following steps: modifying the task execution state of the task to be executed in the task queue to be in execution; after the task control service thread is reclaimed, the method further comprises: and modifying the task execution state of the task to be executed in the task queue to be successful in execution.
Optionally, before acquiring the task to be executed, the method further includes: in response to receiving a task execution request, generating a task to be executed with a task identifier, and putting the task to be executed into the task queue; the obtaining of the task to be executed from the task queue includes: acquiring a task to be executed from a task queue according to the task identifier; the modifying the task execution state of the task to be executed in the task queue to be in execution includes: modifying the task execution state of the task to be executed of the task identifier in the task queue to be in execution; the modifying the task execution state of the task to be executed in the task queue to be successful execution comprises: and modifying the task execution state of the task to be executed identified in the task queue to be successful in execution.
Optionally, the obtaining the task to be executed from the task queue includes: acquiring the foremost task to be executed in the task queue from the task queue; the modifying the task execution state of the task to be executed in the task queue to be in execution includes: modifying the task execution state of the foremost task to be executed in the task queue to be in execution; the modifying the task execution state of the task to be executed in the task queue to be successful execution comprises: and modifying the task execution state of the foremost task to be executed in the task queue into a task execution success state.
Optionally, the recovering the task control service thread according to the execution state response of each computing node includes: if the received execution state responses of all the computing nodes are not complete successful responses, determining that the task to be executed fails to be executed, and modifying the task execution state of the task to be executed in the task queue to be execution failure; and forcibly recovering the task control service thread corresponding to the task to be executed in a shell script mode.
Optionally, after determining that the task to be executed fails to be executed and modifying the task execution state of the task to be executed in the task queue to be execution failure if the received execution state responses of the intermediate results are not all successful responses, the method further includes: and restarting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the TC thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation.
Optionally, the sending task information to a corresponding computing node by the task control service process to perform multiparty security computation includes: and calling a task control service process by the task control service thread in a shell script mode, and sending task information to corresponding computing nodes by adopting a custom interface, wherein the custom interface is a structural body comprising a task identifier, an executable code, a scheduling node and a controller node for managing all data sources.
Optionally, after recovering the task control service thread if all the execution state responses of the computing nodes are successful responses, the method further includes:
determining whether a result demand side is allowed to obtain a task execution result;
and if so, allowing the result demander to obtain a task execution result by calling a custom result interface, wherein the custom result interface is a structural body comprising a task identifier and a result variable name to be returned.
Optionally, the determining whether to allow the result demander to obtain the task execution result includes: and acquiring an execution log generated by the computing node executing the task to be executed by a log thread, determining whether a task control service process is successfully called in a shell script mode or not based on the execution log, and determining whether a result demand side is allowed to acquire a task execution result or not.
Optionally, the determining whether to allow the result demander to obtain the task execution result by determining whether to successfully invoke the task control service process in a shell script manner based on the execution log includes: and determining whether a result demand side is allowed to obtain a task execution result or not by determining whether a task control service process is successfully called in a shell script mode or not and determining a specific field in the task to be executed based on the execution log.
Optionally, the determining, by the log thread, whether the task control service process is successfully invoked by the shell script includes:
checking whether the calling of the shell script by the task control service thread is normally ended or not by the log thread;
and if the execution log is normally finished, checking whether the received execution log meets a preset criterion, and if the execution log meets the preset criterion, determining that the task control service process is successfully called in a shell script mode.
Optionally, after checking whether the received execution log meets a predetermined criterion if normally finished, the method further comprises:
and if the calling shell script is abnormally finished or the received execution log does not accord with the preset criterion, the task control service thread is triggered again to call the task control service process in the shell script mode.
According to another aspect of the present disclosure, there is provided a task scheduling executing apparatus, where the multi-party security computation is executed by a task scheduling platform scheduling computing node, the apparatus including:
a to-be-executed task obtaining unit, configured to obtain a to-be-executed task:
a task control service thread starting unit, configured to start a task control service thread corresponding to the task to be executed in the task scheduling platform, create a corresponding task control service process by the task control service thread, and send task information to a corresponding computing node by means of the task control service process to execute multiparty security computation;
an execution state response receiving unit, configured to receive, from the task control service process via the task control service thread, an execution state response of each computing node participating in computation in the process of executing the task to be executed;
and the recovery unit is used for responding and recovering the task control service thread according to the execution state of each computing node.
According to another aspect of the present disclosure, there is provided a task scheduling platform, including: a memory storing computer readable instructions; a processor reading computer readable instructions stored by the memory to perform the method as described above.
According to another aspect of the present disclosure, there is provided a computer readable program medium storing computer readable instructions which, when executed by a processor, cause a computer to perform the method as described above.
In the task scheduling and executing scheme in the multi-party security computing provided by the embodiment of the disclosure, an MPC computing task is managed and scheduled by adopting an architecture design mode of a multi-task control thread, a task control service thread is opened for a task to be executed, a task control service process is created, and different tasks are created corresponding processes by different task control service threads. The decoupling design from the system structure can be initiated from any party, and the flexibility of the system is increased. The completely isolated task process, design and use are all extremely simple designs. The method for processing by the sub-threads can improve the task execution performance, and compared with the prior art that one method for integrating multiple functions is applied, the expandability of the MPC is improved. The function can be realized by only adding corresponding task control threads when the function is added, so that the function expansion is facilitated, and the high availability is realized.
Drawings
The above and other objects, features and advantages of the present invention will become more apparent from the following description of the embodiments of the present invention with reference to the accompanying drawings, in which:
FIG. 1 illustrates an overall architecture diagram of a multi-party secure computing environment to which embodiments of the present disclosure apply;
FIG. 2 illustrates a flow diagram of a method of task scheduling execution in multi-party security computing, according to one embodiment of the present disclosure;
FIG. 3 illustrates a flow diagram of a method for task scheduling execution in multi-party security computing, according to one embodiment of the present disclosure;
FIG. 4 illustrates a flow diagram of a method for task scheduling execution in multi-party security computing, according to one embodiment of the present disclosure;
FIG. 5 illustrates a block diagram of a task schedule execution apparatus in multi-party security computing, according to one embodiment of the present disclosure;
FIG. 6 illustrates a hardware diagram of a task scheduling platform in multi-party secure computing, according to one embodiment of the present disclosure.
Detailed Description
Various embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. Like elements in the various figures are denoted by the same or similar reference numerals. For purposes of clarity, the various features in the drawings are not necessarily drawn to scale.
The following detailed description of embodiments of the present invention is provided in connection with the accompanying drawings and examples.
The overall architecture of a multi-party secure computing environment to which embodiments of the present disclosure apply is described below with reference to FIG. 1. The overall architecture comprises a client 110, a task scheduling platform 120, a computing node 130, and a data server 140.
The client 110 is the client of the MPC task initiator. As described above, the MPC is a task that allows a plurality of non-mutually trusted databases to perform data calculation or fusion on the premise that data are kept secret from each other, and therefore, the MPC task is a task that requires a computing node to perform calculation or processing according to ciphertext of data without exposing the plaintext of the data to the computing node, so as to obtain a task processing result. If the client 110 of task initiation designates a result-obtaining end when initiating the task, the task processing result is returned to the result-obtaining end (not shown in the figure). If the specified processing result is returned to itself, the task processing result is returned to the client 110.
The data server 140 is a terminal that provides services such as data storage, data provision, and calculation result storage. It provides data for computation (but typically in the form of ciphertext).
The computation node 130 is a node that performs computation or processing on ciphertext, that is, a node that can still perform computation or processing based on ciphertext of data without knowing plaintext of the data.
The task call platform 120 is a node that organizes configuration information of tasks (e.g., which data numbers are needed, where the code executed by the computation and the task result are sent) to be delivered to different computation nodes to complete computation or processing, and in the embodiment of the present disclosure, a task is specifically divided into a task control thread 126. The tasks are sent to a plurality of computing nodes 130 at one time and executed at the same time, and each node can execute different works according to the own role. After the execution, the task control thread 126 receives the execution status of each task returned by each computing node 130, such as non-execution, successful execution, and execution failure. The task management service module 121 is a central module that performs management and scheduling of all computing tasks in the task call platform 120. The task control threads 126 are threads that perform a single computational task, with one computational task being assigned to each task control thread. The task management service module 120 includes a task queue 122, a task control service thread pool 123, and a log thread pool 124. The task execution result calculated by the computing node 130 is directly returned to the result obtaining end which requires the result.
The task queue 122 is a queue that primarily receives all tasks received on the task scheduling platform 120 and arranges them in order. The task control service thread pool 123 holds all task control service threads created for the execution of a computing task. The log thread pool 124 stores a log generated when the computing node 130 executes each thread, a processing task response log, and the like.
As shown in fig. 2, according to an embodiment of the present disclosure, there is provided a task scheduling execution method in multi-party secure computing, where the multi-party secure computing is executed by a task scheduling platform scheduling computing node, the method includes:
s210, acquiring a task to be executed:
s220, starting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the TC thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation;
s230, receiving execution state responses of all computing nodes participating in computation in the task execution process from the task control service process through the task control service thread;
s240, responding and recovering the task control service thread according to the execution state of each computing node.
The above steps are described in detail below.
In step S210, a task to be executed is acquired.
The task to be executed, that is, the task scheduling platform 120 receives and needs to schedule the task allocated to each computing node for execution.
Although a task queue 122 is shown in FIG. 1, in practice there may be no such queue. Without such a queue, the task scheduling platform 120 or the task management service module 121 receives the task to be executed directly from the client 110.
In the case of the task queue 122, as shown in fig. 1, the task to be executed may be obtained from the task queue.
In one embodiment, each task in the task queue 122 has a task identification. That is to say, before this step, the method further includes a step of generating a task to be executed with a task identifier in response to receiving a task execution request, and placing the task to be executed in the task queue. When the client 110 wants to make the computing node 130 execute a task, it first generates a task execution request, and gives it to the task scheduling platform 120, which assigns an identifier to it, generates a task to be executed with the identifier, and puts it into a task queue. The identifiers may be assigned sequentially, for example, 00000000 is assigned first, 00000001 is assigned second, and so on, or randomly, for example, generated by a random number generator, and compared with the generated identifiers after generation, and discarded if the generated identifiers are repeated. In this way, when a task is fetched from the task queue, it can be done according to the task code. For example, a task identified as 00001728 may be retrieved from the task queue for execution first, and the task may not necessarily be at the head of the queue. A benefit of this embodiment is that the flexibility of task execution is increased.
In another embodiment, step S210 includes: and acquiring the task to be executed which is arranged at the front in the task queue from the task queue. I.e. first in first out. For example, there are three tasks in the task queue, A, B, C, a first to generate and enter the queue, B second, and C last. Thus, when a task is fetched, a is fetched from the queue, followed by B and finally C. The embodiment has the advantages of ensuring that the tasks generated firstly can be processed preferentially and improving the client fairness.
In step S220, a task control service thread corresponding to the task to be executed is started in the task scheduling platform, the task control service thread creates a corresponding task control service process, and task information is sent to a corresponding computing node by the task control service process to execute multiparty security computation.
In the prior art, different functions are integrated on a computing node and processed in the same application, but in the embodiment of the disclosure, threads and processes are adopted. Different tasks are distributed to different threads for processing, and different processes are created. A process is a running activity of a program in a computer on a certain data set, and is a basic unit for resource allocation and scheduling of a system. A thread is the smallest unit that an operating system can perform computational scheduling. It is included in the process and is the actual unit of operation in the process. A thread refers to a single sequential control flow in a process, multiple threads can be concurrently executed in a process, and each thread executes different tasks in parallel. In the disclosed embodiment, however, there is only one thread in a process. And starting a task control service thread for each task to be executed, and establishing a corresponding task control service process by the task control service thread. The task is sent to a plurality of computing nodes at one time and executed at the same time, and each node can execute different works according to the role of the node. The task control service thread receives the execution state of each computing node, such as: initialization, running or running failure, etc.
In one embodiment, the sending task information to a corresponding computing node by the task control service process to perform multiparty security computation includes: and calling a task control service process by the task control service thread in a shell script mode, and sending task information to corresponding computing nodes by adopting a custom interface, wherein the custom interface is a structural body comprising a task identifier, an executable code, a scheduling node and a controller node for managing all data sources. In this embodiment, the task control service thread calls the task control service process in the shell script mode, and the task is general and is finished, which means that the task is correctly executed. As described above, the process simultaneously executes the entire task to be executed to the plurality of computing nodes, and the configuration information of the task is the sent task information. In order to transmit the task information to the computing node, a form of a custom interface is adopted, the custom interface is a structural body comprising a task identifier, an executable code, a scheduling node and a controller node for managing all data sources, so that the executed configuration information is accurately transmitted to the computing node, and the computing node can conveniently execute corresponding work. The executable code is the program code required for the execution of the task to be performed. The scheduling node is a node that performs scheduling of the task control thread 126.
The grpc execttask interface below is an example of a custom interface.
Description of the function: rpc ExecTask (TaskConfig) return (TaskResponse)
Wherein:
in the above example, string request _ id is a task identifier, string code is an executable code executed by a corresponding thread, Node tm is a scheduling Node identifier, and Node dsc is a controller Node identifier for managing all data sources, through which the executed task is forwarded to a specified data source.
Although the task scheduling platform 120 may also transmit the thread scheduling information to the computing nodes in other manners, the task control service thread calls the task control service process in a shell script manner, which has the advantage that a user-defined interface is used to send task information to the corresponding computing nodes, and the user-defined interface defines necessary information for the computing nodes to perform corresponding work, thereby improving the efficiency of transmitting the task information.
In step S230, an execution status response of each computing node participating in the computation during the task execution process is received from the task control service process via the task control service thread.
As described above, the execution task is handed to each computing node to be executed at the same time, and each computing node completes its own corresponding job and sends a response of its own execution status (unexecuted, successful execution, failed execution, etc.) back to the task control service process. In one embodiment, the process response may be received from the corresponding compute node through the following structure.
Wherein, String request _ id indicates task identification, i.e. response to which task's thread execution result. DSInfo ds _ info is data source information. The requested Status is the execution Status of the corresponding compute node, i.e., whether execution succeeded, whether execution failed, whether execution was in progress, etc. Thus, the state information returned from each computing node can know whether the whole task is successfully executed. That is, if the status responses returned by the computing nodes for a task are all successful, the entire task to be executed is successfully executed. As long as one is unsuccessful, the entire task to be performed fails.
In step S240, the task control service thread is recovered according to the execution status response of each computing node.
The task control service thread is recovered, namely the task control service thread is released back to the task control service thread pool after being finished, so that the task control service thread can be conveniently used by subsequent tasks.
In one embodiment, this step includes: and if all the execution state responses of the computing nodes are successful responses, recovering the task control service thread.
And the execution state responses of all the computing nodes are successful responses, which means that the whole task is successfully executed, and the task control service thread can be recycled, so that the resource waste is avoided.
Additionally, in one embodiment, step S210 includes: and acquiring the tasks to be executed from the task queue, wherein the tasks to be executed in the task queue have a task execution state. The task execution state refers to whether a task in the task queue is not executed, is executing, is successfully executed or fails to execute. When a task is generated and put into the task queue, the task execution state is set to be not executed. As shown in fig. 3, after step S220, the method further includes: step S225, modifying the task execution state of the task to be executed in the task queue to be in execution. After step S240, the method further comprises: step S245, modifying the task execution state of the to-be-executed task in the task queue to be successful. Therefore, the execution state of the task can be conveniently known by referring to the task execution state in the task execution process, and the task execution condition can be conveniently monitored.
As described above, a task identification may be assigned to a task to be performed. In the case that the task to be executed is assigned with the task identifier, step S210 includes: and acquiring the task to be executed from the task queue according to the task identifier. Accordingly, step 225 includes: and modifying the task execution state of the task to be executed identified in the task queue to be in execution. Accordingly, step 245 includes: and modifying the task execution state of the task to be executed identified in the task queue to be successful in execution. That is, when the execution state of the task changes, the task execution state of the task in the modification queue can be modified according to the task identifier, so that the task execution can be arbitrarily selected according to the identifier and the state can be modified, thereby improving the execution flexibility.
In addition, as described above, the task to be executed may also be acquired from the task queue by a first-in first-out method. In this embodiment, step S210 includes: acquiring the foremost task to be executed in the task queue from the task queue; step S225 includes: modifying the task execution state of the foremost task to be executed in the task queue to be in execution; step S245 includes: and modifying the task execution state of the foremost task to be executed in the task queue into a task execution success state. This embodiment has the advantage that the fairness of the task execution is improved.
In another embodiment, step S240 includes:
if the received execution state responses of all the computing nodes are not complete successful responses, determining that the task to be executed fails to be executed, and modifying the task execution state of the task to be executed in the task queue to be execution failure;
and forcibly recovering a plurality of task control service threads corresponding to the tasks to be executed in a shell script mode.
As described above, the task to be executed can be determined to be successfully executed only if all the received status responses of the computing nodes are successful responses, and the task to be executed is determined to be failed as long as one status response is not a successful response. The manner of modifying the task execution state of the task to be executed in the task queue to be execution failure is similar to the manner of modifying the task execution state of the task to be executed in the task queue to be execution success. In the case of a task identifier, the task identifier may be used. In the case of first-in first-out, the task execution state of the foremost task to be executed in the task queue may be modified to perform the task. And naturally releasing the plurality of task control service threads corresponding to the tasks to be executed according to a successful mode because the execution is not successful. At this time, the plurality of task control service threads corresponding to the task to be executed may be forcibly released in a shell script manner. The method has the advantages that under the condition that the task to be executed is not successfully realized, the infinite occupation of thread resources is avoided, and the utilization rate of data is improved.
In one embodiment, after step S241, the method further comprises: and restarting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the TC thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation.
The reason why the task to be executed fails to be executed is that the execution state response of at least one computing node after executing the task is not a successful response, and at this time, the computing node needs to re-execute its work, that is, the task control service thread needs to be re-executed. In order to execute again, a task control service thread corresponding to the task to be executed needs to be restarted, and the task control service thread sends task information to each computing node again.
In step S240, it is determined that the task to be executed has been successfully executed, but the result of the execution is not necessarily acquired. As shown in fig. 4, after step S240, in one embodiment, the method further comprises:
s250, determining whether a result demand side is allowed to obtain a task execution result;
and S260, if so, allowing the result demander to obtain a task execution result by calling a custom result interface, wherein the custom result interface is a structural body comprising a task identifier and a result variable name to be returned.
In one embodiment, step S250 includes: and acquiring an execution log generated by the computing node executing the task to be executed by a log thread, determining whether a task control service process is successfully called in a shell script mode or not based on the execution log, and determining whether a result demand side is allowed to acquire a task execution result or not.
The reason why whether the result requiring party is allowed to obtain the task execution result is determined according to whether the task control service process is successfully called by the shell script is that there is a possibility that when the task control service process is called by the task control service thread by the shell script, the task control service process may not be called at all or incorrectly called, and at this time, even if each computing node returns a successful process response, it is likely that the task execution result is incorrect even if the process response is successful, and the task execution result is likely to be the execution response of other processes or the response to the incorrect call. And if the execution result is incorrect, the result demand side acquires the task execution result, and the incorrect result is acquired. Through the embodiment, the accuracy of acquiring the task execution result is improved.
The result demander means that if the client 110 initiating the task designates a data server 140 to obtain the task execution result when initiating the task, the data server 140 is the result demander; if the specified processing result is returned to itself, the client 110 is the result demander.
Call failures or erroneous calls through the shell script may be reflected in the log of the compute node. Therefore, in the above embodiment, the task control service process is successfully invoked by determining whether the task control service process is successfully invoked by means of the shell script based on the execution log.
In one embodiment, the execution log is sent to the corresponding task control service thread at the same time that each compute node sends an execution status response to the corresponding task control service thread. In another embodiment, the execution log is obtained by a task control service thread from a specific storage location, wherein each computing node stores the execution log generated by executing the task to be executed in the specific storage location.
In one embodiment, the determining whether to allow the result demander to obtain the task execution result by determining whether the task control service process is successfully invoked by means of the shell script based on the execution log includes: and determining whether a result demand side is allowed to obtain a task execution result or not by determining whether a task control service process is successfully called in a shell script mode or not and determining a specific field in the task to be executed based on the execution log.
That is, when determining whether to allow the result demander to obtain the task execution result, not only whether the task control service process is successfully invoked by means of the shell script, but also specific fields in the task to be executed are considered. For example, the specific field value is 1, which represents that the task execution result is allowed to be acquired; the specific field value is 0, which represents that the task execution result is not allowed to be acquired.
The custom result interface at least comprises a task identifier and a result variable name to be returned. The task identification indicates which task's results are needed and the result variable name to return indicates which variable of the results to return. The function definition of a custom interface, i.e., the grpe GetREADILResult interface, is as follows. The function is rpc GetRealResult (RealResultRequest) returns (stream RealResultResultResponse)
Wherein:
wherein, string request _ id is task identification, and string variable is variable name to be returned.
In one embodiment, the determining, by the log thread, whether the task control service process was successfully invoked by way of the shell script includes:
checking whether the calling of the shell script by the task control service thread is normally ended or not by the log thread;
and if the execution log is normally finished, checking whether the received execution log meets a preset criterion, and if the execution log meets the preset criterion, determining that the task control service process is successfully called in a shell script mode.
And determining whether the task control service process is successfully called in a shell script mode or not by the log thread, and firstly checking whether the shell script called by the task control service thread is normally ended or not by the log thread. If not, successful calling by the shell script is impossible. If it ends normally, it is possible that the call ends, but the call is wrong. Therefore, a predetermined criterion is stored in advance, which indicates that the execution log is erroneous at call when what condition is satisfied. When the fact that the call of the shell script by the log thread verification task control service thread is normally finished is judged, the received execution log meets a preset criterion, and if the call is not wrong, the task control service process can be considered to be successfully called in the shell script mode. According to the embodiment, whether the calling of the shell script by the task control service thread is normally finished is checked by the log thread, whether the calling is wrong is also considered, and the accuracy of determining whether the task control service process is successfully called in a shell script mode is improved.
In one embodiment, after checking whether the received execution log meets a predetermined criterion if ended normally, the method further comprises:
and if the calling shell script is abnormally finished or the received execution log does not accord with the preset criterion, the task control service thread is triggered again to call the task control service process in the shell script mode.
The embodiment has the advantages that once the task control service process is not successfully called in the shell script mode, the task control service process can be automatically called again for remediation, and the burden of manual remediation is reduced.
In the embodiment of the disclosure, a multi-party safe computing task is managed and scheduled in the task scheduling platform by adopting a multi-task control service architecture design mode, and a complex task scheduling service is split into a plurality of task control services with simple functions and loose coupling, so that the development difficulty can be reduced, the agile development is facilitated, and the expansibility is enhanced.
Meanwhile, the fault tolerance is enhanced by a mode of a multi-task control service thread architecture, the problem of single point fault (a part which can not be operated by the whole system due to failure of one point in the system) caused by single TM service can be effectively solved, and the problem of high availability is really realized.
The multi-task control service thread architecture mode also enhances the execution performance of the computing task, and a cluster distributed deployment mode can be adopted to support massive distributed task requests, so that the requirement of high performance is met.
There is further provided, according to an embodiment of the present disclosure, a task scheduling executing apparatus 300 in multi-party secure computing, where the multi-party secure computing is executed by a task scheduling platform scheduling computing node, and the apparatus 300 includes:
a to-be-executed task obtaining unit 310, configured to obtain a to-be-executed task:
a task control service thread starting unit 320, configured to start a task control service thread corresponding to the task to be executed in the task scheduling platform, create a corresponding task control service process by the task control service thread, and send task information to a corresponding computing node by means of the task control service process to execute multiparty security computation;
an execution state response receiving unit 330, configured to receive, from the task control service process through the task control service thread, an execution state response of each computing node participating in computation in the process of executing the task to be executed;
a recovery unit 340, configured to recover the task control service thread according to the execution status response of each computing node.
Optionally, the recycling unit 340 is further configured to: and if all the execution state responses of the computing nodes are successful responses, recovering the task control service thread.
Optionally, the to-be-executed task obtaining unit 310 is further configured to: acquiring a task to be executed from a task queue, wherein the task to be executed in the task queue has a task execution state; the device further comprises: and the modifying unit is used for starting a task control service thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the task control service thread, modifying the task execution state of the task to be executed in the task queue into execution after the task control service process sends task information to a corresponding computing node to execute multiparty security computation, and modifying the task execution state of the task to be executed in the task queue into successful execution after the task control service thread is recovered.
Optionally, the apparatus further comprises: the to-be-executed task generating unit is used for responding to a received task execution request before acquiring the to-be-executed task, generating the to-be-executed task with a task identifier and putting the to-be-executed task into the task queue; the to-be-executed task obtaining unit 310 is further configured to: acquiring a task to be executed from a task queue according to the task identifier; the modification unit is further configured to: modifying the task execution state of the task to be executed of the task identifier in the task queue to be in execution; the modification unit is further configured to: and modifying the task execution state of the task to be executed identified in the task queue to be successful in execution.
Optionally, the to-be-executed task obtaining unit 310 is further configured to: acquiring the foremost task to be executed in the task queue from the task queue; the modifying the task execution state of the task to be executed in the task queue to be in execution includes: modifying the task execution state of the foremost task to be executed in the task queue to be in execution; the modifying the task execution state of the task to be executed in the task queue to be successful execution comprises: and modifying the task execution state of the foremost task to be executed in the task queue into a task execution success state.
Optionally, the recovery unit is further configured to: if the received execution state responses of all the computing nodes are not complete successful responses, determining that the task to be executed fails to be executed, and modifying the task execution state of the task to be executed in the task queue to be execution failure; and forcibly recovering the task control service thread corresponding to the task to be executed in a shell script mode.
Optionally, the recovery unit is further configured to: if the received execution state responses of all the intermediate results are not complete successful responses, the task to be executed is determined to be failed to execute, after the task execution state of the task to be executed in the task queue is modified to be failed to execute, a task control service thread corresponding to the task to be executed is started in the task scheduling platform again, a corresponding task control service process is established by the task control service thread, and task information is sent to a corresponding computing node by the task control service process to execute the multi-party security computation.
Optionally, the sending task information to a corresponding computing node by the task control service process to perform multiparty security computation includes: and calling a task control service process by the task control service thread in a shell script mode, and sending task information to corresponding computing nodes by adopting a custom interface, wherein the custom interface is a structural body comprising a task identifier, an executable code, a scheduling node and a controller node for managing all data sources.
Optionally, the apparatus further comprises: a task execution result obtaining determination unit configured to determine whether to allow a result demander to obtain a task execution result after recovering the task control service thread if all the execution state responses of the respective computing nodes are successful responses;
an allowed obtaining unit, configured to allow the result demander to obtain the task execution result by calling a custom result interface if it is determined that the allowed result demander obtains the task execution result, where the custom result interface is a structure option including a task identifier and a result variable name to be returned, and the task execution result obtaining determination unit is further configured to: and acquiring an execution log generated by the computing node executing the task to be executed by a log thread, determining whether a task control service process is successfully called in a shell script mode or not based on the execution log, and determining whether a result demand side is allowed to acquire a task execution result or not.
Optionally, the determining whether to allow the result demander to obtain the task execution result by determining whether to successfully invoke the task control service process in a shell script manner based on the execution log includes: and determining whether a result demand side is allowed to obtain a task execution result or not by determining whether a task control service process is successfully called in a shell script mode or not and determining a specific field in the task to be executed based on the execution log.
Optionally, the determining whether the task control service process is successfully invoked by the shell script includes: verifying whether the calling of the shell script by the task control service thread is normally finished; and if the execution log is normally finished, checking whether the received execution log meets a preset criterion, and if the execution log meets the preset criterion, determining that the task control service process is successfully called in a shell script mode.
In one embodiment, the apparatus further comprises: and the re-triggering unit is used for re-triggering the task control service thread to call the task control service process in a shell script mode if the call of the shell script is abnormally finished or the received execution log does not accord with the preset criterion after checking whether the received execution log accords with the preset criterion if the execution log is normally finished.
As shown in FIG. 6, the task scheduling platform 120 may be embodied in the form of a general purpose computing device. The components of the task scheduling platform 120 may include, but are not limited to: the at least one processing unit 810, the at least one memory unit 820, and a bus 830 that couples the various system components including the memory unit 820 and the processing unit 810.
Wherein the storage unit stores program code that is executable by the processing unit 810 to cause the processing unit 810 to perform steps according to various exemplary embodiments of the present disclosure described in the description part of the above exemplary methods of the present specification. For example, the processing unit 810 may perform the various steps as shown in fig. 2-4.
The storage unit 820 may include readable media in the form of volatile memory units such as a random access memory unit (RAM)8201 and/or a cache memory unit 8202, and may further include a read only memory unit (ROM) 8203.
The storage unit 820 may also include a program/utility 8204 having a set (at least one) of program modules 8205, such program modules 8205 including, but not limited to: a social operating system, one or more application programs, other program modules, and program data, each of which, or some combination thereof, may comprise an implementation of a network environment.
The task scheduling platform 120 may also communicate with one or more external devices 700 (e.g., keyboard, pointing device, bluetooth device, etc.), may also communicate with one or more devices that enable a user to interact with the task scheduling platform 120, and/or may communicate with any device (e.g., router, modem, etc.) that enables the task scheduling platform 120 to communicate with one or more other computing devices. Such communication may occur via an input/output (I/O) interface 650. Further, task scheduling platform 120 may also communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the Internet) via network adapter 860. As shown, network adapter 860 communicates with the other modules of task scheduling platform 120 via bus 830. It should be appreciated that, although not shown in the figures, other hardware and/or software modules may be used in conjunction with the task scheduling platform 120, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, among others.
Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a terminal device, or a network device, etc.) to execute the method according to the embodiments of the present disclosure.
In an exemplary embodiment of the present disclosure, there is also provided a computer program medium having stored thereon computer readable instructions which, when executed by a processor of a computer, cause the computer to perform the method described in the above method embodiment section.
According to an embodiment of the present disclosure, there is also provided a program product for implementing the method in the above method embodiment, which may employ a portable compact disc read only memory (CD-ROM) and include program code, and may be run on a terminal device, such as a personal computer. However, the program product of the present invention is not limited in this regard and, in the present document, a readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable disk, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
A computer readable signal medium may include a propagated data signal with readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A readable signal medium may also be any readable medium that is not a readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
Program code embodied on a readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device may be connected to the user computing device through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computing device (e.g., through the internet using an internet service provider).
It should be noted that although in the above detailed description several modules or units of the device for action execution are mentioned, such a division is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit, according to embodiments of the present disclosure. Conversely, the features and functions of one module or unit described above may be further divided into embodiments by a plurality of modules or units.
Moreover, although the steps of the methods of the present disclosure are depicted in the drawings in a particular order, this does not require or imply that the steps must be performed in this particular order, or that all of the depicted steps must be performed, to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps combined into one step execution, and/or one step broken down into multiple step executions, etc.
Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a mobile terminal, or a network device, etc.) to execute the method according to the embodiments of the present disclosure.
While embodiments in accordance with the invention have been described above, these embodiments are not intended to be exhaustive or to limit the invention to the precise embodiments described. Obviously, many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described in order to best explain the principles of the invention and the practical application, to thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. The invention is limited only by the claims and their full scope and equivalents.
Claims (10)
1. A task scheduling execution method, wherein the multi-party secure computing is executed by a task scheduling platform scheduling computing node, the method comprising:
acquiring a task to be executed:
starting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the TC thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation;
receiving the execution state response of each computing node participating in the computation in the task execution process from the task control service process through the task control service thread;
and responding and recovering the task control service thread according to the execution state of each computing node.
2. The method of claim 1, wherein said reclaiming the task control service thread in response to the execution state of each compute node comprises:
and if all the execution state responses of the computing nodes are successful responses, recovering the task control service thread.
3. The method of claim 1, wherein the obtaining the task to be performed comprises: acquiring a task to be executed from a task queue, wherein the task to be executed in the task queue has a task execution state;
starting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the task control service thread, and after sending task information to a corresponding computing node by means of the task control service process to execute multiparty security computation, the method further comprises the following steps: modifying the task execution state of the task to be executed in the task queue to be in execution;
after the task control service thread is reclaimed, the method further comprises: and modifying the task execution state of the task to be executed in the task queue to be successful in execution.
4. The method of claim 3, wherein prior to obtaining the task to be performed, the method further comprises: in response to receiving a task execution request, generating a task to be executed with a task identifier, and putting the task to be executed into the task queue;
the obtaining of the task to be executed from the task queue includes: acquiring a task to be executed from a task queue according to the task identifier;
the modifying the task execution state of the task to be executed in the task queue to be in execution includes: modifying the task execution state of the task to be executed of the task identifier in the task queue to be in execution;
the modifying the task execution state of the task to be executed in the task queue to be successful execution comprises: and modifying the task execution state of the task to be executed identified in the task queue to be successful in execution.
5. The method of claim 3,
the obtaining of the task to be executed from the task queue includes: acquiring the foremost task to be executed in the task queue from the task queue;
the modifying the task execution state of the task to be executed in the task queue to be in execution includes: modifying the task execution state of the foremost task to be executed in the task queue to be in execution;
the modifying the task execution state of the task to be executed in the task queue to be successful execution comprises: and modifying the task execution state of the foremost task to be executed in the task queue into a task execution success state.
6. The method of claim 3, wherein said reclaiming the task control service thread in response to the execution state of each compute node comprises:
if the received execution state responses of all the computing nodes are not complete successful responses, determining that the task to be executed fails to be executed, and modifying the task execution state of the task to be executed in the task queue to be execution failure;
and forcibly recovering the task control service thread corresponding to the task to be executed in a shell script mode.
7. The method according to claim 6, wherein after determining that the task to be executed fails to execute if the execution status responses of the received intermediate results are not all successful responses, and modifying the task execution status of the task to be executed in the task queue to be execution failure, the method further comprises:
and restarting a task control service (TC) thread corresponding to the task to be executed in the task scheduling platform, creating a corresponding task control service process by the TC thread, and sending task information to a corresponding computing node by virtue of the task control service process to execute multiparty security computation.
8. A task scheduling execution apparatus, wherein the multi-party secure computation is executed by a task scheduling platform scheduling computing node, the apparatus comprising:
a to-be-executed task obtaining unit, configured to obtain a to-be-executed task:
a task control service thread starting unit, configured to start a task control service (TC) thread corresponding to the to-be-executed task in the task scheduling platform, create a corresponding task control service process by the task control service thread, and send task information to a corresponding computing node by means of the task control service process to perform multiparty security computation;
an execution state response receiving unit, configured to receive, from the task control service process via the task control service thread, an execution state response of each computing node participating in computation in the process of executing the task to be executed;
and the recovery unit is used for responding and recovering the task control service thread according to the execution state of each computing node.
9. A task scheduling platform, comprising:
a memory storing computer readable instructions;
a processor reading computer readable instructions stored by the memory to perform the method of any of claims 1-7.
10. A computer-readable program medium storing computer-readable instructions which, when executed by a processor, cause a computer to perform the method of any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911053851.1A CN111045797A (en) | 2019-10-31 | 2019-10-31 | Task scheduling execution method, related device and medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911053851.1A CN111045797A (en) | 2019-10-31 | 2019-10-31 | Task scheduling execution method, related device and medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111045797A true CN111045797A (en) | 2020-04-21 |
Family
ID=70232842
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911053851.1A Pending CN111045797A (en) | 2019-10-31 | 2019-10-31 | Task scheduling execution method, related device and medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111045797A (en) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111625336A (en) * | 2020-05-22 | 2020-09-04 | 金蝶软件（中国）有限公司 | Thread data processing method and device |
| CN112131135A (en) * | 2020-11-19 | 2020-12-25 | 华控清交信息科技(北京)有限公司 | Ciphertext operation debugging method and system and device for ciphertext operation debugging |
| CN112187854A (en) * | 2020-08-18 | 2021-01-05 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN112187862A (en) * | 2020-08-31 | 2021-01-05 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN113157426A (en) * | 2020-10-26 | 2021-07-23 | 微医云(杭州)控股有限公司 | Task scheduling method, system, equipment and storage medium |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101442482A (en) * | 2007-11-13 | 2009-05-27 | 北京大学 | Method and system for building distributed computing network based on feedback propagation |
| CN102360310A (en) * | 2011-09-28 | 2012-02-22 | 中国电子科技集团公司第二十八研究所 | Multitask process monitoring method and system in distributed system environment |
| CN105893126A (en) * | 2016-03-29 | 2016-08-24 | 华为技术有限公司 | Task scheduling method and device |
| CN108182111A (en) * | 2018-01-23 | 2018-06-19 | 百度在线网络技术（北京）有限公司 | Task scheduling system, method and apparatus |
| US10387179B1 (en) * | 2014-12-16 | 2019-08-20 | Amazon Technologies, Inc. | Environment aware scheduling |
| CN110224812A (en) * | 2019-06-12 | 2019-09-10 | 江苏慧世联网络科技有限公司 | A kind of method and equipment that the electronic signature mobile client calculated based on Secure is communicated with Collaboration Server |
| CN110298190A (en) * | 2019-04-19 | 2019-10-01 | 矩阵元技术（深圳）有限公司 | Decentralization Secure data processing method, device and storage medium |
-
2019
- 2019-10-31 CN CN201911053851.1A patent/CN111045797A/en active Pending
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101442482A (en) * | 2007-11-13 | 2009-05-27 | 北京大学 | Method and system for building distributed computing network based on feedback propagation |
| CN102360310A (en) * | 2011-09-28 | 2012-02-22 | 中国电子科技集团公司第二十八研究所 | Multitask process monitoring method and system in distributed system environment |
| US10387179B1 (en) * | 2014-12-16 | 2019-08-20 | Amazon Technologies, Inc. | Environment aware scheduling |
| CN105893126A (en) * | 2016-03-29 | 2016-08-24 | 华为技术有限公司 | Task scheduling method and device |
| CN108182111A (en) * | 2018-01-23 | 2018-06-19 | 百度在线网络技术（北京）有限公司 | Task scheduling system, method and apparatus |
| CN110298190A (en) * | 2019-04-19 | 2019-10-01 | 矩阵元技术（深圳）有限公司 | Decentralization Secure data processing method, device and storage medium |
| CN110224812A (en) * | 2019-06-12 | 2019-09-10 | 江苏慧世联网络科技有限公司 | A kind of method and equipment that the electronic signature mobile client calculated based on Secure is communicated with Collaboration Server |
Non-Patent Citations (1)
| Title |
|---|
| 朱岩等: "基于安全多方计算的区块链智能合约执行系统" * |
Cited By (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111625336A (en) * | 2020-05-22 | 2020-09-04 | 金蝶软件（中国）有限公司 | Thread data processing method and device |
| CN111625336B (en) * | 2020-05-22 | 2024-03-19 | 金蝶软件（中国）有限公司 | Thread data processing method and device |
| CN112187854A (en) * | 2020-08-18 | 2021-01-05 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN112187854B (en) * | 2020-08-18 | 2023-10-20 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN112187862A (en) * | 2020-08-31 | 2021-01-05 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN112187862B (en) * | 2020-08-31 | 2023-08-08 | 华控清交信息科技(北京)有限公司 | Task processing method and device for task processing |
| CN113157426A (en) * | 2020-10-26 | 2021-07-23 | 微医云(杭州)控股有限公司 | Task scheduling method, system, equipment and storage medium |
| CN113157426B (en) * | 2020-10-26 | 2024-04-02 | 微医云(杭州)控股有限公司 | Task scheduling method, system, equipment and storage medium |
| CN112131135A (en) * | 2020-11-19 | 2020-12-25 | 华控清交信息科技(北京)有限公司 | Ciphertext operation debugging method and system and device for ciphertext operation debugging |
| CN112131135B (en) * | 2020-11-19 | 2021-03-05 | 华控清交信息科技(北京)有限公司 | Ciphertext operation debugging method and system and device for ciphertext operation debugging |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111045797A (en) | Task scheduling execution method, related device and medium | |
| CN109951547B (en) | Transaction request parallel processing method, device, equipment and medium | |
| US9396031B2 (en) | Distributed UIMA cluster computing (DUCC) facility | |
| US9753783B2 (en) | System and method for accelerating mapreduce operation | |
| US8973117B2 (en) | Propagating security identity information to components of a composite application | |
| CN107515785A (en) | A kind of EMS memory management process and device | |
| CN110955523B (en) | Service processing method and device | |
| CN111625496A (en) | Method, device and equipment for deploying distributed file system in virtual machine environment | |
| US20120110581A1 (en) | Task cancellation grace periods | |
| CN112256444B (en) | DAG-based service processing method, device, server and storage medium | |
| CN113448657B (en) | Method for generating and executing dynamic spark task | |
| CN112799851B (en) | Data processing method and related device in multiparty security calculation | |
| US7085853B2 (en) | System and method for a distributed shell in a java environment | |
| CN117076096A (en) | Task flow execution method and device, computer readable medium and electronic equipment | |
| CN113886502B (en) | Data processing method and system for synchronizing database and block chain | |
| US10063567B2 (en) | System for cross-host, multi-thread session alignment | |
| CN111190725B (en) | Task processing method, device, storage medium and server | |
| CN111324386B (en) | Method and device for starting split application program, electronic equipment and storage medium | |
| CN112486502A (en) | Distributed task deployment method and device, computer equipment and storage medium | |
| CN110928672A (en) | Task arranging method, device and equipment and storage medium | |
| CN113407331A (en) | Task processing method and device and storage medium | |
| CN111367875B (en) | Ticket file processing method, system, equipment and medium | |
| CN117271424B (en) | Processing device and processing method based on multimode fusion computing framework | |
| CN118413486A (en) | Method and system for realizing interactive operation based on mass data | |
| CN112148348A (en) | Task processing method and device and storage medium |
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 | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20200421 |