Iktara in ConCert Realizing a Certified Grid Computing Framework from Programmer’s Perspective

1. With the vast amount of computing resources distributed throughout the world today, the prospect of effectively harnessing these resources has captivated the imaginations of many and motivated both industry and academia to pursue this dream. In recent years, we have seen numerous organizations desperately seeking resource donors. Part of the difficulty with obtaining resources is the establishment of trust between the distributed-application developer and the resource donors. Because donors often receive little or no direct reward for their contributions, they vehemently demand safety, security, and privacy assurances. To address this issue, the ConCert project (to which this specific undertaking contributes) seeks to develop the theoretical and engineering foundation for grid computing in a trustless setting based on the notion of certified code. We believe that this is the best means to create a grid infrastructure that allows application developers to propagate their software to as many hosts as possible and maximize the exploitation of these resources. In this project, we seek to drive an initial implementation of a real framework for the distribution and verification of software from a programmer’s perspective. Specifically, we search for a reasonable and effective model for programming the grid. To better understand the design space of such a framework and programming model, we perform a case study on a specific application, namely a parallel theorem prover for linear logic (Iktara), which imposes a unique and guiding set of requirements. Such a development process aims to both inspire new ideas and to expose current problems. TAL Direction of Search Results Researcher Resource Donors OR Resource Donors Iktara in ConCertRealizing a Certified Grid Computing Framework from Programmer’s Perspective Bor-Yuh Evan ChangAdvisors: Professor Robert Harper and Professor Frank Pfenning Abstract ConCert More Information • Suppose you have an ingeniously crafted massively parallelized algorithm to solve some problem. You would like use all the “wasted” computing resources of the Internet. • Problem: How does a resource donor know you are a benevolent researcher and not an evil hacker? • The ConCert project proposes to use certified code to resolve this issue of trust. • Each program comes with a mathematical proof that the program adheres to the resource donor’s safety, security, and privacy policies. ConCert Project Webpage • http://www.cs.cmu.edu/~concert/ • My Presentation • 3:00pm, Class of ’87 Room • Margaret DeLap (senior, SCS) • Implementing a Framework for Certified Grid Computing • Presentation: 1:20pm, Dowd Room • Poster • Jason Liszka (senior, SCS) • Trustless Grid Raytracing • Poster The ConCert project seeks to develop programming language and type theoretic technology for Grid Computing in a trustless setting. My Contribution Idea: The process of developing a substantial application using the ConCert framework will help us better understand the requirements on the framework and how to program in such an environment. Theorem Proving Algorithm ConCert Framework Jobs, Tasks, and Cords • Focusing [Andreoli ’92][Pfenning ’01] • Refinement of the plain sequent calculus to reduce the non-determinism in proof search • Advantageous for parallelization by concentrating several non-deterministic choices into one place • Procedure: • first apply invertible rules eagerly • select a “focus” proposition and apply non-invertible rules until reach an atom or an invertible connective • upon reaching an atom, proof attempt either fails or succeeds • Resource-distribution via Boolean constraints [Harland and Pym ’01] • Method to postpone the distribution of resources for multiplicative connectives • Represent constraints using OBDDs (Ordered Binary Decision Diagrams) • With Tom Murphy, Margaret DeLap, and Jason Liszka, we seek to develop a real framework to: • Motivate theoretical work • Provide a source of technical ideas and problems to solve • Provide a testbed for implementation • Margaret and Jason • Low-level to discover implementation issues. • Evan and Tom • High-level to discover programming issues. • Job: A whole-program that is injected into the network from the command-line. The unit of computation from the grid application user’s point of view. • Task: The unit of computation from the programmer’s point of view. Consists of a piece of closed code along with its arguments. • Cord: The unit of computation scheduled by the ConCert software. • Goals • Make apparent the current shortcomings. • Drive the framework to a more robust and stable state. • Better understand the requirements from a programmer’s perspective. • Design a programming model based on these observations. • What Application? • A bottom-up parallel theorem prover for intuitionistic linear logic Example: Mergesort ML Interface Focusing (* mergesort : int list * int -> int list *) fun mergesort (l, cutoff) = let val (lt, md, rt) = (* … split l into three parts … *) in if (length l <= cutoff) then (* … do mergesort sequentially … *) else let (* Start sorting each partition *) val t1 = inject true (mergesort, (lt, cutoff)) val t2 = inject true (mergesort, (md, cutoff)) val t3 = inject true (mergesort, (rt, cutoff)) (* Get the results of the 3 child tasks. Start merging when 2 sorted lists have been received. *) val (sort1, sort2) = let val (a, rest) = relax [t1,t2,t3] val (b, [last]) = relax rest in (merge (a,b), sync last) end in merge (sort1, sort2) end signature CCTASKS = sig (* an 'r task is a computation yielding a result of type 'r *) type 'r task val inject : bool -> ('e -> 'r) * 'e -> 'r task val enable : 'r task -> unit val sync : 'r task -> 'r val syncall : 'r task list -> 'r list val relax : 'r task list -> 'r * 'r task list val forget : 'r task -> unit val status : 'r task -> CCStatus.status end Future Work • Prover • Integrate with ConCert software. • Programming Model • Implement compiler. • Find how to determine if or ensure that data is marshalable. • Are there more primitive constructs? Use Parallelism Here Sequential Implementation Parallel Implementation