System, computer implementation method, computer program (circuit partitioning for sequential secure computation code execution on multiple processors)

By dividing sequential secure computation code into sub-circuits and assigning them to different processors, the system addresses the challenge of slow execution times in sequential programming languages, achieving efficient parallel processing and language migration.

JP7953971B2Active Publication Date: 2026-11-19INTERNATIONAL BUSINESS MACHINE CORPORATION
View PDF 2 Cites 0 Cited by

Patent Information

Application Number
JP2022167827
Authority / Receiving Office
JP · JP
Patent Type
Patents
Current Assignee / Owner
Priority Date
2021-10-20
Filing Date
2022-10-19
Publication Date
2026-11-19
Estimated Expiration
2042-10-19

Smart Images

  • Figure 0007953971000035
    Figure 0007953971000035
  • Figure 0007953971000036
    Figure 0007953971000036
  • Figure 0007953971000037
    Figure 0007953971000037
Patent Text Reader

Abstract

To provide a system having a processor that enables a sequentially secure computational code to be executed concurrently on multiple processors and thereby executed more efficiently.SOLUTION: The processor may modify circuits based on a cost function. The processor may divide the circuit into multiple sub-circuits. The processor may assign multiple sub-circuits to different processors for execution. The processor may also execute sequential secure computational codes using a replaced library that logs an operation type and input for each operation. The processor may generate circuits based on operations performed in response to the execution of the sequential secure computational codes.SELECTED DRAWING: Figure 2A
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present technology relates to secure computation code. More specifically, the present technology relates to the execution of sequential secure computation code, such as sequential Fully Homomorphic Encryption (FHE) code.

Background Art

[0002] Recent developments in cryptography have demonstrated how several groups can cooperate to compute functions on their own secret inputs without disclosing their own inputs. Specifically, cryptographers have proposed encryption schemes that allow arithmetic operations such as addition and multiplication to be applied to ciphertexts. The inputs to such operations may be ciphertexts that encrypt input values, or ciphertexts that are outputs of other operations. However, secure computation code such as Fully Homomorphic Encrypted (FHE) code can be slow to execute. Since performing operations on ciphertexts can take a long time, some solutions utilize multiple processors to achieve better execution time. However, in many cases, sequential programming languages may be used to describe specific solutions. Furthermore, such sequential languages are difficult to parallelize. In addition, manual parallelization is time-consuming, costly, error-prone, and may need to be performed for each deployment of a project.

Summary of the Invention

Problems to be Solved by the Invention

[0003] However, in many cases, sequential programming languages may be used to describe specific solutions. Furthermore, such sequential languages are difficult to parallelize. In addition, manual parallelization is time-consuming, costly, error-prone, and may need to be performed for each deployment of a project.

Means for Solving the Problems

[0004] According to one embodiment described herein, the system may include a processor for obtaining a circuit that describes the operation of a sequential secure computation code. Furthermore, the processor may modify the circuit based on a cost function. The processor may also divide the circuit into several sub-circuits. The processor may then assign several sub-circuits to different processors for execution.

[0005] According to other embodiments described herein, the method may include a step of a processor obtaining a circuit describing the operation of a sequential fully homomorphic encryption (FHE) code. The method may further include a step of the processor modifying the circuit based on a cost function. The method may further include a step of the processor dividing the circuit into several sub-circuits. The method may also include a step of the processor assigning the several sub-circuits to different processors for execution.

[0006] According to other embodiments described herein, a computer program product for executing sequential secure computation code may include a computer-readable storage medium through which the program code is embodied. The computer-readable storage medium is not a transient signal in itself. The program code is processor-executable such that it causes the processor to obtain a circuit describing the operation of the sequential fully secure computation code. The program code may also cause the processor to modify the circuit based on a cost function. The program code may also cause the processor to divide the circuit into multiple sub-circuits. The program code may also cause the processor to assign each of the multiple sub-circuits to a different processor for execution. [Brief explanation of the drawing]

[0007] [Figure 1]This is a block diagram of an exemplary system for executing secure computation code using the generated subcircuits. [Figure 2A] This is a block diagram of an exemplary method that can generate subcircuits for executing secure computation code based on acquired circuits that describe secure computation code.

[0008] [Figure 2B] This is a block diagram of an exemplary method that can generate subcircuits for executing secure computation code based on the received secure computation code.

[0009] [Figure 3] This is a block diagram of an exemplary computing device capable of generating subcircuits for executing secure computation code.

[0010] [Figure 4] This is a diagram illustrating an exemplary cloud computing environment according to the embodiments described herein.

[0011] [Figure 5] This is a diagram of an exemplary abstraction model layer according to the embodiments described herein.

[0012] [Figure 6] This is a diagram of an exemplary non-temporary, tangible, computer-readable medium capable of generating subcircuits for executing secure computation code. [Modes for carrying out the invention]

