text:
JP2011076513A - Distributed processing system - Google Patents
Distributed processing system Download PDF
JP2011076513A
JP2011076513A JP2009229252A JP2009229252A JP2011076513A JP 2011076513 A JP2011076513 A JP 2011076513A JP 2009229252 A JP2009229252 A JP 2009229252A JP 2009229252 A JP2009229252 A JP 2009229252A JP 2011076513 A JP2011076513 A JP 2011076513A
processing block
Masanori Kubo
Takayuki Nakatomi
Arata Shinozaki
高之 中富
允則 久保
新 篠崎
Olympus Corp
オリンパス株式会社
2009-10-01 Application filed by Olympus Corp, オリンパス株式会社 filed Critical Olympus Corp
2009-10-01 Priority to JP2009229252A priority Critical patent/JP2011076513A/en
2011-04-14 Publication of JP2011076513A publication Critical patent/JP2011076513A/en
Status Withdrawn legal-status Critical Current
238000000034 methods Methods 0.000 claims abstract description 55
239000004698 Polyethylene (PE) Substances 0.000 claims description 43
238000000275 quality assurance Methods 0.000 claims description 10
239000003138 indicators Substances 0.000 claims 4
230000003362 replicative Effects 0.000 description 4
280000603137 Block as companies 0.000 description 3
281000010254 Secure Computing companies 0.000 description 2
280000667465 Run Time companies 0.000 description 1
230000000536 complexating Effects 0.000 description 1
238000005111 flow chemistry technique Methods 0.000 description 1
230000001629 suppression Effects 0.000 description 1
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/50—Allocation of resources, e.g. of the central processing unit [CPU]
G06F9/5061—Partitioning or combining of resources
G06F9/5066—Algorithms for mapping a plurality of inter-dependent sub-tasks onto a plurality of physical CPUs
G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
G06F9/5044—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering hardware capabilities
G06F2209/00—Indexing scheme relating to G06F9/00
G06F2209/5017—Task decomposition
Y02D10/22—
Disclosed is a distributed processing system that defines an optimum degree of parallelism from an index for performing parallel execution.
A distributed processing system for executing an application, comprising: a processing element capable of parallel processing; a control unit; and a client requesting the control unit to execute the application. The element is based at least on one or more processing blocks that process each of the one or more tasks that the processing element performs at least during the execution of the application, and an index received from the control unit that controls the degree of parallelism. A processing block control unit that calculates the degree of parallelism, a division unit that divides processing data input to the processing block based on the degree of parallelism by the processing block control unit, and a processing block based on the degree of parallelism by the processing block control unit Processing data output from Having a integrating unit for integrating.
[Selection] Figure 1
The present invention relates to a distributed processing system.
In some conventional parallel processing systems, an application requested by a user is input to the system as a program or wiring information and is parallelized. A program written in a high-level language or the like can be described regardless of whether the processing system performs sequential processing or parallel processing. It is automatically extracted to perform data division and program division, and further determine whether communication between calculation modules is necessary. An example of such a parallel program generation method is Patent Document 1.
JP-A-8-328872
In the automatic parallelization in the conventional parallel processing system described above, there are many cases where a parallelizable part is extracted from a program or the like input by a user and assigned to a calculation module or converted into wiring information. Further, there is a system such as an operating system in which a process is assigned to a calculation module such as a processor core that is different for each program and the user is not involved in parallelization at all. These systems execute parallelization only in consideration of optimizing the performance at the time of execution, and an index for the user to flexibly control the parallelization has not been provided.
The present invention has been made in view of the above, and is defined by a data flow type module network composed of calculation modules that provide one or more specific functions in order to realize a service requested by a user. An object of the present invention is to provide a distributed processing system that defines not only parallelism and overall performance but also power consumption and processing time as an index for performing parallel execution in the system, and that defines an optimum degree of parallelism from these indices. Parallelization in this distributed processing system is virtually provided within the calculation module.
It is a further object of the present invention to provide a distributed processing system that can dynamically increase or decrease the number of processing blocks in a calculation module according to a dynamically defined parallelism. Another object of the present invention is to dynamically construct an optimum application execution environment for the user himself / herself by defining an index to be noticed when executing the application as a policy even if the user does not directly specify the degree of parallelism. And
In order to solve the above-described problems and achieve the object, a distributed processing system according to the present invention includes a processing element capable of parallel processing, a control unit, and a client that requests the control unit to execute an application. A distributed processing system for executing an application, wherein the processing element processes each of the one or more tasks to be executed by the processing element at least when the application is executed A block, a processing block control unit for calculating the degree of parallelism based on an index for controlling the degree of parallelism received from the control unit, and processing data input to the processing block based on the degree of parallelism by the processing block control unit Dividing part to be divided and processing block The control unit is characterized by having, an integrated unit for integrating processing data outputted from the processing block based on parallelism.
In the distributed processing system according to the present invention, the processing element preferably has a plurality of processing blocks in advance.
In the distributed processing system according to the present invention, when the processing element is connected to the control unit, its function information, configuration information, maximum parallelism, and characteristics of the parallelism and an index for controlling the parallelism It is preferable to register PE information including a profile representing.
In the distributed processing system according to the present invention, it is preferable that the client specifies a standard related to execution of the application.
In the distributed processing system according to the present invention, the control unit determines and presents index candidates for controlling the degree of parallelism based on the PE information and / or criteria for executing the application, and the client displays the index candidate. It is preferable to determine an index for controlling the degree of parallelism by selecting an index from among them.
In the distributed processing system according to the present invention, it is preferable that the control unit determines an index for controlling the degree of parallelism based on the PE information and / or a criterion related to execution of the application.
In the distributed processing system according to the present invention, the index for controlling the degree of parallelism preferably includes an upper limit and a lower limit of the degree of parallelism of each processing element.
In the distributed processing system according to the present invention, when the upper limit value and the lower limit value of the parallelism are different from each other, the processing block control unit determines the parallelism according to an index for controlling the parallelism excluding the upper limit and the lower limit. It is preferable.
In the distributed processing system according to the present invention, when the upper limit value and the lower limit value of the degree of parallelism match each other, the processing block control unit preferably performs processing with the matching degree of parallelism.
In the distributed processing system according to the present invention, the processing block includes a dedicated processing block for executing a predetermined function, a general-purpose processing block whose function is changed by input program information, and hardware by the input reconfiguration information. It is preferable to include at least one of a dynamic reconfigurable processing block to be reconfigured.
In the distributed processing system according to the present invention, the processing block is a dedicated processing block configured by software, the processing element includes a dedicated processing block in advance, and the processing element unloads, duplicates, and copies the dedicated processing block. Alternatively, it is preferable to have a dedicated processing block holding unit that can be erased and can hold a dedicated processing block that has been unloaded and / or copied.
In the distributed processing system according to the present invention, it is preferable that the dedicated processing block holding unit replicates the held dedicated processing block according to the degree of parallelism.
In the distributed processing system according to the present invention, it is preferable that the dedicated processing block holding unit loads the held dedicated processing block so that it can be processed.
In the distributed processing system according to the present invention, the processing block is a dedicated processing block configured by hardware, by connecting / disconnecting a path connecting the input of the dedicated processing block to the dividing unit and connecting the output to the integrating unit, It is preferable to execute a predetermined function and control the parallelism.
In the distributed processing system according to the present invention, the processing block is a general-purpose processing block configured by software, the processing element includes a general-purpose processing block configured by software in advance, and the processing element is software It is preferable to have a general-purpose processing block holding unit capable of unloading, duplicating, or erasing the general-purpose processing block configured as described above, and holding a general-purpose processing block that has been unloaded and / or copied.
In the distributed processing system according to the present invention, the general-purpose processing block holding unit preferably replicates the held dedicated processing block according to the parallelism.
In the distributed processing system according to the present invention, the general-purpose processing block holding unit preferably loads the held general-purpose processing block so that the program information can be loaded.
In the distributed processing system according to the present invention, it is preferable that the processing element has a load unit that directly loads program information included in a library connected according to a task to be executed into a general-purpose processing block from the outside.
In the distributed processing system according to the present invention, the processing element can unload, duplicate, or delete the program information included in the library loaded in the general-purpose processing block, and can further store the unloaded and / or duplicated program information. It is preferable to have a library holding part that can be held.
In the distributed processing system according to the present invention, it is preferable that the load unit loads the program information into the library holding unit, and the library holding unit holds the program information received from the outside via the load unit.
In the distributed processing system according to the present invention, it is preferable that the library holding unit replicates the held program information according to the degree of parallelism.
In the distributed processing system according to the present invention, it is preferable that the library holding unit loads the held program information into the general-purpose processing block.
In the distributed processing system according to the present invention, the processing block is a dynamic reconfigurable processing block, and the processing element receives the reconfiguration information contained in the library connected according to the task to be executed from the outside. It is preferable to have a load section that loads directly to the configurable / processing block.
In the distributed processing system according to the present invention, the processing element can unload, duplicate, or delete the reconfiguration information included in the library loaded in the dynamic reconfigurable processing block. It is preferable to have a library holding unit capable of holding the duplicated reconfiguration information.
In the distributed processing system according to the present invention, it is preferable that the load unit loads the reconfiguration information into the library holding unit, and the library holding unit holds the reconfiguration information received from the outside via the load unit.
In the distributed processing system according to the present invention, it is preferable that the library holding unit replicates the held reconfiguration information according to the degree of parallelism.
In the distributed processing system according to the present invention, it is preferable that the library holding unit loads the held reconfiguration information into the dynamic reconfigurable processing block.
In the distributed processing system according to the present invention, execution of the function realized by the reconfiguration information by connecting / disconnecting the path connecting the input of the dynamic reconfigurable processing block to the dividing unit and connecting the output to the integrating unit; It is preferable to control the degree of parallelism.
In the distributed processing system according to the present invention, it is preferable that the index for controlling the degree of parallelism includes any one or more of the degree of parallelism, priority, quality assurance type, power consumption, processing time, and output throughput.
In the distributed processing system according to the present invention, the client designates a priority for each of one or more tasks as an index for controlling the degree of parallelism, and the processing block relates to the execution of the task based on the designated priority. It is preferable to determine the degree of parallelism dynamically.
In the distributed processing system according to the present invention, the control unit presents an alternative indicator that deviates from the criterion when the candidate of the indicator that controls the degree of parallelism cannot be determined according to the criterion related to the execution of the application specified by the client. It is preferable.
In the distributed processing system according to the present invention, the control unit defines combinations of index candidates for controlling the degree of parallelism, and the client presents index candidates to the user via the user interface, and the control unit defines It is preferable to limit the input combinations on the user interface within the range of combinations of index candidates for controlling the degree of parallelism.
In the distributed processing system according to the present invention, it is preferable that the processing element can unload all the dedicated processing blocks, general-purpose processing blocks, program information, and reconfiguration information that have already been loaded.
In the distributed processing system according to the present invention, it is preferable that the reference regarding the execution of the application includes any one or more of quality assurance type, power consumption, processing time, and output throughput.
A distributed processing system according to the present invention is a system defined by a data flow type module network composed of calculation modules that provide one or more specific functions in order to realize a service requested by a user. As an index for virtually executing parallel execution, not only the degree of parallelism and overall performance but also power consumption and processing time are defined, and a distributed processing system that defines the optimum degree of parallelism from these indices can be provided.
Furthermore, according to the present invention, it is possible to provide a distributed processing system capable of dynamically increasing / decreasing the processing blocks inside the calculation module according to the dynamically defined parallelism.
In addition, the present invention can dynamically construct an application execution environment that is optimal for the user himself / herself by defining an index to be noticed when executing the application as a policy even if the user does not directly specify the degree of parallelism. .
It is a figure which shows schematic structure of the distributed processing system which concerns on embodiment of this invention. It is a flowchart which shows the flow of a process of the application which concerns on embodiment of this invention. FIG. 3 is a diagram showing a service task correspondence table in which the service shown in FIG. 2 is associated with the tasks constituting the service. It is a table | surface which respectively shows the example of the information which comprises the execution transition information which concerns on embodiment of this invention, and the data example of each structure information. It is a figure which shows the example of a model of the system corresponding to the structure of the execution transition information shown in FIG. It is a table | surface which shows the structural example of the service policy which concerns on embodiment of this invention. It is a table | surface which shows the structural example of the task policy which concerns on embodiment of this invention. 6 is a flowchart illustrating a flow of processing of an application according to the first embodiment. FIG. 6 is a diagram illustrating an execution sequence in the first embodiment. 6 is a diagram illustrating an example of PE registration information in Embodiment 1. FIG. 3 is a graph showing an example of a profile in Example 1. 7 is a table showing an example of PE registration information of PE1 in Example 1. 10 is a table illustrating an example of PE registration information of PE4 (VPE) in the first embodiment. 10 is a table showing an example of presenting task policy options according to the first embodiment. 6 is a table illustrating an example of a task policy after specifying a client in the first embodiment. FIG. 10 is a diagram illustrating an execution sequence in the second embodiment. 10 is a table showing an example of PE registration information of PE1 in Example 2. 10 is a table illustrating an example of PE registration information of PE4 in the second embodiment. 10 is a table showing an example of a service policy designated by a client in the second embodiment. 10 is a table illustrating an example of a task policy determined based on a service policy in the second embodiment. FIG. 10 is a diagram illustrating an execution sequence in the third embodiment. 12 is a table illustrating an example of a service policy registered by a client in the third embodiment. It is a figure which shows the execution sequence in case the CU presents an alternative in Example 4. FIG. FIG. 20 is a diagram illustrating an example of an alternative GUI window presented on the client in the fourth embodiment. FIG. 10 is a diagram illustrating an execution sequence when input is restricted on a client in the fifth embodiment. FIG. 10 is a diagram illustrating an example of input restriction in a GUI window on a client according to a fifth embodiment. 22 is a table showing an example of a task policy in which priority is specified in Example 6. It is a flowchart which shows the flow of the parallel degree adjustment at the time of execution between tasks in consideration of the priority to 2 tasks in Example 6. In Example 6, PE4 is a figure which shows the state which performs a task by the parallel degree 1. FIG. 10 is a diagram illustrating a configuration example of a PE having a processing block as a general purpose in the seventh embodiment. It is a figure which shows the initial state of PE in Example 7. FIG. FIG. 10 is a diagram illustrating an execution sequence in the seventh embodiment. 20 is a table showing an example of PE registration information of a PE having a general-purpose processing block in Example 7. In Example 7, it is a figure which shows the state which loaded the library into GP-PB. In Example 7, it is a figure which shows the state which copied the set of GP-PB and a library. FIG. 16 is a diagram showing a state before duplication in a series of diagrams showing a state in which GP-PB and a library are separately loaded and duplicated in Example 7. FIG. 16 is a diagram illustrating a state in which GP-PB is replicated among a series of diagrams illustrating a state in which GP-PB and a library are separately loaded and replicated in Example 7. FIG. 17 is a diagram showing a state in which a library is duplicated and loaded in a series of diagrams showing a state in which GP-PB and a library are loaded and duplicated separately in Example 7. It is a figure which shows the state before replication among a series of figures which show the state which loaded and replicated only the library in Example 7. FIG. It is a figure which shows the state which loaded the library among a series of figures which show the state which loaded and replicated only the library in Example 7. It is a figure which shows the state which copied the loaded library among the series of figures which show the state which loaded and replicated only the library in Example 7. FIG. 17 is a diagram illustrating a state in which a library and a processing block are deleted in a series of diagrams illustrating a state in which only a library is loaded and copied in Example 7. 20 is a table illustrating an example of PE registration information of a PE including a GP-PB and a library in the seventh embodiment. In Example 7, it is a figure which shows the state which unloaded GP-PB and was completely erased, or the state reloaded, and the structure of a holding | maintenance part. It is a figure which shows the state which made the exclusive processing block holding | maintenance part copy a processing block, load as another processing block, and can be processed among a series of figures which show the replication state of the exclusive processing block PB. It is a figure which shows the state which unprocessed and hold | maintained or reloaded all the processing blocks among the series of figures which show the replication state of the exclusive processing block PB, and was able to process. It is a figure which shows the state which the exclusive process block holding | maintenance part erase | eliminated all the process blocks among a series of figures which show the replication state of the exclusive process block PB. FIG. 20 is a diagram illustrating an example of dynamic switching to a hardware mounting block according to an eighth embodiment. FIG. 20 is a diagram illustrating a state example in which all switches are released in the eighth embodiment. It is a figure which shows the example of dynamic switching to a dynamic reconfigurable processing block among a series of figures which show the example of a structure which mounts the dynamic reconfigurable processor as a processing block in Example 8. FIG. Of the series of diagrams showing a configuration example in which a dynamic reconfigurable processor is mounted as a processing block in the eighth embodiment, the reconfiguration information obtained from the database server by the CU via the load unit is used as a dynamic reconfigurable processing block. It is a figure showing the state which loaded in the library holding | maintenance part, and the state copied and copied. FIG. 10 is a diagram in which a library holding unit duplicates and loads reconfiguration information in a series of diagrams illustrating a configuration example in which a dynamic reconfigurable processor is mounted as a processing block in the eighth embodiment. FIG. 20 is a diagram illustrating a library unloaded and reloaded state among a series of diagrams illustrating a configuration example in which a dynamic reconfigurable processor is mounted as a processing block in the eighth embodiment. FIG. 20 is a diagram illustrating a state where a library holding unit erases reconfiguration information in a series of diagrams illustrating a configuration example in which a dynamic reconfigurable processor is mounted as a processing block in the eighth embodiment. It is a flowchart which shows the flow of parallel degree determination in PE.
Embodiments of a distributed processing system according to the present invention will be described below in detail with reference to the drawings. In addition, this invention is not limited by the following embodiment.
In the following description, JPEG decoding processing is taken up as an application (service) executed by the distributed processing system according to the present embodiment, but the present invention is also applicable to processing other than JPEG decoding processing.
FIG. 1 is a diagram showing a schematic configuration of a distributed processing system according to an embodiment of the present invention.
The distributed processing system of this embodiment includes a VPE 30 (parallel processing virtualization PE) that is a computation module capable of parallel processing. The VPE 30 has one or both of a single input stream and a single output stream as an input / output interface for PEs (processing elements) 21, 22, and 23 as external devices. The client 10 requests the CU (control unit) 40 to execute an application.
The VPE 30 includes a control unit 31, a division unit 32, an integration unit 33, and one or more processing blocks (PB) 34, 35, 36, and 37 therein.
Although FIG. 1 shows an example in which there are four processing blocks, the number of processing blocks can be arbitrarily set as will be described later.
The control unit (processing block control unit) calculates the degree of parallelism based on a policy (an index for controlling the degree of parallelism) given from the CU. The control unit divides the input stream (processing data input to each processing block) by controlling the data stream dividing unit or integration unit according to the calculated parallelism, or outputs the stream (each processing block) Process data output from
Next, an application execution example will be described with reference to FIG. FIG. 2 is a flowchart showing the flow of processing of the application of this embodiment.
As shown in FIG. 2, the JPEG decoding process includes JPEG file analysis (step S101), entropy decoding (step S102), inverse quantization (step S103), IDCT (step S104), upsampling (step S105), and It is possible to divide into six consecutive processes of color signal conversion (step S106).
Here, an application requested by the user, such as JPEG decoding processing, is called a service, and sub-processing such as entropy decoding constituting the JPEG decoding processing is called a task. In other words, a task is one or more processing units constituting an application.
A service ID and a task ID are uniquely assigned to each service and task in order to identify each processing content. The service ID of the JPEG decoding process is SV-823, and the task ID of each task constituting the JPEG decoding process is TK-101 to TK-106.
When the client 10 requests execution of JPEG decoding processing as a service, the control unit 40 disassembles the task column from TK-101 to TK-106 in accordance with, for example, the service-task correspondence table shown in FIG. Here, FIG. 3 is a table in which the service shown in FIG. 2 is associated with the tasks constituting the service.
A task is assigned to each executable PE. PEs to which tasks are assigned include PE21, 22, 23, and VPE30.
The input / output of the route between the PEs is uniquely determined, and a path ID is determined as the route ID for the input / output pair. The control unit 40 generates information (execution transition information) regarding the configuration of this processing path. An example of the execution transition information is shown in FIG. FIG. 4 is a table showing an example of information constituting the execution transition information and a data example of each piece of configuration information.
For example, according to the execution transition information shown in FIG. 4, a processing path for performing JPEG decoding can be configured as shown in FIG. FIG. 5 is a diagram illustrating a model example of a system corresponding to the configuration of the execution transition information illustrated in FIG.
Thereafter, calculation resources necessary for processing are allocated and a processing path is established.
The execution transition information of this embodiment includes a task policy. The policy is a restriction at the time of execution related to the task processing of the PE including the entire service execution and the parallel processing virtualization PE (VPE). The policy includes a service policy (reference for application execution) that restricts the entire service execution, and a task policy (an index that controls the degree of parallelism) that restricts task processing in each PE. For example, it is also possible to directly specify the multiplicity (parallelism) of parallel processing for each task using a task policy. In addition, the processing time of the entire service is specified as a performance index using the service policy, and the CU optimizes the processing path in order to perform processing within the processing time, and automatically sets the parallelism of task execution in each PE. It is also possible to automatically generate a task policy. In either case, a task policy that defines task execution in each PE is finally determined and notified to each PE.
Here, examples of parameters that can be used in the service policy and the task policy will be described. Table 1 is a table for explaining parameters constituting the policy. FIG. 6 is a table showing a configuration example of a service policy according to the present embodiment. FIG. 7 is a table showing a configuration example of the task policy according to the present embodiment. In Table 1, parameters that can be specified in each policy are indicated by circles.
Examples of service policies include quality assurance type, power consumption upper and lower limits, processing time upper and lower limits, and output throughput upper and lower limits, as shown in FIG. As examples of task policies, as shown in FIG. 7, quality assurance type, upper and lower limits of power consumption, upper and lower limits of processing time, upper and lower limits of output throughput, upper and lower limits of parallelism, priority Degrees.
The service policy is registered in the CU together with an ID for identifying the client before the client requests execution of the service. At this time, if the service to which the service policy is to be applied is specified, it is registered with the CU in combination with the service ID. Otherwise, the registered service policy is applied to all services requested from this client, and execution transition information including a task policy is generated.
The task policy is generated when the execution transition information is generated regardless of whether the service policy is registered. It is possible to provide options for each parameter of the task policy and allow the client to select the task policy, or it is possible to use the task policy that the CU determines to be optimal without the approval of the client.
Hereinafter, examples of the distributed processing system according to the above-described embodiment will be described. In the following description, the configuration, operation, and effect that are characteristic will be mainly described, and the configuration, operation, and effect described above may be omitted. The number of PEs arranged before and after the VPE may differ from the example shown in FIG. 1 depending on the contents of each example.
Each embodiment is premised on the implementation by software in principle, but the PE can be implemented by hardware, and the outline will be described later.
The first embodiment relates to processing when a client specifies a task policy. FIG. 8 is a flowchart illustrating the flow of processing of the application according to the first embodiment, and each step corresponds to each step in FIG. 2 as follows. Here, for the task policy generated by the CU, the client designates the degree of parallelism for each PE, and designates the degree of parallelism of IDCT (task ID = TK-104) as 2.
First, the JPEG file analysis (step S101) in FIG. 2 corresponds to the processing (step S201) in the PE (PE1) having a parallel degree of 1, and the entropy complexing (step S102) is performed in the PE (PE2) having a parallel degree of 1. Corresponding to the processing (step S202), the inverse quantization (step S103) corresponds to the processing (step S203) in the PE (PE3) having a parallel degree of 1.
Next, the IDCT (step S104) inputs and divides processing data to the VPE (PE4) with parallel degree 2 (step S204), processes in the two processing blocks (PB) in the VPE (steps S205 and S206), Also, it corresponds to the integration and output (step S207) of the processing data in the two processing blocks.
Further, the upsampling (step S105) corresponds to the processing (step S208) in the PE (PE5) having a parallel degree of 1, and the color signal conversion (step S106) is performed in the PE (PE6) having a parallelism of 1 (step S208). Corresponding to S209), it is possible to divide into the continuous processing of steps S201 to S209 as in steps S101 to S106 of FIG.
Subsequently, a sequence according to the first embodiment will be described. FIG. 9 is a diagram illustrating an execution sequence in the first embodiment.
First, in sequence 300, when PE1 is activated, PE registration information shown in FIG. 10 is transmitted to the control unit. FIG. 10 is a diagram illustrating an example of PE registration information according to the first embodiment. Table 2 is a table for explaining each data field of the PE registration information shown in FIG. FIG. 11 is a graph showing an example of the profile shown in FIG. FIG. 12 is a table showing an example of PE registration information of PE1 shown in FIG. In FIG. 11, a solid line A indicates a change in the upper limit value of the parallelism with respect to the power consumption, and a broken line B indicates a change in the lower limit value of the parallelism with respect to the power consumption.
Here, PE1 can provide a function (JPEG file analysis) having an FID of FN-101 with a maximum parallelism of 1, that is, cannot be parallelized.
Next, in the sequence 301, when the VPE as the PE4 is activated, the PE registration information shown in FIG. 13 is transmitted to the control unit in the same manner as the PE1. FIG. 13 is a table illustrating an example of PE registration information of the PE 4 in the first embodiment.
PE4 (VPE) can provide a function (IDCT) having an FID of FN-104 with a maximum parallelism of 2. Although not shown, other PEs also transmit PE registration information at the time of activation and perform registration.
In the sequence 302, the client requests the CU to specify the service ID = SV-823 to execute JPEG decoding as a service execution request.
In sequence 303, the CU generates execution transition information based on the registration information of each PE. The registration information of each PE that dynamically changes may be monitored sequentially, and the execution transition information may be generated by reflecting the result.
As a result, assuming that execution transition information including the same route information as shown in FIG. 4 has been generated, a value candidate is determined based on the PE registration state for each value of the task policy. As this candidate, the upper limit value and the lower limit value of the degree of parallelism shown in FIG. 14 are shown. FIG. 14 is a table illustrating a presentation example of task policy options according to the first embodiment. Here, it is assumed that value candidates have been determined for other parameters such as power consumption.
In sequence 304, the CU transmits execution transition information including the task policy to the client. In sequence 305, the client selects an arbitrary value (task policy) for the range indicated. The only policies that can be selected at this time are the upper and lower limits of parallelism. It is assumed that other policies are specific to the PE that cannot be specified by the client. When this combination of values is inappropriate or impossible, it is checked on the GUI (Example 5), or checked by the CU and an error is returned.
Here, in the sequence 305, it is assumed that the client determines each parameter from the selection candidates as shown in FIG. That is, the upper limit and the lower limit of the parallelism are the same value, the parallelism of PE1 is 1, and the parallelism of PE4 is 2. Here, FIG. 15 is a table showing an example of a task policy after client designation in the first embodiment.
In sequence 306, the client transmits execution transition information including the selected task policy to the CU.
Subsequently, the CU sends execution transition information including the task policy to each PE constituting the execution transition information, and requests to secure a computing resource. In sequence 307, execution transition information is transmitted to PE1 to request to secure computing resources.
The CU checks the parameter values and combinations before transmission to each PE, and returns an error if the values or combinations are inappropriate or impossible, and ends the service processing.
In the sequence 308, when the PE 1 receives the execution transition information, the PE 1 confirms the assigned task and secures calculation resources such as a memory necessary for executing the task. Further, the policy is applied, and the internal configuration of the PE 1 is changed as necessary. In Example 1, PE1 confirms that the upper limit and the lower limit of the parallelism are both 1, and determines the parallelism to 1. If there is no processing block in PE1, a new process or thread is generated or program information is loaded. In the case of hardware implementation, dynamic reconfiguration such as switching is executed as necessary.
In sequence 309, when PE1 secures the computational resource and applies the policy, it notifies the CU that the computational resource has been secured.
In sequence 310, similarly to PE1, PE4 also receives a calculation resource securing request from the CU.
In the sequence 311, the PE 4 confirms that both the upper limit and the lower limit of the parallel degree are 2, and determines the parallel degree to 2. If there are no two processing blocks in PE4, a process or thread is newly generated or program information is loaded. If there are unnecessary processing blocks, they may be deleted. In the case of hardware implementation, dynamic reconfiguration is performed such as switching the route to the processing block as necessary.
In the sequence 312, when the PE 4 secures the computing resource and applies the policy, the PE notifies the CU that the securing of the computing resource is completed.
The computing resources are secured in the same manner for PEs other than PE1 and PE4.
When the CU confirms that the computation resources have been secured for all PEs included in the execution transition information, the CU requests each PE to establish a processing path between the PEs (sequence 313). Each PE establishes a processing path with an adjacent PE on the processing path. Thereafter, the client is requested to connect to the PE, and the client is notified that service processing can be started.
In sequence 314, data is transmitted from the client when the processing path with the PE is established. Each PE performs data flow processing along the established processing path. That is, data is transmitted from the client to PE1, and after PE1 performs data processing, the data is transmitted to PE2. Further, PE2 takes over the processing result to PE3 and PE4, and outputs the result at PE6.
In sequence 315, PE1 receives data from the client, reads the JPEG file, performs header analysis, and the like. PE1 transmits the read image information to PE2.
In sequence 316, after entropy decoding is performed in PE2, inverse quantization is performed in PE3 that has received data from PE2, and PE4 receives data from PE3.
In sequence 317, PE4 performs IDCT processing in parallel. For example, assuming that processing is performed in units of MCUs and consecutively unique numbers are assigned according to image coordinate positions, even-numbered MCUs and odd-numbered MCUs are processed in parallel by separate processing blocks in the division unit. Before being sent to the next PE5, the integration unit performs synchronization processing and integrates again.
In sequence 318, after upsampling is executed in PE5, color signal conversion is performed in PE6, the result is returned from PE6 to the client, and the service processing is terminated.
In sequence 319, the processing path and computing resources are released, and the completion process is executed.
In sequence 320, the CU sends a service execution completion to the client, and the service execution is completed.
Unless otherwise specified in the second to seventh embodiments, the calculation resource securing described in the sequence 307 to the sequence 309 and the sequence 310 to the sequence 312 is appropriately performed for all PEs necessary for service execution. The process from establishment of the processing path of the sequence 313 to completion of service execution of the sequence 320 is common to all the embodiments, and a detailed description may be omitted as an expression such as "continue service processing".
(Example 2)
The second embodiment relates to processing when a client designates a service policy in a best effort manner.
FIG. 16 is a diagram illustrating an execution sequence according to the second embodiment.
In the sequence 400, when the PE1 is activated, the PE registration information shown in FIG. 17 is transmitted to the CU to notify that the task can be executed with the parallel degree 2. Here, FIG. 17 is a table showing an example of PE registration information of PE1 in the second embodiment.
In sequence 401, as in PE1, PE4 (VPE) transmits PE registration information (FIG. 18) to the CU, notifying that the task can be executed with a degree of parallelism of 4. When a PE other than PE1 and PE4 is also activated, registration information is transmitted to the CU and its own information is registered. Here, FIG. 18 is a table showing an example of PE registration information of the PE 4 in the second embodiment.
In sequence 402, the client registers in advance a policy to be applied to the service, together with its own client ID, with the CU. This policy may be applied to all services, or may be applied only to specific services by specifying a service ID.
In the second embodiment, the service policy shown in FIG. 19 is applied to the entire system for all services requested from the client specified by the client ID 123456 without specifying the service ID. Here, FIG. 19 is a table showing an example of a service policy designated by the client in the second embodiment.
In a sequence 403, the client requests the CU to specify the service ID = SV-823 to execute JPEG decoding as a service execution request.
In sequence 404, when the CU receives the service execution request, the CU determines whether the service policy can be applied and the task policy can be determined. In the second embodiment, since the quality assurance type in the service policy is the best effort type, the task policy can be automatically determined and the task can be executed even if conditions such as the power consumption amount are not satisfied.
In sequence 405, the CU determines a task policy based on the registration information of the PE, and generates execution transition information. Information that dynamically changes among PE registration information may be sequentially monitored, and execution transition information may be generated by reflecting the result. As a result, the CU generates execution transition information similar to that shown in FIG. Here, the parameters of the policy information for each PE are determined as shown in FIG. 20 so as to satisfy the policy designated by the client. FIG. 20 is a table illustrating an example of a task policy determined based on a service policy in the second embodiment.
In a sequence 406, the CU transmits execution transition information including the generated task policy to each PE constituting the execution transition information, and requests to secure computing resources.
In the sequence 407, when each PE receives the execution transition information, the PE confirms the assigned task and secures a calculation resource such as a memory necessary for executing the task. Furthermore, the task policy is applied, and the configuration inside the PE is changed as necessary.
In the second embodiment, if there are not the same number of processing blocks as the degree of parallelism, a new process or thread is generated, or program information is loaded. In the case of hardware implementation, dynamic reconfiguration such as switching is executed as necessary. For task 4 shown in FIG. 20, since the upper limit value and the lower limit value of the parallelism are different, the parallelism is dynamically determined inside the VPE so as to satisfy other parameter values such as power consumption, and data processing is controlled. To do. In addition, the parallel degree in PE is determined by the flow demonstrated in the following example, for example.
In sequence 408, the CU receives the completion of securing the computing resource from each PE, establishes a processing path, and continues processing the service.
The third embodiment relates to a process when the service policy specified by the client cannot be applied when the client specifies a guarantee type service policy.
FIG. 21 is a diagram illustrating an execution sequence according to the third embodiment. FIG. 22 is a table illustrating an example of a service policy registered by a client in the third embodiment.
In sequence 500, the client registers the service policy shown in FIG. 22 in the system. It is assumed that the PE registration is completed before the sequence 500.
In sequence 501, the client specifies the ID of the requested service and requests the CU to execute the service.
In sequence 502, the CU determines whether or not to apply a service policy registered in advance by the client. In the third embodiment, it is determined that application of this service policy is impossible.
In sequence 503, the CU returns an error to the client and ends the service processing.
In the third embodiment, since the quality assurance type is set to the guarantee type, if the quality cannot be guaranteed, the execution is stopped and an error is returned because it is contrary to the client's intention.
The following fourth and fifth embodiments relate to the actions taken by the distributed processing system when it is determined that the service policy cannot be applied in the sequence 502 of FIG. In addition to returning an error when the service policy cannot be applied, the system can take the following actions:
(1) Presentation of alternative service policy (Example 4)
(2) Task policy input restriction or input check on client GUI (Example 5)
Hereinafter, Example 4 and Example 5 will be described in order.
The fourth embodiment relates to the presentation of an alternative service policy among the responses of the distributed processing system when it is determined that the service policy cannot be applied.
FIG. 23 is a diagram illustrating an execution sequence when the CU presents an alternative in the fourth embodiment.
First, in sequence 600, it is assumed that registration of PE is completed. The client registers a service policy similar to the sequence 500 in FIG. 21 in the system.
In sequence 602, the CU determines whether the service policy registered in advance by the client is appropriate. In the fourth embodiment, the CU determines that the service policy cannot be applied.
In sequence 603, the CU generates an alternative service policy. The CU presents the generated service policy to the client (sequence 604). FIG. 24 shows an alternative presentation image on the GUI to the client. FIG. 24 is a diagram illustrating an example of an alternative GUI (Graphical User Interface) window presented on the client in the fourth embodiment.
In the GUI example shown in FIG. 24, each parameter of the service policy can be edited for the service indicated by the service ID SV-823. In the fourth embodiment, in order to guarantee the power consumption upper limit and the output throughput upper limit of the entire system, 10 seconds is shown as an alternative to the processing time upper limit instead of 1 second specified to reduce the upper limit of the processing time.
In sequence 605, the client selects whether or not an alternative is possible in the first column on the GUI window. In Example 4, the client accepts the use of the alternative.
In sequence 606, the client transmits the selection result to the CU, and the client determines the selection result (sequence 607).
When the CU accepts the selection result in the sequence 607, the CU determines the task policy and generates execution transition information (sequence 608). Subsequently, in sequence 609, the CU transmits execution transition information to each PE together with a calculation resource securing request.
On the other hand, if the CU does not accept the selection result in sequence 607, the CU returns an error to the client and ends the execution of the service.
The fifth embodiment relates to the task policy input restriction or input check on the client GUI among the correspondences of the distributed processing system when it is determined that the service policy cannot be applied.
FIG. 25 is a diagram illustrating an execution sequence when input restriction is performed on the client in the fifth embodiment.
In sequence 700, it is assumed that registration of the PE is completed. The client designates the ID of the requested service and requests the CU to execute the service.
In sequence 701, the CU generates execution transition information including candidate task policies.
In sequence 702, the CU transmits execution transition information including parameter options of the task policy to the client. A possible combination of task policy parameters is sent along with the execution transition information.
In the sequence 703, when the client selects a task policy, the client can set the value of the task policy within the range of possible values shown on the GUI shown in FIG. In this case, if the GUI determines from possible combinations of parameters generated in the sequence 702 and sets a value that exceeds the range of possible values, an error is returned on the GUI and input is restricted. Also, the previously set value is checked in real time, and the possible value changes. By restricting or checking the input of policy setting values on the GUI, the step of checking the policy by the CU can be omitted. Here, FIG. 26 is a diagram illustrating an example of input restriction in the GUI window on the client in the fifth embodiment.
In sequence 704, when the task policy is confirmed, the client notifies the CU of the task policy.
In sequence 705, the CU configures execution transition information using the determined task policy, and starts to secure a computing resource necessary for service execution.
The sixth embodiment relates to a process for specifying a priority for each task as a policy.
Since priority cannot be applied to a service, the client specifies the priority for each task after execution transition information is generated by the CU after a service execution request from the client, or a specific PE is specified and prioritized. Pre-register the degree. When the maximum parallelism of PE1 and PE4 is registered as 2 and 4 respectively (the same as in the second embodiment), JPEG encoding is requested as a service. Assume that the client specifies the priority for the execution transition information generated by the CU as shown in FIG. FIG. 27 is a table illustrating an example of a task policy in which priority is specified in the sixth embodiment.
Here, the parallelism at the time of independent execution of each task applied when there is no task executed simultaneously with the priority is defined as follows, for example.
(1) High priority: Execute with maximum parallelism.
(2) Priority Medium: Execute at the upper limit of parallelism. However, if it is not specified, it is executed with the maximum parallelism.
(3) Low priority: Execute at the lower limit of parallelism. However, if it is not specified, it is executed with a parallelism of 1.
FIG. 28 is a flowchart illustrating the flow of adjusting the degree of parallelism during execution between tasks in consideration of priorities up to two tasks in the sixth embodiment.
FIG. 28 shows an example of adjusting the run-time parallelism when executing up to two tasks in parallel on a certain PE at the same time. Here, the self task (the task to be adjusted) is A, and the task that has been executed first on the PE is task B. Although the case where the degree of parallelism of three or more tasks is adjusted is not described here, it is the same as the adjustment of the degree of parallelism between two tasks in that the degree of parallelism during comparison and execution is adjusted.
In step S800, it is determined whether a task that is being executed prior to its own task A exists in the same PE. If it does not exist in the same PE (N in step S800), the process proceeds to step S808, where the task is executed with the parallelism at the time of the single execution, and the execution of the task is terminated.
On the other hand, if a task that is executed prior to its own task A exists in the same PE (Y in step S800), the process proceeds to step S801, and the parallelism at the time of execution of task A and the parallelism at the time of execution of task B Determine whether the sum of degrees exceeds the maximum parallelism of PE. If the sum does not exceed the maximum degree of parallelism (N in step S801), the process proceeds to step S809, and task A and task B are simultaneously executed and terminated.
On the other hand, if the sum exceeds the maximum parallelism (Y in step S801), the process further proceeds to step S802, where the priority of the task A is lower than the priority of the task B that is executed first. Determine whether or not. If the priority of the own task A is lower (Y in step S802), the process proceeds to step S803, where L is task A and H is task B.
If the priority of the task A is equal to or higher than the priority of the task B (N in step S802), the process proceeds to step S810, where L is the task B and H is the task A.
In either case of steps S803 and 810, after the processing, the process proceeds to step S804, where the parallelism at the time of execution of the task represented by L is larger than the parallelism at the time of execution of the task represented by the maximum parallelism of PE. Judge whether or not.
If the maximum parallelism of the PE is greater than the execution parallelism of the task represented by H (Y in step S804), the execution parallelism of the task represented by L is set to the maximum parallelism of the PE and H in step S811. In step S812, task A and task B are executed simultaneously, and the process ends.
If N in step S804, the process proceeds to step S805. In step S805, the task represented by L is pending, and in step S806, it is determined whether execution of the task represented by H has been completed.
If execution of the task represented by H has not been completed (N in step S806), the process returns to step S805 to continue the pending. When the execution of the task represented by H is completed (Y in step S806), the execution of the task represented by L is resumed with the parallelism at the time of single execution, and the execution is terminated.
The task with the task ID "TK-104" is assigned to PE4 (VPE) with the priority "low". Since there is no designation of the parallelism lower limit, even if there are no other tasks being executed, the parallelism is executed with a parallelism of 1 (solid line in FIG. 29). Here, FIG. 29 is a diagram illustrating a state in which the PE 4 executes the task with the parallel degree 1 in the sixth embodiment.
Example 7 relates to the case where the processing block is self-replicated, and includes a case where the processing block is general-purpose. In the seventh embodiment, an example in which processing blocks having different functions in the same PE do not exist at the same time will be described. In addition, regardless of whether it is dedicated or general purpose, the processing block is not loaded from the outside, and only the library information including program information and reconfiguration information can be loaded from the outside.
In the first to sixth embodiments, regardless of whether the implementation is software or hardware, all processing blocks are dedicated processing blocks that provide application-specific functions. A general-purpose processing block that can provide a function equivalent to a specialized normal processing block can be incorporated into the PE. This general-purpose processing block is called GP-PB. In the following description, loading a library means loading program information of the library.
FIG. 30 is a diagram illustrating a configuration example of a PE in which processing blocks are general-purpose in the seventh embodiment. FIG. 30 shows that if a library 300 that provides a function equivalent to the function provided by the dedicated processing block is downloaded to the GP-PB 301 and used, the dedicated processing block can be used equally. The control unit 303 includes a library holding unit 304, a general-purpose processing block holding unit 305, and a loading unit 306. The load unit 306 loads a library including software information and reconfiguration information from the outside into the general-purpose processing block. The library holding unit 304 unloads or duplicates the library from the general-purpose processing block, and holds those libraries or the library loaded from the load unit. The stored library is duplicated, loaded to the general-purpose processing block, and unnecessary libraries on the general-purpose processing block are deleted. The general-purpose processing block holding unit 305 unloads or duplicates processing blocks implemented by software, and holds those processing blocks. The stored general-purpose processing block is copied, the program information to the general-purpose processing block is loaded so that it can be loaded, and unnecessary general-purpose processing blocks are deleted. The GP-PB itself can be implemented by software or hardware, but the description will be continued assuming that it is software.
In the following description, examples are shown for three cases.
(1) When replicating GP-PB and library as a set (2) When replicating GP-PB and library separately (3) When replicating only library
(1) When replicating GP-PB and library as a set (FIGS. 31 to 35)
In this case, there is no PE having a dedicated processing block for providing the JPEG encoding process as a service in the initial state. For this reason, the library is dynamically downloaded to the PE (VPE) having GP-PB. The initial state of the PE having GP-PB has the configuration shown in FIG. Here, FIG. 31 is a diagram illustrating an initial state of PE (VPE) in the seventh embodiment.
FIG. 32 is a diagram illustrating an execution sequence according to the seventh embodiment.
In the sequence 900, the PE having GP-PB registers the function ID (FID) with the CU as FN-999. For example, the registration information is as shown in FIG. Here, the maximum parallelism is 4. FIG. 33 is a table illustrating an example of PE registration information of a PE having a general-purpose processing block according to the seventh embodiment.
In sequence 902, the CU generates execution transition information including task policy candidates based on the registration information of the PE. The PE with GP-PB is expected to be assigned a task of TK-104. That is, by downloading the library to the GP-PB, it is expected that a function equivalent to that of the dedicated processing block having the function of the TK-104 is expected, and a PE having the GP-PB is assigned to the execution transition information. The execution transition information generated here is the same as that shown in FIG. 4, and the task policy generates the same candidates as in FIG. Even when a PE having a general-purpose processing block is used, the execution transition information is the same if the path information and the task policy constituting the service to be realized are the same.
In sequence 903, the CU notifies the client of execution transition information including a task policy candidate.
In the sequence 904, the client selects only the parallel degree, and designates the parallel degree of the task 4 corresponding to the task ID: TK-104 as 2 as in FIG.
In sequence 905, the client notifies the CU of execution transition information including the selected task policy.
In sequence 906, the CU first checks execution transition information including a task policy. The CU knows the function of the library loaded in the PE having GP-PB and its operating state. The CU determines whether the library is necessary from the execution transition information including the task policy.
In the seventh embodiment, since the library that provides the FN-104 function necessary for executing the task of TK-104 is not downloaded to the PE having GP-PB, the library that provides the FN-104 function is dynamically used. It is necessary to deliver to.
In sequence 907, the CU obtains program information as a GP-PB library that provides the functions of the FN-104 from, for example, a database server, and downloads it via the PE load unit (FIG. 34). FIG. 34 is a diagram illustrating a state in which a library is loaded on the GP-PB in the seventh embodiment.
In the sequence 908, the PE receives a calculation resource securing request from the CU. In the sequence 909, the PE confirms the task to be executed and determines the parallelism at the time of execution.
At this stage, since there is only one processing block for the parallel degree 2, the GP-PB and the library are duplicated as a set and reconfigured so that parallel processing is possible with the parallel degree 2 (FIG. 35). ). FIG. 35 is a diagram illustrating a state in which a GP-PB and library set is duplicated in the seventh embodiment. More specifically, the main control unit copies the GP-PB to the general-purpose processing block holding unit while leaving the GP-PB entity, and similarly copies the GP-PB to the library holding unit while leaving the library entity. Further, each holding unit duplicates the GP-PB and the library, respectively. Thereafter, the GP-PB and library set copied so as to be connected to the dividing unit and the connecting unit are reloaded.
In sequence 910, when the task is ready to be executed, it is considered that the securing of the computing resource is completed, and the completion is returned to the CU.
In the sequence 911, service processing is continued.
(2) When copying the GP-PB and the library separately (FIGS. 36 to 38)
36 to 38 are a series of diagrams showing a state in which the GP-PB and the library are separately loaded and replicated in the PE (VPE) in the seventh embodiment, and FIG. 36 is a diagram illustrating a state before the replication. 37 is a diagram showing a state where the GP-PB is duplicated, and FIG. 38 is a diagram showing a state where the library is duplicated and loaded.
In this case, in an initial state, a library that provides the FN-500 function to the GP-PB is already loaded (FIG. 36). When you want to execute TK-104 task on GP-PB at parallel degree 2, PE deletes the library that provides FN-500 function and then copies (duplicates) GP-PB in general-purpose processing block holding unit Then, GP-PB is loaded so that the library can be loaded (FIG. 37). After that, the library that provides the function of FN-104 acquired by the CU from the database server is loaded into the library holding unit via the loading unit and then copied, and the library holding unit loads each of the two GP-PBs (FIG. 38). ) To realize parallel processing. Even if the FN-500 function is being provided, it is possible to duplicate only the GP-PB in advance.
(3) When copying only the library (FIGS. 39 to 42)
FIGS. 39 to 42 are a series of diagrams showing a state in which only the library is loaded and copied in the PE (VPE) in the seventh embodiment, FIG. 39 is a diagram showing a state before duplication, and FIG. 40 is a diagram showing loading the library. FIG. 41 is a diagram showing a state in which a loaded library is duplicated, and FIG. 42 is a diagram showing a state in which the library and processing blocks are erased.
In this case, it is a case where it is desired to execute the task of TK-104 with a parallel degree of 2 on the PE (VPE) having GP-PB. When the PE already has two GP-PBs (FIG. 39), FIG. 32, the library distributed from the CU in S907 is held in the library holding unit, the library held in the library holding unit is copied (FIG. 40), and the library (FN-104) is loaded to each GP-PB ( FIG. 41). For example, when deleting the library and GP-PB in order to reduce the parallelism to 1 because the priority of this task is low, the library holding unit and the general-purpose processing block holding unit delete the library and GP-PB, respectively (FIG. 42). .
As shown in FIG. 41, when the PE is already provided as a set of the library and GP-PB, two function IDs of GP-PB and library are registered in the CU (FIG. 43). Here, FIG. 43 is a table illustrating an example of PE registration information of the PE including the GP-PB and the library in the seventh embodiment.
As described in (1) and (2), all GP-PBs can be copied as necessary. Further, as described in (1), GP-PB can be replicated as a set with a library, and GP-PB and the library can be replicated individually ((2), (3). )). It is also possible to delete a library and load a library having a different function from the outside. In either case, the parallelism can be dynamically manipulated freely by copying and deleting the processing block.
The GP-PB and the library can be unloaded to the holding unit. It is safe to unload all GP-PBs and libraries. Further, either the GP-PB or the library or a combination thereof can be held in the holding unit in the control unit (FIG. 44). As for what is held in the holding unit, one or more GP-PBs and libraries can be reloaded at an arbitrary timing. A library can be loaded with multiple types from the outside and stored, but a PE can provide only one type of function at a time. Here, FIG. 44 is a diagram illustrating a state in which the GP-PB is unloaded and completely erased or reloaded and a configuration of the holding unit in the seventh embodiment.
In the seventh embodiment, a processing block that provides a specific function in the combination of GP-PB and library has been shown. However, since the combination of GP-PB and library is functionally equivalent to the dedicated processing block PB, the above embodiment can also be applied to dedicated processing blocks implemented in software. That is, a dedicated processing block that provides a specific function can be duplicated, unloaded, or deleted (FIGS. 45 to 47). The entire dedicated processing block can be held in the holding unit. Here, FIG. 45 to FIG. 47 are a series of diagrams showing the copy and unload states of the dedicated processing block PB. FIG. 45 shows the processing block copied by the dedicated processing block holding unit and loaded as another processing block. 46 is a diagram showing a state where processing is possible, FIG. 46 is a diagram showing a state where all processing blocks are unloaded and held or reloaded and processing is possible, and FIG. 47 is a diagram where the dedicated processing block holding unit has all processing blocks It is a figure which shows the state which deleted.
Example 8 relates to mounting of PE by hardware.
In the first to seventh embodiments, PE is implemented by software, and the processing blocks can be increased or decreased freely up to the maximum parallelism. Although the maximum degree of parallelism depends on the memory capacity, if the block is not large with respect to the memory capacity, the maximum parallelism may be considered as unlimited.
On the other hand, the PE can be implemented as hardware. However, in the case of hardware, since a block previously created as a circuit is used, the maximum parallelism is defined for the number of blocks created. The processing block may be always connected to the division unit or the integration unit, but it is preferable to configure the route dynamically by configuring a switch to each processing block as shown in FIG. FIG. 48 is a diagram illustrating an example of dynamic switching to a hardware mounting block according to the eighth embodiment.
In addition, as shown in FIG. 49, when not in use, the processing block can be dynamically increased or decreased within the range of 0 to the maximum parallelism, and the power consumption is suppressed by releasing all the switches. Is also possible. FIG. 49 is a diagram illustrating a state example in which all switches are released in the eighth embodiment.
Furthermore, as shown in FIGS. 50 to 54, if a dynamic reconfigurable processor (DRP) is used as a processing block, it can be regarded as a general-purpose processing block (GP-PB) implemented in hardware. . However, as a hardware mounting block, input / output connection is disconnected by dynamic switching. DRP cannot be replicated. It is assumed that the reconfiguration information is copied as a library and loaded or unloaded to the DRP, and all the reconfiguration information loaded to each DRP is the same. The reconfiguration information held in the library holding unit can be loaded from the outside as a library, and a plurality of pieces of reconfiguration information may be held. By dynamically loading the library, a processing block that can reconfigure the internal configuration can be constructed. In this case, the library is reconfiguration information such as wiring information or switching information for the dynamic reconfigurable processor. Here, FIG. 50 to FIG. 54 are a series of diagrams showing a configuration example in which a dynamic reconfigurable processor is mounted as a processing block in the eighth embodiment, and FIG. 50 is a diagram showing the configuration of the dynamic reconfigurable processing block. FIG. 51 is a diagram showing an example of dynamic switching. FIG. 51 shows a state in which the reconfiguration information acquired by the CU from the database server is loaded into the dynamic reconfigurable processing block via the load unit or loaded into the library holding unit and copied. FIG. 52 shows a state where the library holding unit duplicates and loads the reconfiguration information, FIG. 53 shows a state where the library is unloaded and reloaded, and FIG. 54 shows a state where the library holding unit re-loads. It is a figure showing the state which erase | eliminated structure information. Both can exhibit the same functions as general-purpose processing blocks implemented in software.
Here, with reference to FIG. 55, the flow of determining the degree of parallelism in the PE will be described. FIG. 55 is a flowchart showing the flow of determining the degree of parallelism in the PE. When each parameter of the task policy is given, the PE determines the parallelism at the time of execution according to the flow of FIG. The flow of parallelism determination described here can be applied to the first, second, fourth to eighth embodiments.
First, in step S1000, the presence / absence of setting (designation) of the upper limit of the parallelism of the service policy is checked. If the upper limit is set (Y in step S1000), the process proceeds to step S1020. If the upper limit is not set (N in step S1000), the process proceeds to step S1010. In step S1010, the upper limit of parallelism is set as the maximum parallelism of PE, and the process proceeds to step S1020.
In step S1020, the presence / absence of setting (designation) of the lower limit of the service policy parallelism is checked. If the lower limit is set (Y in step S1020), the process proceeds to step S1040. If the lower limit is not set (N in step S1020), the process proceeds to step S1030. In step S1030, the lower limit of parallelism is set to 1, and the process proceeds to step S1040.
In step S1040, it is determined whether the upper limit of the degree of parallelism is greater than the lower limit. If the upper limit is larger (Y in step S1040), the process proceeds to step S1060. If the upper limit is equal to or lower than the lower limit (N in step S1040), the process proceeds to step S1050.
In step S1050, it is determined whether the upper limit of the degree of parallelism is equal to the lower limit. If the upper limit of the degree of parallelism is equal to the lower limit (Y in step S1050), it is not necessary to select the degree of parallelism, and the process advances to step S1070. If the upper limit and the lower limit of the degree of parallelism are not equal (N in step S1050), the process proceeds to step S1150, and an error notification is sent to the CU.
In step S1060, it is checked whether task policy parameters other than parallelism and priority, such as power consumption, processing time, and output throughput, are set, and if any one is set (Y in step S1060). The process proceeds to step S1080. If no parameter is set (N in step S1060), the process proceeds to step S1070.
In step S1070, the upper limit value of the degree of parallelism is set as the degree of parallelism, and the process proceeds to step S1130.
In step S1080, the upper limit and the lower limit of the corresponding parallelism are calculated from the power consumption profile, the range A of parallelism is determined, and the process proceeds to step S1090.
In step S1090, as in step S1080, the upper limit and lower limit of the corresponding parallelism are calculated from the processing time profile, the range B of parallelism is determined, and the process proceeds to step S1100.
In step S1100, as in steps S1080 and 1090, the upper limit and lower limit of the corresponding parallelism are calculated from the output throughput profile, the range C of parallelism is determined, and the process proceeds to step S1110.
In step S1110, it is determined whether or not the common range D can be extracted from the parallelism ranges A, B, and C. If the common range D can be extracted (Y in step S1110), the process proceeds to step S1120. If the common range D cannot be extracted (N in step S1110), the process proceeds to step S1150. For example, when the parallelism range A is 1, 2, 3, the range B is 2, 3, and the range C is 2, 3, 4, the common range D is 2, 3.
In step S1120, a common range is further extracted from the range indicated by the upper limit and the lower limit of the parallelism and the common range D, determined as the parallelism using the maximum parallelism, and the process proceeds to step S1130. For example, if the common range D is 2 and 3, the upper limit value of parallelism is 4, and the lower limit value is 2, the parallel degree to be used is 3.
In step S1130, it is checked whether a priority is specified. If specified (Y in step S1130), the process proceeds to step S1140. If not specified (N in step S1130), the process ends.
In step S1140, for example, according to the flow of FIG.
In step S1150, since there is no degree of parallelism that can be determined, an error is returned to the CU, and the process ends.
Although not shown, for example, if the task policy defines the output throughput lower limit and the power consumption upper limit, and the quality assurance type is the best effort type, the value specified in the task policy cannot be guaranteed. The controller dynamically adjusts the degree of parallelism so that the trade-off between throughput and power consumption is optimal. If the quality assurance type is a guarantee type, the degree of parallelism is adjusted so as to guarantee the value specified in the task policy.
As described above, the distributed processing system according to the present invention is useful for a distributed processing system that is expected to define an optimum degree of parallelism.
10 Client 21, 22, 23 PE (Processing Element)
30 VPE
31 Control Unit 32 Dividing Unit 33 Integration Unit 34, 35, 36, 37 Processing Block (PB)
40 CU (control unit)
Processing elements that can be processed in parallel;
A control unit;
A client requesting the control unit to execute an application;
A distributed processing system for executing the application,
The processing element is at least when executing the application,
One or more processing blocks that process each of the one or more tasks to be executed by the processing element;
A processing block control unit for calculating the degree of parallelism based on an index for controlling the degree of parallelism received from the control unit;
A dividing unit configured to divide the processing data input to the processing block based on the degree of parallelism by the processing block control unit;
An integration unit that integrates the processing data output from the processing block based on the degree of parallelism by the processing block control unit;
A distributed processing system comprising:
The distributed processing system according to claim 1, wherein the processing element includes a plurality of the processing blocks in advance.
When the processing element is connected to the control unit, PE information including a profile representing characteristics of its own function information, configuration information, maximum parallelism, and an index for controlling the parallelism and parallelism. The distributed processing system according to claim 1, wherein: is registered.
The distributed processing system according to any one of claims 1 to 3, wherein the client specifies a standard related to execution of an application.
The control unit determines and presents candidate indicators for controlling the degree of parallelism according to the PE information and / or criteria related to the execution of the application.
The distributed processing system according to claim 4, wherein the client determines an index for controlling the degree of parallelism by selecting an index from the index candidates.
The distributed processing system according to claim 4, wherein the control unit determines an index for controlling the degree of parallelism based on the PE information and / or a criterion related to execution of the application.
The distributed processing system according to any one of claims 1 to 6, wherein the index for controlling the degree of parallelism includes an upper limit and a lower limit of the degree of parallelism of each processing element.
When the upper limit value and the lower limit value of the parallelism are different from each other, the processing block control unit determines the parallelism according to an index for controlling the parallelism except for the upper limit and the lower limit. The distributed processing system according to claim 7.
The distributed processing system according to claim 7, wherein when the upper limit value and the lower limit value of the parallelism match each other, the processing block control unit performs processing with the matched parallelism.
The processing block is
A dedicated processing block for executing a predetermined function;
A general-purpose processing block whose function is changed according to the input program information;
10. The distribution according to claim 1, comprising at least one of a dynamic reconfigurable processing block for reconfiguring hardware according to input reconfiguration information. 10. Processing system.
The processing block is the dedicated processing block configured by software,
The processing element includes the dedicated processing block in advance,
The processing element has a dedicated processing block holding unit that can unload, duplicate, or erase the dedicated processing block, and can hold the dedicated processing block that has been unloaded and / or copied. The distributed processing system according to claim 10.
The distributed processing system according to claim 11, wherein the dedicated processing block holding unit replicates the held dedicated processing block according to the degree of parallelism.
13. The distributed processing system according to claim 11 or 12, wherein the dedicated processing block holding unit loads the held dedicated processing block so that the processing can be performed.
The processing block is the dedicated processing block configured by hardware,
11. The predetermined function is executed and the parallelism is controlled by connecting / disconnecting a path connecting the input of the dedicated processing block to the dividing unit and connecting the output to the integrating unit. The distributed processing system described in 1.
The processing block is the general-purpose processing block configured by software,
The processing element includes a general-purpose processing block configured by the software in advance,
The processing element is capable of unloading, duplicating, or erasing a general-purpose processing block configured by the software, and can hold the general-purpose processing block that has been unloaded and / or copied. The distributed processing system according to claim 10, further comprising:
The distributed processing system according to claim 15, wherein the general-purpose processing block holding unit replicates the held dedicated processing block according to the degree of parallelism.
The distributed processing system according to claim 15 or 16, wherein the general-purpose processing block holding unit loads the held general-purpose processing block so that the program information can be loaded.
16. The processing element according to claim 15, further comprising: a load unit that directly loads program information included in a library connected according to the task to be executed, into the general-purpose processing block from the outside. The distributed processing system according to any one of 17.
The processing element is capable of unloading, duplicating or erasing program information contained in the library loaded in the general-purpose processing block, and further holding the unloaded and / or duplicated program information. The distributed processing system according to claim 18, further comprising a holding unit.
The load unit loads the program information into the library holding unit,
20. The distributed processing system according to claim 19, wherein the library holding unit holds the program information received from the outside via a load unit.
21. The distributed processing system according to claim 19, wherein the library holding unit replicates the held program information according to the degree of parallelism.
The distributed processing system according to any one of claims 19 to 21, wherein the library holding unit loads the held program information into the general-purpose processing block.
The processing block is the dynamic reconfigurable processing block,
The processing element includes a load unit that directly loads reconfiguration information included in a library connected in accordance with the task to be executed from the outside into the dynamic reconfigurable processing block. The distributed processing system according to claim 10.
The processing element can unload, duplicate, or delete the reconfiguration information included in the library loaded in the dynamic reconfigurable processing block, and further, the reconfiguration that has been unloaded and / or copied The distributed processing system according to claim 23, further comprising a library holding unit capable of holding information.
The load unit loads the reconfiguration information into the library holding unit,
The distributed processing system according to claim 24, wherein the library holding unit holds the reconfiguration information received from the outside via a load unit.
26. The distributed processing system according to claim 24, wherein the library holding unit replicates the held reconfiguration information according to the degree of parallelism.
27. The distributed processing system according to claim 24, wherein the library holding unit loads the held reconfiguration information into the dynamic reconfigurable processing block.
Execution of functions realized by the reconfiguration information and control of the degree of parallelism by connecting / disconnecting a path connecting the input of the dynamic reconfigurable processing block to the dividing unit and connecting the output to the integrating unit The distributed processing system according to any one of claims 23 to 27, wherein:
The index for controlling the parallelism includes any one or more of parallelism, priority, quality assurance type, power consumption, processing time, and output throughput. The distributed processing system according to any one of the above.
The client designates a priority for each of the one or more tasks as an index for controlling the parallelism,
The distributed processing system according to any one of claims 1 to 29, wherein the processing block dynamically determines a degree of parallelism related to the execution of the task based on a designated priority.
The control unit presents an alternative indicator that deviates from the criterion when the candidate for the indicator that controls the degree of parallelism cannot be determined in accordance with a criterion related to execution of the application specified by the client. The distributed processing system according to claim 4.
The control unit defines candidate combinations of indicators controlling the degree of parallelism;
The client presents the index candidates to the user via a user interface, and limits input combinations on the user interface within a range of index candidate combinations that control the parallelism defined by the control unit. The distributed processing system according to any one of claims 1 to 31, wherein:
12. The processing element according to claim 11, wherein the processing element can unload all of the dedicated processing block, the general-purpose processing block, the program information, and the reconfiguration information that have already been loaded. The distributed processing system according to claim 15, claim 19, or claim 24.
34. The standard according to any one of claims 4 to 33, wherein the criterion related to execution of the application includes one or more of quality assurance type, power consumption, processing time, and output throughput. Distributed processing system.
JP2009229252A 2009-10-01 2009-10-01 Distributed processing system Withdrawn JP2011076513A (en)
JP2009229252A JP2011076513A (en) 2009-10-01 2009-10-01 Distributed processing system
CN201010507197XA CN102033783A (en) 2009-10-01 2010-09-29 Distributed processing system
US12/893,515 US20110083136A1 (en) 2009-10-01 2010-09-29 Distributed processing system
JP2011076513A true JP2011076513A (en) 2011-04-14
JP2009229252A Withdrawn JP2011076513A (en) 2009-10-01 2009-10-01 Distributed processing system
US (1) US20110083136A1 (en)
CN (1) CN102033783A (en)
JP2015191282A (en) * 2014-03-27 2015-11-02 富士通株式会社 Job schedule program, job schedule method and job schedule device
JP2017504088A (en) * 2013-12-20 2017-02-02 インテル・コーポレーション Execution offload
CN102207892B (en) * 2011-05-27 2013-03-27 清华大学 Method for carrying out synchronization between subunits in dynamic reconfigurable processor
EP2801074A4 (en) * 2011-12-28 2016-03-16 Intel Corp Pipelined image processing sequencer
Family Cites Families (3)
US6609131B1 (en) * 1999-09-27 2003-08-19 Oracle International Corporation Parallel partition-wise joins
US7506297B2 (en) * 2004-06-15 2009-03-17 University Of North Carolina At Charlotte Methodology for scheduling, partitioning and mapping computational tasks onto scalable, high performance, hybrid FPGA networks
US7730119B2 (en) * 2006-07-21 2010-06-01 Sony Computer Entertainment Inc. Sub-task processor distribution scheduling
2009-10-01 JP JP2009229252A patent/JP2011076513A/en not_active Withdrawn
2010-09-29 CN CN201010507197XA patent/CN102033783A/en not_active Application Discontinuation
CN102033783A (en) 2011-04-27
US10019294B2 (en) 2018-07-10 Method of achieving intra-machine workload balance for distributed graph-processing systems
US20190199777A1 (en) 2019-06-27 System and method for batch computing
US9753669B2 (en) 2017-09-05 Real time cloud bursting
US20180060313A1 (en) 2018-03-01 Dynamic migration script management
AU2015263042B2 (en) 2018-08-09 System and method for fully configurable real time processing
US9665404B2 (en) 2017-05-30 Optimization of map-reduce shuffle performance through shuffler I/O pipeline actions and planning
US9405553B2 (en) 2016-08-02 Processing element management in a streaming data system
US8866817B2 (en) 2014-10-21 Computer-aided parallelizing of computation graphs
US20200057672A1 (en) 2020-02-20 Dynamic tree determination for data processing
US8595742B2 (en) 2013-11-26 Executing a distributed java application on a plurality of compute nodes in accordance with a just-in-time compilation history
US8386560B2 (en) 2013-02-26 Pipeline for network based server-side 3D image rendering
US9031910B2 (en) 2015-05-12 System and method for maintaining a cluster setup
US10394847B2 (en) 2019-08-27 Processing data in a distributed database across a plurality of clusters
US8121966B2 (en) 2012-02-21 Method and system for automated integrated server-network-storage disaster recovery planning
US9176785B2 (en) 2015-11-03 System and method for providing multi-resource management support in a compute environment
US20200004638A1 (en) 2020-01-02 System and method for selective compression in a database backup operation
US6826753B1 (en) 2004-11-30 Managing parallel execution of work granules according to their affinity
US8868963B2 (en) 2014-10-21 Dynamically configurable placement engine
US8112751B2 (en) 2012-02-07 Executing tasks through multiple processors that process different portions of a replicable task
US7472193B2 (en) 2008-12-30 Expanded method and system for parallel operation and control of legacy computer clusters
JP2014029718A (en) 2014-02-13 Method of managing computing resources in graph type computation
US20140379722A1 (en) 2014-12-25 System and method to maximize server resource utilization and performance of metadata operations
US7441240B2 (en) 2008-10-21 Process scheduling apparatus, process scheduling method, program for process scheduling, and storage medium recording a program for process scheduling
US7467383B2 (en) 2008-12-16 System for controlling task execution using a graphical representation of task dependency
US9594637B2 (en) 2017-03-14 Deploying parallel data integration applications to distributed computing environments
2012-08-11 A621 Written request for application examination
Free format text: JAPANESE INTERMEDIATE CODE: A621
2013-07-18 A761 Written withdrawal of application


