Parallelization and instrumentation in a producer graph oriented programming framework

• US 20080134207A1
• Filed: 12/01/2006
• Published: 06/05/2008
• Est. Priority Date: 12/01/2006
• Status: Active Grant

• Current Assignee: Murex S.A.S.
• Original Assignee: Murex S.A.S.
• Inventors: Chamieh, Fady, Edde, Elias
• Granted Patent: US 8,307,337 B2
• Time in Patent Office: Days
• US Class Current: 719/315
• CPC Class Codes: G06F 11/3404 for parallel or distributed programming
• CPC Class Codes: G06F 11/3419 by assessing time
• CPC Class Codes: G06F 11/3428 Benchmarking
• CPC Class Codes: G06F 11/3495 for systems
• CPC Class Codes: G06F 2201/865 Monitoring of software
• CPC Class Codes: G06F 9/4488 Object-oriented
• CPC Class Codes: G06F 9/4494 data driven

Abstract

Embodiments of parallelization and/or instrumentation in a producer graph oriented programming framework have been presented. In one embodiment, a request to run an application program is received, wherein object-oriented source code of the application program includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers with outputs that are an input to the given method, wherein a producer is at least an instance and a method associated with that instance. Further, execution of the application program may be parallelized based on dependency between producers of the application program using the runtime. In some embodiments, the application program is instrumented using the runtime.

Claims

1. A computer implemented method for executing an application program written in object-oriented code, the method comprising:

instantiating a producer with an output that is currently of interest, wherein the object-oriented code includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance;

responsive to said instantiating, adding the producer of interest as part of a producer graph;

attempting to automatically generate a remainder of the producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the producer graph; and

executing the producers in the producer graph to determine the current output for the producer of interest, wherein said executing comprises parallelizing execution of at least two of the producers in the producer graph using the runtime based on dependency between the producers in the producer graph.

2. The method of claim 1, wherein parallelizing execution of the at least two of the producers in the producer graph comprises:

identifying a set of ready producers among the producers in the producer graph;

determining an execution mode of each producer of the set of ready producers;

causing each producer of the set of ready producers to be executed in a corresponding execution mode.

3. The method of claim 2, wherein the execution mode is one of a local execution mode, a multiprocessing mode, and a multithreading mode.

4. The method of claim 2, further comprising:

creating a task for each producer in the set of ready producers; and

causing the task to be executed in the execution mode of the corresponding producer.

5. The method of claim 4, wherein the task of each producer of the set of ready producers comprises a reference to a corresponding producer and a reference to an output of the corresponding producer.

6. The method of claim 2, wherein determining the execution mode of each producer of the set of ready producers comprises:

checking an execution mode setting of a method of a corresponding producer;

overriding the execution mode setting of the corresponding producer if an end user selects another execution mode on at least one of a class basis, a method basis, and an instance basis;

overriding the execution mode setting of the corresponding producer on a producer-by-producer basis if a corresponding execution mode setting of the corresponding producer has been changed in the producer graph; and

overriding the corresponding execution mode setting in the producer graph with a predetermined execution mode if the runtime has been set to globally override the corresponding execution mode with the predetermined execution mode.

7. The method of claim 1, further comprising:

acquiring metrics related to the executing of the producers in the producer graph using the runtime on a producer by producer basis in response to an instrumentation request, comprising, measuring execution time of the producers in the producer graph on a producer by producer basis.

8. The method of claim 7, wherein acquiring metrics further comprises:

measuring execution time of the producers in the producer graph on a job basis, wherein a job comprises a plurality of producers to be multiprocessed.

9. The method of claim 8, wherein acquiring metrics further comprises:

benchmarking local execution against distant execution of the job in response to a benchmarking request, comprising,

executing the plurality of producers locally;

measuring local execution time of the plurality of producers;

sending the job to a grid of processors, wherein the grid of processors execute the plurality of producers substantially in parallel;

measuring an overall execution time of the job;

comparing the local execution time against the overall distant execution time; and