[0013] According to embodiments of the present disclosure, the system includes a processor capable of obtaining a circuit describing the operation of a sequential secure computation code. For example, the sequential secure computation code may be a sequential fully homomorphic encryption (FHE) code. The processor is capable of modifying the circuit based on a cost function. The processor is capable of dividing the circuit into several sub-circuits. The processor is capable of assigning several sub-circuits to different processors for execution. Thus, embodiments of the present disclosure enable the sequential secure computation code to be executed simultaneously on multiple processors and thus executed more efficiently. Furthermore, embodiments enable circuit optimization to improve the execution time of the generated circuit. Furthermore, embodiments also enable the migration of solutions from one language to another by using a standard description in the form of a generated sub-circuit.

[0014] Referring here to Figure 1, the block diagram shows an exemplary system for executing secure computation code using generated subcircuits. The exemplary system 100 in Figure 1 includes a circuit extractor 102 that is communicatively coupled to two processors 104A and 104B. For example, the two processors 104A and 104B could each be processors in different computing devices. As an example, these computing devices could be two servers connected via a network. The circuit extractor 102 includes a mockup executor 106, a circuit generator 108, a circuit modifier 110, and a circuit divider 112. The circuit extractor 102 is shown receiving sequential FHE code 114 and outputting subcircuits 116A and 116B for execution by processors 104A and 104B. For example, subcircuits 116A and 116B could be arithmetic circuits.

[0015] In the example in Figure 1, the circuit extractor 102 of system 100 can automatically generate sub-circuits 116A and 116B for execution on multiple processors 104A and 104B in response to receiving a sequential FHE code 114. Specifically, the FHE code is agnostic to the input data. Therefore, the mockup executor 106 can execute the sequential FHE code 114 using any suitable mockup ciphertext. For example, the mockup executor 106 can execute the sequential FHE code 114 using a mockup class that records each operation performed when executing the sequential FHE code 114. In various examples, the mockup executor 106 can replace the secure computation library of the sequential FHE code 114 with a library having the same interface. For example, among many examples of secure computation libraries for homomorphic encryption codes, there are HElib, first released in 2013; Homomorphic Encryption for Arithmetic of Approximate Numbers (HEAAN), first released in 2016; Simple Encrypted Arithmetic Library (SEAL), first released in 2018; PALISADE, first released in 2017; and Fast Fully Homomorphic Encryption over the Torus (TFHE), first released in 2017. This new alternative library can simulate the operation of the original library. Therefore, the sequential FHE code 114 cannot be modified before execution. Furthermore, for each operation performed by the library, this new library can log the operation type and its input. Therefore, the mock-up executor 106 can execute the sequential FHE code 114 using the replaced library and generate a log of all operations performed during execution.Since sequential FHE code 114 may not recognize the input mockup ciphertext, the same behavior may occur for all inputs at every possible step.

[0016] In various examples, the circuit generator 108 can record the actions performed during the execution of mock-up ciphertext. For example, the circuit generator 108 can collect generated logs corresponding to the actions performed by the sequential FHE code 114 and format these logs as a circuit description. For example, the description may be in the format of a graph. In some examples, the graph may be a directed acyclic graph (DAG). For example, each node in the DAG may represent an action, and each edge may represent the ciphertext on which the node acts. In various examples, each log entry from the generated logs may include the gate type, input wire label, and output wire label.

[0017] In some cases, the circuit modifier 110 can apply optimizations to the generated circuit. For example, the circuit modifier 110 can modify the circuit structure. In various cases, the circuit modifier 110 can extract a polynomial that describes the recorded circuit. For example, the polynomial may be a multivariate polynomial where each input is a variable to the polynomial. The circuit modifier 110 can then generate a second polynomial based on the number of processors to be used to execute the sequential FHE code 114 in parallel. Using the second polynomial, a second optimized circuit can be generated.

[0018] With continued reference to Figure 1, when the circuit is modified by the circuit modifier 110, the circuit divider 112 may determine which server executes each gate of the modified circuit. Accordingly, the circuit divider 112 may divide the circuit generated by the circuit generator 108 into several sub-circuits. Each of the sub-circuits may be executed by a different processor. In various examples, the circuit divider 112 may divide the circuit such that the number of edges crossing between the sub-circuits is minimized. For example, each crossing edge may represent a piece of information that should be sent from one sub-circuit to another. Thus, in examples where the processors 104A and 104B are implemented in separate servers connected by a network, such crossing edges may represent data that should be sent from one server to another. Furthermore, the circuit divider 112 may divide the circuit such that computation time is equally distributed among the sub-circuits and can be performed in parallel. The circuit divider 112 may then generate a set of sub-circuits that can be used to compute the same polynomial using several sub-circuits.

