List of Figures

1. Overview of Charisma architecture
2. Pictorial summary of the thesis.
3. Control regimes for parallel programs
4. Software Architecture of Converse
5. Pseudo-code for scheduler variants
6. Converse message-passing performance
7. Converse scheduler overhead
8. NAMD 2 Architecture
9. Chare interface description
10. Proxy class to MyChare generated from the interface description
11. Chare Definition
12. Invoking a chare's method
13. Chare array interface description
14. Chare array element Definition
15. Invoking chare array's methods
16. A sequential wrapper for parallel components
17. Rigid structure imposed on interaction between parallel components
18. Processor-based parallel wrappers promote efficient interaction among parallel components
19. Asynchronous remote service invocation with return results
20. Proliferation of interfaces
21. A Producer-Consumer Application
22. Transformer Component
23. Construction of a 2-D array component from elements
24. A Parallel image smoother construction from sub-image smoother components
25. Fluids-Solids interface in a coupled simulation
26. Fluids grid partitioned into $32\times 32$ chunks
27. Fluids grid partitioned into 4 processors
28. Construction of a Particle-Set component from Boxes dynamically using recursive bisection.
29. Dynamic Network Creation
30. Sequential partitioner wrapper for METIS
31. Parallel processor-based partitioner wrapper for METIS
32. Charisma components lack explicit control-flow specification.
33. Real world components may have complex control flow structures. In this diagram, solid circles denote computations that are internal to the component. Dashed circles denote external computations. Solid lines are dependencies internal to the component, whereas dashed lines denote external dependencies among computations.
34. Charm++ Implementation of ``Compute-Object'' in Molecular dynamics
35. Flow of control in compute-object.
36. Multi-threaded Implementation of ``Compute-Object'' in Molecular dynamics
37. Structured Dagger Implementation of ``Compute-Object'' in Molecular dynamics
38. Simplified syntax of a when-block
39. Structured Dagger Implementation of the control-flow depicted in figure 4.2
40. Out of order messages
41. Harlow-Welch Program
42. Spatial Decomposition in Harlow-Welch Scheme
43. A Non-Series-Parallel Control-Flow Graph
44. Possible Structured Dagger implementations for the Non-Series-Parallel Graph (Fig. 4.12)
45. ``Overhead'' of threaded components
46. Performance of Conjugate-Gradient solver on a single processor.
47. Threads impede migration, since references to stack variables may become invalid upon migration if stacks are dynamically allocated.
48. An example of references to stack variables
49. Comparison of context-switching times of stack-copying and isomalloc-based migrating threads with non-migrating threads. This experiment was performed on NCSA Origin2000, with 250 MHz MIPS R10000 processor.
50. Address space layout of a typical Unix process.
51. Original MPI program
52. Conversion to AMPI: Shared data is aggregated in a user-defined type.
53. Conversion to AMPI: References to shared data are made through thread-private variables.
54. Intermodule communication using AMPI cross-communicators.
55. Registration of multiple AMPI modules.
56. The throughput (number of iterations per second) for a Jacobi relaxation application. (Left) with 1-D decomposition. (Right) with 3-D decomposition.
57. Comparison of AMPI with native MPI.
58. AMPI adaptivity on a heterogeneous cluster.
59. CSAR integrated rocket simulation code on heterogeneous cluster.
60. AMPI components respond to changing machine availability at runtime.
61. Dynamic load balancing in irregular and dynamic AMPI components.