text:
Don Ferguson may refer to:

Don Ferguson (actor) (born 1946), Canadian actor and comedian
Don Ferguson (South Australian politician) (1936–2013)
Don Ferguson (Victorian politician) (1907–1987)
Don Ferguson (Canadian politician), Green Party of Canada candidate during the 2004 Canadian federal election
Don Ferguson (rower) (born 1912), Australian rower
Don Ferguson (soccer) (born 1963), Canadian soccer goalkeeper
J. Don Ferguson (1933–2008), sometimes credited as "Don Ferguson", American character actor

See also
Donald Ferguson (disambiguation)
Ferguson (name)

redpajama_set_name: RedPajamaWikipedia


With Hannah's Cheddar & Caramel mix of our famous gourmet popcorn, every handful of delicious popcorn becomes an adventure. While we were not the inventors of the mixing of cheese and caramel popcorn - we think that the combination of our Hannah's Caramel and Cheddar Cheese popcorn is a superior take on this classic flavor combination. We are certain your taste buds will agree. After all, there's no reason that you should have to choose between sweet and savory when it comes to handfuls of delicious popcorn. And what can be better than grabbing a handful of popcorn and tasting the sweet, rich, buttery flavor of Hannah's Caramel and the deep, robust, savory flavor of cheddar cheese? We think you'll agree, this savory sweet gourmet flavored popcorn will be a welcome addition to any party, making the choice between sweet and savory no choice at all. So go ahead and grab some, your taste buds will love you.
0.0% would recommend this item to a friend.
© 2019 Uptown Popcorn. All Rights Reserved.