[0019] In some examples, the circuit divider 112 may use a gradient descent-based algorithm to divide the circuit into sub-circuits. For example, the circuit divider 112 may start from a given partition where each gate is assigned to be executed on one of the servers. Then, in various examples, the circuit divider 112 may iteratively apply steps in which it can search for local changes to the assignment of gates to servers. This algorithm may terminate when the circuit divider 112 cannot find any local changes that improve the execution time of the circuit. Since the circuit divider 112 can apply a change only if the change improves the execution time of the circuit, the algorithm is guaranteed to terminate. In some examples, this algorithm may be formulated as a gradient descent algorithm. For example, the objective function is a function [Formula] where [Math.] is the number of servers, [Math.] is the number of gates. One point in this space is [Math.] for the number of servers [Math.] is the partition of the number of gates. At each iteration of the algorithm, the circuit partitioner 112 is capable of taking a step along the steepest gradient from a small possible subset of gradients. For example, a gradient descent-based algorithm may take the following form. Algorithm 1 1 Input: a circuit having g gates [Math.] [Math.] number of servers [Math.] executes. 2 Output: a vector assigning each gate to a server [Math.] . 3 := [Math.] the first vector in. 4 Descent step: / / Find the best gradient 5 K := [Math.] neighborhood 6 k :=

number

number

number

number

number

number

number

number

number

number

number

number

number

number

number

number

number

number

[0020] In some examples, the circuit divider 112 uses constrained optimization to optimize a certain performance measure P, using variables x1...,x across servers. n It is possible to divide it. For example, the circuit divider 112 can divide the circuit generated by the circuit generator 108 into several subcircuits using constrained optimization calculations. For example, system 100 may include N servers, including two servers running separately on processors 104A and 104B, and attempt to complete O operations in the shortest time. Each operation is an operation

number

number

number

number

number

[0021] For example, the sequential FHE code 114 input to system 100 could be code written by a developer in any suitable high-level language such as C++. For instance, code for calculating the product of a, b, c, and d may be received in the following form: ab = mul(a, b) cd = mul(c, d) x = mul(ab, cd) Here, the first line of code calculates the product of a and b and stores it in the variable ab, the second line of code calculates the product of c and d and stores it in the variable cd, and the third line of code calculates the product of ab and cd to obtain the product of a, b, c, and d. In this example, the output of the circuit generator 108 may be a description of an arithmetic circuit. For example, the output of the circuit generator 108 may be [a multiplication gate having inputs "a" and "b" and an output called "ab"], [a multiplication gate having inputs "c" and "d" and an output called "cd"], or [a multiplication gate having inputs "ab" and "cd" and an output called "x"]. The output of the circuit extractor 102 may be a first subcircuit [a multiplication gate having inputs "a" and "b" and an output called "ab"] 116A, and a second subcircuit [a multiplication gate having inputs "c" and "d" and an output called "cd"], and [a multiplication gate having inputs "ab" and "cd" and an output called "x"] 116B. The first subcircuit 116 may be executed by the first processor 104A in parallel with the execution of subcircuit 116B by the second processor 104B.

[0022] It should be understood that the block diagram in Figure 1 is not intended to indicate that system 100 must include all the components shown in Figure 1. Rather, system 100 may include fewer components, or additional components not shown in Figure 1 (e.g., additional client devices or additional resource servers). For example, in an example where a circuit describing sequential FHE code 114 is available and directly provided to the circuit divider 112, the mockup executor 106 and circuit generator 108 can be omitted. In various examples, sequential FHE code 114 may be any other sequential secure computation code. For example, the secure computation code may be other forms of homomorphic encryption, MPC using Beaver Triple, Garbled circuitry, or any other suitable secure computation code. Furthermore, in some examples, the circuit modifier 110 and circuit divider 112 may be implemented as a single module.

[0023] Figure 2A is a process flow diagram of an exemplary method capable of generating subcircuits for the execution of secure computation code. Method 200A can be implemented using any suitable computing device, such as computing device 300 in Figure 3, and will be described with reference to system 100 in Figure 1. For example, the method described below can be implemented using processor 302 in Figure 3 or processor 602 in Figure 6.

[0024] In block 202, the processor obtains the circuitry that describes the operation of the sequential secure computation code. For example, the sequential secure computation code could be a sequential fully homomorphic encryption (FHE) code.

[0025] In block 204, the processor modifies the circuit. For example, the circuit may be modified to optimize latency or throughput when executed on several processors on different machines connected via a network. In various examples, the processor may extract the underlying polynomial of the circuit, generate a second polynomial that minimizes the cost function, and then generate the modified circuit based on this second polynomial.

[0026] In block 206, the processor divides a circuit into several sub-circuits. For example, the processor can generate a polynomial describing the circuit and then divide that polynomial into several polynomials that do not share variables. In various examples, dividing a circuit is based on reducing the difference in computation time between sub-circuits and reducing the amount of data sent between sub-circuits. In some examples, the processor divides a circuit into several sub-circuits using a gradient descent-based algorithm. For example, the processor can divide a circuit using algorithm 1. In some examples, the processor divides a circuit into several sub-circuits using constraint optimization. For example, the processor can divide a circuit using equation 3.