measuring input streams size and output streams size on a producer by producer basis.

10. A computer implemented method for executing an application program written in object-oriented code, the method comprising:

instantiating a producer with an output that is currently of interest, wherein the object-oriented code includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance;

responsive to said instantiating, adding the producer of interest as part of a producer graph;

attempting to automatically generate a remainder of the producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the producer graph; and

instrumenting the application program based on the producer graph using a runtime with producer graph oriented programming support.

11. The method of claim 10, wherein instrumenting the application program comprises:

measuring execution time of the application program on a producer by producer basis.

12. The method of claim 10, wherein instrumenting the application program further comprises:

sending a job to a grid of processors, wherein the grid of processors execute a plurality of producers of the job substantially in parallel;

measuring an overall execution time of the job; and

measuring input streams size and output streams size on a producer by producer basis.

13. The method of claim 12, wherein instrumenting the application program further comprises:

benchmarking local execution against distant execution of the job in response to a benchmarking request, comprising,

executing the plurality of producers of the job locally; and

measuring local execution time of the plurality of producers.

14. The method of claim 13, wherein benchmarking further comprises:

comparing the local execution time against the overall distant execution time; and

deriving comparison metrics from the local execution time, and the overall distant execution time.

15. An apparatus comprising:

a runtime to run object-oriented source code with producer dependency declarations for methods and execution mode settings for the methods, wherein a producer is a runtime instantiatable construct that includes an instance and a method associated with that instance, wherein each producer dependency declaration for a given method identifies a set of zero or more producers and wherein said runtime includes,

an automated producer graph generation module to receive a designation of a producer of interest, to add the producer of interest as part of a producer graph, and to automatically generate a remainder of the producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the producer graph, and

an automated producer graph execution module to execute the producers in the producer graph in the order indicated by the producer graph to determine an output of the producer of interest, wherein execution of each producer results in the method of the producer being executed on the instance of the producer, and the automated producer graph execution module comprises,

a parallelization module to cause zero or more of the plurality of producers to be executed in parallel.

16. The apparatus of claim 15, wherein the automated producer graph execution module further comprises:

a local execution module coupled to the parallelization module to cause a producer having an execution mode of local execution to be executed locally.

17. The apparatus of claim 16, wherein the automated producer graph execution module further comprises a metrics acquisition module to measure local execution time of the producer having the execution mode of local execution if instrumentation is requested.

18. The apparatus of claim 15, wherein the automated producer graph execution module further comprises:

a multithreading module coupled to the parallelization module to initiate a thread pooling mechanism and to feed available threads with multithreading tasks corresponding to producers having an execution mode of multithreading.

19. The apparatus of claim 18, wherein the automated producer graph execution module further comprises a metrics acquisition module to measure execution time of each of the producers having the execution mode of multithreading if instrumentation is requested.

20. The apparatus of claim 15, wherein the automated producer graph execution module further comprises:

a multiprocessing module coupled to the parallelization module to instantiate a job, to serialize multiprocessing tasks corresponding to producers having an execution mode of multiprocessing, to serialize inputs and underlying instances of the multiprocessing tasks, to add the serialized multiprocessing tasks and the serialized inputs and the serialized underlying instances to the job, and to provide the job to a grid dispatcher, the grid dispatcher to dispatch the job to a grid having a plurality of processors to execute the multiprocessing tasks in the job.

21. The apparatus of claim 20, wherein the automated producer graph execution module further comprises a metrics acquisition module is to measure execution time of each of the multiprocessing tasks corresponding to the producers having the execution mode of multiprocessing, serialization time and size of the multiprocessing task inputs, outputs, and instances within the job, deserialization time and size of the multiprocessing task inputs, outputs, and instances within the job, and execution time of the multiprocessing tasks within the job if instrumentation is requested.

22. The apparatus of claim 21, wherein, responsive to a benchmarking request, the metrics acquisition module is to measure local execution time of the multiprocessing tasks, to compare the local execution time of the multiprocessing tasks against the execution time of the job, and to derive comparison metrics.