[0027] In block 208, the processor assigns each of these subcircuits to a different processor for execution. For example, each subcircuit may be assigned to a different processor. In various examples, the processors may be located in different computing devices connected via a network connection. In various examples, the processors can then execute the subcircuits. In this way, the execution of the sequential secure computation code is parallelized across multiple processors or computing devices.

[0028] The process flow diagram in Figure 2A is not intended to indicate that the operations of Method 200A should be performed in any particular order, or that all operations of Method 200A should be included in every case. Furthermore, Method 200A may include any number of additional operations. For example, Method 200A may include a step of translating the circuit into different code associated with different libraries and testing for performance improvements.

[0029] Figure 2B is a process flow diagram of an exemplary method capable of generating subcircuits for the execution of secure computation code. Method 200B can be implemented using any suitable computing device, such as computing device 300 in Figure 3, and will be described with reference to system 100 in Figure 1. For example, the method described below can be implemented using processor 302 in Figure 3 or processor 602 in Figure 6. Figure 2B includes blocks that are referenced in the same way as in Figure 2A.

[0030] In block 210, the processor receives a sequential secure computation code. For example, the sequential secure computation code could be a sequential fully homomorphic encryption (FHE) code.

[0031] In block 212, the processor executes sequential secure computation code. For example, sequential secure computation code may be executed with mockup ciphertext as input. In various examples, the processor may execute secure computation code using an alternative library that logs the actions performed during execution.

[0032] In block 214, the processor generates a circuit based on logged operations performed in response to the execution of sequential secure computation code. For example, the logged operations may be formatted in the form of a graph. In some examples, the graph may be a directed acyclic graph (DAC). In various examples, the generated circuit may be an arithmetic circuit.

[0033] In blocks 204, 206, and 208, the processor executes the blocks referenced in the same manner as described in Figure 2A. For example, in block 204, the processor modifies the circuit. In block 206, the processor divides the circuit into several sub-circuits. In block 208, the processor assigns these sub-circuits to different processors for execution.

[0034] The process flow diagram in Figure 2B is not intended to indicate that the operations of Method 200B should be performed in any particular order, or that all operations of Method 200B should be included in every case. Furthermore, Method 200B may include any number of additional operations. For example, Method 200B may include a step of translating the circuit into different code associated with different libraries and testing for performance improvements.

[0035] While this disclosure includes a detailed description of cloud computing, it should be understood that the implementation of the teachings described herein is not limited to cloud computing environments. Rather, embodiments of the present invention can be implemented in conjunction with any other type of computing environment currently known or to be developed in the future.

[0036] Cloud computing is a service delivery model that enables convenient on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and deployed with minimal management effort or interaction with service providers. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0037] The following are its characteristics.

[0038] On-demand self-service: Cloud consumers can unilaterally provision computing power, such as server time and network storage, automatically as needed, without requiring human interaction with service providers.

[0039] Broad network access: Capabilities are available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin-client or thick-client platforms (e.g., mobile phones, laptops, and PDAs).

[0040] Resource pooling: A provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, with various physical and virtual resources dynamically allocated and reallocated according to demand. Consumers generally do not have control over, or knowledge of, the exact location of the resources provided, although they may be able to specify the location at a higher level of abstraction (e.g., country, state, or data center), thus exhibiting location independence.

[0041] Rapid scalability: Capabilities can be provisioned quickly and flexibly, sometimes automatically, allowing for instant scaling out or rapid release and instant scaling in. For consumers, it often feels like there's unlimited capacity available for provisioning, and they can purchase any amount at any time.

[0042] Measuring Services: Cloud systems automatically control and optimize resource usage by leveraging metric capabilities at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage is monitored, controlled, and reported, providing transparency to both service providers and consumers.

[0043] The following is the service model.

[0044] Software as a Service (SaaS): The capability offered to consumers is the use of a provider's applications running on cloud infrastructure. These applications are accessible from various client devices through thin client interfaces such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, storage, or even individual application capabilities. However, limited user-specific application configuration settings may be an exception.

[0045] Platform as a Service (PaaS): The capability offered to consumers is the ability to deploy applications they have created or acquired, written using programming languages ​​and tools supported by the provider, onto a cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they do control the deployed applications and, in some cases, the configuration of the application hosting environment.

[0046] Infrastructure as a Service (IaaS): The ability provided to consumers is the provisioning of processing, storage, networking, and other fundamental computing resources, which consumers can then deploy and run any software, including operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they do control the operating system, storage, and deployed applications, and, in some cases, have limited control over selected networking components (e.g., host firewalls).

[0047] The deployment model is as follows:

[0048] Private Cloud: A cloud infrastructure operated exclusively for one organization. It can be managed by the organization or a third party and can reside on-premises or off-premises.

[0049] Community Cloud: A cloud infrastructure shared by several organizations to support a specific community with common interests (e.g., mission, security requirements, policies, and compliance considerations). It can be managed by an organization or a third party and can reside on-premises or off-premises.

[0050] Public cloud: Cloud infrastructure is made available to the general public or large industry groups and is owned by organizations that sell cloud services.

[0051] Hybrid cloud: A cloud infrastructure that combines two or more clouds (private, community, or public), where each cloud remains a distinct entity, but is bound together by standardized or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing across clouds).

[0052] Cloud computing environments are service-oriented, emphasizing statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing lies an infrastructure that includes a network of interconnected nodes.

[0053] Figure 3 is a block diagram of an exemplary computing device capable of generating subcircuits for executing secure compute code. The computing device 300 could be, for example, a server, desktop computer, laptop computer, tablet computer, or smartphone. In some examples, the computing device 300 could be a cloud computing node. The computing device 300 can be described in the general context of computer system executable instructions executed by a computer system, such as program modules. Generally, program modules may include routines, programs, objects, components, logic, and data structures that perform a specific task or implement a specific abstract data type. The computing device 300 can be implemented in a distributed cloud computing environment where tasks are performed by remote processing devices linked over a communication network. In a distributed cloud computing environment, program modules may reside on both local computer system storage media, including memory storage devices, and remote computer system storage media.

[0054] The computing device 300 may include a processor 302 for executing stored instructions, and a memory device 304 for providing temporary memory space for the operation of those instructions during operation. The processor may be a single-core processor, a multi-core processor, a computing cluster, or any number of other configurations. The memory 304 may include random-access memory (RAM), read-only memory, flash memory, or any other suitable memory system.

[0055] The processor 302 may be connected to an input / output (I / O) device interface 308 via a system interconnect 306 (e.g., PCI®, PCI-Express®, etc.) which is adapted to connect the computing device 300 to one or more I / O devices 310. The I / O devices 310 may include, for example, a keyboard and a pointing device, the pointing device of which may include, among other things, a touchpad or a touchscreen. The I / O devices 310 may be built-in components of the computing device 300 or may be devices connected to the computing device 300 from an external source.

[0056] The processor 302 may also link to a display interface 312 adapted to connect the computing device 300 to a display device 314 via the system interconnect 306. The display device 314 may include a display screen that is a built-in component of the computing device 300. The display device 314 may also include, among other things, a computer monitor, television, or projector that is connected externally to the computing device 300. Furthermore, the network interface controller (NIC) 316 may be adapted to connect the computing device 300 to a network 318 via the system interconnect 306. In some embodiments, the NIC 316 is capable of transmitting data using any suitable interface or protocol, among other things, such as an Internet Small Computer System Interface. The network 318 may be, among other things, a cellular network, a wireless network, a wide area network (WAN), a local area network (LAN), or the Internet. An external computing device 320 may connect to the computing device 300 via the network 318. In some examples, the external computing device 320 may be an external web server 320. In some examples, the external computing device 320 may be a cloud computing node.

[0057] The processor 302 can also be linked through the system interconnect 306 to a storage device 322 which may include a hard drive, optical drive, USB flash drive, drive array, or any combination thereof. In some examples, the storage device may include a receiver module 324, a code executor module 326, a circuit generator module 328, a circuit modifier module 330, a circuit divider module 332, and a transmitter module 334. The receiver module 324 is capable of receiving sequential secure computation code. For example, sequential secure computation code may be sequential FHE code. The code executor module 326 is capable of executing sequential secure computation code using a replaced library that logs the operation type and input for each operation. The circuit generator module 328 is capable of obtaining a circuit that describes the operation of the sequential secure computation code. For example, the circuit may be an arithmetic circuit. In various examples, the circuit can be converted into a second code different from the secure computation code. The circuit generator module 328 can generate circuits based on actions performed in response to the execution of sequential secure computation code. The circuit modifier module 330 can modify circuits based on a cost function. In various examples, the circuit modifier module 330 can extract the fundamental polynomial of the circuit, generate a second polynomial that minimizes the cost function, and generate a modified circuit based on this second polynomial. In some examples, the circuit modifier module 330 can modify circuits iteratively. For example, for higher dimensions, the circuit modifier module 330 can repeatedly run Newton's method (also known as the Newton-Raphson method) until a polynomial of the form (xa)(xb)(xc)...(xn) is obtained. The circuit divider module 332 can divide a circuit into several subcircuits. For example, the circuit divider module 332 can randomly assign each node to a server.Next, the circuit divider module 332 can parse all node pairs and switch the servers assigned to them. If the switch does not improve the cost function, the circuit divider module 332 can reverse this change. In various examples, the circuit divider module 332 can consider all pairs in this way and repeatedly switch them until there are no more pairs to switch. In some examples, the circuit divider module 332 can divide the circuit using a gradient descent-based algorithm. For example, the circuit divider module 332 can divide the circuit using algorithm 1 described above. In some examples, the circuit divider module 332 can divide the circuit using constrained optimization. For example, the circuit divider module 332 can solve the division as a constrained optimization problem using, among other things, equation 1 above and any combination of the various constraints described herein. The circuit divider module 332 may be given various constraints, such as gate X being the input to gate Y (formulated as appropriate), or gate X taking a long time to compute and ciphertext C taking a long time to transmit. Next, the circuit divider module 332 can minimize the objective function. For example, the objective function can be designed to minimize the completion time of the last gate. The transmitter module 334 can assign several sub-circuits to different processors for execution. Then, the transmitter module 334 can transmit several sub-circuits to different processors for execution.