23. The apparatus of claim 15, wherein the runtime further comprises:

a producer-based configurable decision structure coupled to the parallelization module to store execution mode based on a combination of one or more of a class key, an instance key, and a method key from a runtime client, wherein the automated producer graph generation module is operable to determine the execution mode based on the execution mode selections, the execution mode settings, and a runtime override setting, if any.

24. The apparatus of claim 15, wherein the runtime further comprises:

a producer graph structure coupled to the automated producer graph generation module and the automated producer graph execution module to store outputs of the plurality of producers, the execution mode settings, and metrics acquired, if any.

25. The apparatus of claim 15, wherein the runtime further comprises:

a runtime setting structure to store global execution mode override settings.

26. An apparatus comprising:

a runtime to run object-oriented source code with producer dependency declarations for methods and execution mode settings for the methods, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, wherein each producer dependency declaration for a given method identifies a set of zero or more producers and wherein said runtime includes,

an automated producer graph generation module to receive a designation of a producer of interest, to add the producer of interest as part of a producer graph, and to automatically generate a remainder of the producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the producer graph, and

an automated producer graph execution module to execute the producers in the producer graph in the order indicated by the producer graph to determine an output of the producer of interest, wherein execution of each producer results in the method of the producer being executed on the instance of the producer, and the automated producer graph execution module comprises,

a metrics acquisition module to acquire metrics related to execution of the plurality of producers on a producer by producer basis if instrumentation is requested.

27. The apparatus of claim 26, wherein the metrics acquisition module is operable to measure execution time of the producers in the producer graph.

28. A machine-readable medium that provides object-oriented source code including:

a plurality of class definitions each including, a set of one or more fields,

a set of one or more methods,

a producer dependency declaration for each method of said set of methods,

wherein the producer dependency declaration for a given one of said methods is used by a runtime to identify a set of zero or more producers and wherein a producer is a runtime instantiatable construct that includes at least an instance of one of the plurality of classes at runtime and a method associated with that instance, and

wherein the runtime is operable to automatically generate a producer graph for a designated producer of interest through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the other producers, and to automatically execute at least two of the producers in the producer graph substantially in parallel based on dependency between the producers as indicated in the producer graph.

29. The machine-readable medium of claim 28, wherein the runtime is operable to automatically acquire metrics related to execution of the producers in the producer graph responsive to an instrumentation request.

30. The machine-readable medium of claim 29, wherein the runtime is operable to automatically benchmark local execution of one or more producers in the producer graph against distant execution of the one or more producers by multiprocessing responsive to a benchmarking request.

31. The machine-readable medium of claim 28, wherein the object-oriented source code further includes:

an execution mode setting for each method of said set of methods.

32. The machine-readable medium of claim 31, wherein the runtime determines an execution mode in which the respective method is to be executed based on the execution mode setting, a second execution mode setting in a configurable decision structure from one of an end user and a client code, if any, a third execution mode setting in a producer graph structure from one of the end user and the client code, if any, and a runtime override setting, if any.

33. The machine-readable medium of claim 31, wherein the execution mode is one of a local execution mode, a multiprocessing mode, and a multithreading mode.

34. The machine-readable medium of claim 31, wherein one or more of the plurality of class definitions further include:

one or more execution mode settings provided in annotation.

35. The machine-readable medium of claim 28, wherein the object-oriented source code further includes:

an override runtime execution mode setting command to override the execution mode at runtime level.

36. The machine-readable medium of claim 28, wherein the object-oriented source code further includes:

an override producer execution mode setting command to override the execution mode on a producer-by-producer basis.

37. The machine-readable medium of claim 28, wherein the object-oriented source code further includes:

a configurable decision tree execution mode setting command to override the execution mode on a basis of at least one of a class, a method, and an instance.

38. The machine-readable medium of claim 28, wherein the object-oriented source code further includes:

a configurable decision tree execution mode setting command to override the execution mode on a basis of at least one of a class, a method, and an instance.