[0058] It should be understood that the block diagram in Figure 3 is not intended to show that the computing device 300 includes all the components shown in Figure 3. Rather, the computing device 300 may include fewer components, or additional components not shown in Figure 3 (e.g., additional memory components, embedded controllers, modules, additional network interfaces, etc.). For example, the computing device 300 may further include a code translation module (not shown) for translating circuits into different code associated with different libraries to test performance improvements. Furthermore, any of the functions of the receiver module 324, code executor module 326, circuit generator module 328, circuit modifier module 330, circuit divider module 332, and transmitter module 334 can be implemented in hardware, in the processor 302, or both, in part or in whole. For example, the functions can be implemented using application-specific integrated circuits, logic implemented in embedded controllers, or within logic implemented in the processor 302. In some embodiments, the functions of the receiver module 324, code executor module 326, circuit generator module 328, circuit modifier module 330, circuit divider module 332, and transmitter module 334 can be implemented using logic, which may include any suitable hardware (e.g., a processor, among other things), software (e.g., an application, among other things), or any suitable combination of hardware, software, and firmware.

[0059] Referring now to Figure 4, an exemplary cloud computing environment 400 is shown. As shown in the figure, the cloud computing environment 400 includes one or more cloud computing nodes 402 that can communicate with local computing devices used by cloud consumers (e.g., a personal digital assistant (PDA) or cellular phone 404A, a desktop computer 404B, a laptop computer 404C, or an automotive computer system 404N, or a combination thereof). The nodes 402 can communicate with each other. They can be physically or virtually grouped (not shown) within one or more networks, such as a private cloud, community cloud, public cloud, or hybrid cloud, or a combination thereof, as described above. This makes it possible for the cloud computing environment 400 to provide infrastructure, platform, or software, or a combination thereof, as a service, without requiring cloud consumers to maintain resources on their local computing devices for that service. The types of computing devices 404A through 404N shown in Figure 4 are for illustrative purposes only, and it should be understood that the computing node 402 and the cloud computing environment 400 can communicate with any type of computerized device via any type of network, a network addressable connection, or both (for example, using a web browser).

[0060] Referring now to Figure 5, a set of functional abstraction layers provided by the cloud computing environment 400 (Figure 4) is shown. It should be understood in advance that the components, layers, and functionalities shown in Figure 5 are for illustrative purposes only and that embodiments of the present invention are not limited thereto. As illustrated, the following layers and corresponding functionalities are provided:

[0061] The hardware and software layer 500 includes hardware and software components. Examples of hardware components include a mainframe 501, RISC (Reduced Instruction Set Computer) architecture-based servers 502, 503, blade servers 504, storage devices 505, and network and networking components 506. In some embodiments, software components include network application server software 507 and database software 508.

[0062] The virtualization layer 510 provides an abstraction layer. From the abstraction layer, examples of the following virtual entities may be provided: a virtual server 511, virtual storage 512, a virtual network 513 including a virtual private network, a virtual application and operating system 514, and a virtual client 515.

[0063] In one example, the management layer 520 may provide the following functions: Resource provisioning 521 dynamically procures computing and other resources used to perform tasks within the cloud computing environment. Measurement and pricing 522 tracks costs as resources are used within the cloud computing environment and generates or sends invoices for the consumption of these resources. In one example, these resources may include application software licenses. Security verifies the identity of cloud consumers and tasks, as well as protecting data and other resources. The user portal 523 provides consumers and system administrators with access to the cloud computing environment. Service level management 524 allocates and manages cloud computing resources to ensure that the required service levels are met. Service level agreement (SLA) formulation and execution 525 proactively coordinates and procures cloud computing resources that are expected to be needed in the future in accordance with the SLA.

[0064] The workload layer 530 provides several examples of functions for which a cloud computing environment can be utilized. Examples of workloads and functions that can be provided from this layer include mapping and navigation 531, software development and lifecycle management 532, virtual classroom education delivery 533, data analysis processing 534, transaction processing 535, and secure computed code processing 536.

[0065] The present invention may be a system, method, or computer program product, or a combination thereof, integrated at any possible level of technical detail. The computer program product may include a computer-readable storage medium (or a plurality of computer-readable storage media) having computer-readable program instructions for causing a processor to perform an aspect of the present invention.

[0066] Computer-readable storage media can be tangible devices capable of holding and storing instructions used by instruction execution devices. Computer-readable storage media can be, but are not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination of the above. A non-exclusive list of more specific examples of computer-readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital multipurpose disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or grooved raised structures on which instructions are recorded, and any suitable combination of the above. In this specification, computer-readable storage media themselves are not considered to be radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through fiber optic cables), or transient signals such as electrical signals transmitted through wires.

[0067] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device, or they may be downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives computer-readable program instructions from the network and transfers the computer-readable program instructions for storage in a computer-readable storage medium within each computing / processing device.

[0068] The computer-readable program instructions that perform the operation of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, and may be code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk® or C++, and conventional procedural programming languages ​​such as the C programming language or similar programming languages. The computer-readable program instructions can run as a standalone software package in whole on the user's computer, in part on the user's computer, in part on the user's computer and in part on a remote computer, or in whole on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be to an external computer (for example, via the Internet using an Internet service provider). In some embodiments, for example, an electronic circuit including a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA) can be personalized by executing computer-readable program instructions using state information of computer-readable program instructions in order to perform an aspect of the present invention.

[0069] Aspects of the present invention are described herein with reference to flowcharts or block diagrams, or both, of methods, apparatus (systems), and computer program products according to embodiments of the present invention. It will be understood that each block in a flowchart or block diagram, or a combination thereof, and any combination of blocks in a flowchart or block diagram, or a combination thereof, can be implemented by computer-readable program instructions.

[0070] These computer-readable program instructions may be provided to the processor of a general-purpose computer, a dedicated computer, or other programmable data processing device for generating machines, thereby creating means for instructions executed via the computer's processor or other programmable data processing device to implement functions / operations specified in one or more blocks in a flowchart or block diagram or a combination thereof. These computer-readable program instructions may also be stored in a computer-readable storage medium capable of instructing a computer, a programmable data processing device, or other device, or a combination thereof, to function in a particular manner, thereby including a product in which the computer-readable storage medium storing the instructions contains instructions that implement modes of functions / operations specified in one or more blocks of a flowchart or block diagram, or both.

[0071] Furthermore, computer-readable program instructions can be loaded into a computer, other programmable data processing device, or other device to create a computer implementation process by causing a series of operational steps on the computer, other programmable device, or other device, thereby enabling the instructions executed on the computer, other programmable device, or other device to implement functions / operations specified in one or more blocks of a flowchart or block diagram, or both.

[0072] Referring here to Figure 6, a block diagram of an exemplary non-temporary tangible computer-readable medium 600 capable of generating subcircuits for executing secure computation code is shown. The non-temporary tangible computer-readable medium 600 may be accessed by the processor 602 via the computer interconnect 604. Furthermore, the non-temporary tangible computer-readable medium 600 may contain code for instructing the processor 602 to perform the operation of method 200A or 200B as shown in Figures 2A and 2B.

[0073] As shown in Figure 6, various software components discussed herein can be stored on a non-temporary tangible computer-readable medium 600. For example, the receiver module 606 includes code for receiving sequential secure computation code. In some examples, the sequential secure computation code may be sequential FHE code. The code executor module 608 includes code for executing the sequential secure computation code. The code executor module 608 further includes code for executing the secure computation code using an alternative library that logs the actions performed during execution. The circuit generator module 610 includes code for obtaining a circuit that describes the actions of the sequential secure computation code. The circuit generator module 610 also includes code for generating a circuit based on the logged actions performed in response to the execution of the sequential secure computation code. In various examples, the circuit generator module 610 includes code for formatting the logged actions as a graph. The circuit modifier module 612 includes code for modifying a circuit based on a cost function. In various examples, the circuit modifier module 612 includes code to extract the fundamental polynomial of the circuit, generate a second polynomial that minimizes the cost function, and generate the modified circuit based on this second polynomial. The circuit divider module 614 includes code to divide the circuit into several sub-circuits. The transmitter module 616 includes code to assign each of the sub-circuits to a different processor for execution. The transmitter module 616 can then transmit each of the sub-circuits to a different processor for execution.

[0074] The flowcharts and block diagrams in the drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of instructions containing one or more executable instructions that implement a specified logical function. In some alternative implementations, the functions described in the blocks may be performed in an order different from the order shown in the drawings. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or blocks may be executed in reverse order depending on the functional characteristics involved. It should also be noted that each block in the block diagram or flowchart, or a combination thereof, and combinations of blocks in the block diagram or flowchart, or both, may be implemented by an application-specific hardware-based system that performs a specified function or operation, or executes a combination of application-specific hardware and computer instructions. Depending on the specific application, it should be understood that any number of additional software components not shown in Figure 6 may be included in the non-temporary tangible computer-readable medium 600. For example, the computer-readable medium 600 may also include a code conversion module (not shown) for converting circuits into different codes associated with different libraries to perform tests for performance improvements.

[0075] The descriptions of the various embodiments of this disclosure are presented for illustrative purposes only and are not intended to be comprehensive or limitless. Those skilled in the art will see many modifications and variations that do not deviate from the scope and spirit of the described embodiments. The terminology used herein has been chosen to best describe the principles of the embodiments, the practical applications of the technologies found in the market or technical improvements thereto, or to enable other those skilled in the art to understand the embodiments disclosed herein.

Claims

1. Receive the sequential secure calculation code, The sequential secure computation code is executed using a replaced library that logs the operation type and input for each operation. A circuit is generated based on the actions performed in response to the execution of the aforementioned sequential secure computation code. The circuit is modified based on a cost function that evaluates the execution efficiency of the circuit as a cost, The circuit is divided into multiple sub-circuits, The aforementioned subcircuits are assigned to different processors for execution. A system equipped with a processor for that purpose.

2. The system according to claim 1, wherein the processor extracts a polynomial describing the circuit, generates a second polynomial that minimizes the cost function, and generates a modified circuit based on the second polynomial.

3. The system according to claim 1, wherein the processor is for iteratively modifying the circuit.

4. The system according to claim 1, wherein the processor is for dividing the circuit using a gradient descent-based algorithm.

5. The system according to claim 1, wherein the processor is for partitioning the circuit using constrained optimization.

6. The system according to claim 1, wherein the cost function is a function that evaluates the latency of the circuit or the throughput of the circuit as the cost.

7. The system according to any one of claims 1 to 6, wherein the circuit is convertible to a second code different from the sequential secure calculation code.

8. The processor receives sequential secure computation code, The processor performs the step of executing the sequential secure computation code, The processor generates a circuit based on logged operations performed in response to the execution of the sequential secure computation code. The processor modifies the circuit based on a cost function that evaluates the execution efficiency of the circuit as a cost, The processor divides the circuit into multiple sub-circuits, The processor performs the steps of assigning the plurality of sub-circuits to different processors for execution. Equipped with, A computer implementation method wherein the step of executing the sequential secure computation code includes a step of executing the sequential secure computation code using an alternative library that logs the actions performed during execution.

9. The computer implementation method according to claim 8, wherein the step of generating the circuit includes a step of formatting the logged operation as a graph.

10. The computer implementation method according to claim 8, wherein the step of modifying the circuit includes the steps of extracting a polynomial that describes the circuit, generating a second polynomial that minimizes the cost function, and generating a modified circuit based on the second polynomial.

11. The computer implementation method according to claim 8, wherein the step of dividing the circuit is based on reducing the difference in calculation time between the plurality of subcircuits and reducing the amount of data sent between the plurality of subcircuits.

12. The computer implementation method according to claim 8, wherein the cost function is a function that evaluates the latency of the circuit or the throughput of the circuit as the cost.

13. The computer implementation method according to any one of claims 8 to 12, further comprising the step of using the processor to convert the circuit into different code associated with different libraries and to perform tests for performance improvements.

14. A computer program for executing sequential secure computation code, wherein the computer program comprises program code, and the program code is transmitted to a processor. The sequential secure calculation code is received, The sequential secure calculation code is executed, The circuit is generated based on the logged actions performed in response to the execution of the sequential secure computation code. The circuit is modified based on a cost function that evaluates the execution efficiency of the circuit as a cost, The circuit is divided into multiple sub-circuits, The aforementioned multiple sub-circuits are assigned to different processors for execution. This is executable by the aforementioned processor, A computer program further comprising program code executable by the processor to execute the sequential secure computation code, using an alternative library for logging the actions performed during execution.

15. The computer program according to claim 14, further comprising program code executable by the processor to format the logged operations as a graph.

16. The computer program according to claim 14, further comprising program code executable by the processor to extract a polynomial describing the circuit, generate a second polynomial that minimizes the cost function, and generate a modified circuit based on the second polynomial.

17. The computer program according to claim 14, wherein the cost function is a function that evaluates the latency of the circuit or the throughput of the circuit as the cost.

18. The computer program according to any one of claims 14 to 17, further comprising program code executable by the processor to translate the circuit into different code associated with different libraries and to perform tests for performance improvements.

19. The system according to claim 1, wherein the processor generates a polynomial describing the circuit in order to divide the circuit into a plurality of subcircuits, and divides the polynomial into a plurality of polynomials that do not share variables.

20. The computer implementation method according to claim 8, wherein the step of dividing the circuit into the plurality of subcircuits comprises the step of generating a polynomial that describes the circuit, and the step of dividing the polynomial into a plurality of polynomials that do not share variables.

21. The computer program according to claim 14, further comprising program code executable by the processor to generate a polynomial describing the circuit in order to divide the circuit into a plurality of subcircuits, and to divide the polynomial into a plurality of polynomials that do not share variables.

Citation Information

Patent Citations

  • Distributed ledger apparatus, distributed ledger system and distributed ledger management method

    JP2020170342A

  • Homomorphic evaluation of tensor programs

    US20200076570A1