Senior Project Proposal
Department of Computer Science
Calvin College
Developing a Framework for Asynchronous Communication Between Objects in Shared Memory Systems
Jonathan Walz
10-08-08
Department of Computer Science
Calvin College
Developing a Framework for Asynchronous Communication Between Objects in Shared Memory Systems
Jonathan Walz
10-08-08
Vision and General Overview of Proposal
Background and Problem:
In an effort fo circumvent the physical barriers to Moore's Law, the world of microprocessors has gone multi-core. At present, though, the benefits to consumers aren't all they could be. The task for writing concurrently executing programs in a broad sense remains a difficult task in most languages currently seeing common use. Yet, so long as our home computers are evolving into shared memory distributed systems, we have an obligation got come up with simpler techniques for effectively utilizing the power we are being given.
While most modern languages provide the ability to write concurrent programs through careful use of threads, locks, monitors, and other mechanisms of "shared memory concurrency", doing so is a burdensome task. The programmer needs to be careful to avoid deadlock, race conditions, and other dangers of shared memory access. Beyond this, it requires adopting and entirely new programming style that is harder both to write and maintain.
Some languages, however, have opted to focus on the potential created yb asynchronous message passing to make it easier to develop concurrently executing programs. At the present time, Erlang is the best known of these languages. Erlang allows the programmer to load code modules into "processes", which operate concurrently on a (potentially distributed) system and request computation from other Erlang processes on a system through asynchronous message passing. However, Erlang's focus lies chiefly in distributed memory systems; meaning many of its mechanisms create more overhead than is needed for concurrent operation on simple shared memory systems like current multi-core processors. Beyond this, Erlang's syntax borrows heavily from the functional programming paradigm, which, for many programmers, makes it less intuitive for many common tasks than Procedural or Object Oriented languages.
Brief Descriptoin of Solution Being Provided:
This sort of "message passing" concurrency seems like it should be a great match for the Object Oriented paradigm. We already talk about passing messages between objects, so mechanisms to allow for these communications to be asynchronous could potentially let us provide concurrent execution with only minimal alterations to our existing development techniques. As such, it is my goal to create a framework within either C++or Java that will utilize the semantics of message passing concurrency to veil the operation of traditional shared memory concurrency in an effort to promote easier development of concurrently executing applications. The mechanisms of this library will, ideally, operate in a memory-safe manner to eliminate developer concerns about deadlock and other such problems to the greatest extent possible.
It is important to note the difference between my intentions and those of "message passing" frameworks such as MPI or OpenMP. These libraries are designed primarily to support parallelization of execution - that is, dividing up execution of looping structures of of operations across collections among multiple processing units. The message passing they employ is also between explicit supervising processes on the distinct processing units. As such, in order to implement the features of these libraries, the programmer must, to some extent, specialice his or her code for specific machine architectures. My framework aims to focus on a broader concept of concurrent execution and to ease the need for programmers to develop with any specific architecture in mind.
Your Interest and Qualifications
Beyond being a devoted student with a great desire to somehow advance the state of computing, I have no special qualifications for this task. My interest lies in my desire to make life easier for programmers and improve the quality of the user experience. Beyond that, I feel that this project will stretch me in ways that nothing I have done before has and provide me with a better idea of it I would truly be happy pursuing a PhD. and the academic life - as is my current intention.
...(boring things cut out here)...
Research Question
Fundamentally, my project doesn't lend itself well to any sort of question. To keep it simple, my goal is to determine the feasibility of developing a framework such as the one I am suggesting and the impect of asynchronous communication between "objects" in a shared memory system.
Development Approach
I intend for this to be largely an exploratory endeavor. As such, the first and most important task before me will be in reading up on existing implementations of concurrent programming strategies and performing small scale proof of concept experiments to help determine my specifications for the final product.
As for the final product, I intend to write it in a fashion keeping in with the tenets of either Test Driven Development or Literate Programming. Both methods were devised to promote consistency and stability. Test Driven Development is an area in with Prof. Frens' expertise would be a great asset in filling in one of the weakest areas of my own development skills - software testing. Literate Programming, on the other hand, is a strategy that would seem to work well with my tendency to resolve my problems most effectively by first sorting out and establishing their semantics.
[...boring stuff until end...]
Again, if you would like to see the actual document, which looks much nicer than this, let me know.
Background and Problem:
In an effort fo circumvent the physical barriers to Moore's Law, the world of microprocessors has gone multi-core. At present, though, the benefits to consumers aren't all they could be. The task for writing concurrently executing programs in a broad sense remains a difficult task in most languages currently seeing common use. Yet, so long as our home computers are evolving into shared memory distributed systems, we have an obligation got come up with simpler techniques for effectively utilizing the power we are being given.
While most modern languages provide the ability to write concurrent programs through careful use of threads, locks, monitors, and other mechanisms of "shared memory concurrency", doing so is a burdensome task. The programmer needs to be careful to avoid deadlock, race conditions, and other dangers of shared memory access. Beyond this, it requires adopting and entirely new programming style that is harder both to write and maintain.
Some languages, however, have opted to focus on the potential created yb asynchronous message passing to make it easier to develop concurrently executing programs. At the present time, Erlang is the best known of these languages. Erlang allows the programmer to load code modules into "processes", which operate concurrently on a (potentially distributed) system and request computation from other Erlang processes on a system through asynchronous message passing. However, Erlang's focus lies chiefly in distributed memory systems; meaning many of its mechanisms create more overhead than is needed for concurrent operation on simple shared memory systems like current multi-core processors. Beyond this, Erlang's syntax borrows heavily from the functional programming paradigm, which, for many programmers, makes it less intuitive for many common tasks than Procedural or Object Oriented languages.
Brief Descriptoin of Solution Being Provided:
This sort of "message passing" concurrency seems like it should be a great match for the Object Oriented paradigm. We already talk about passing messages between objects, so mechanisms to allow for these communications to be asynchronous could potentially let us provide concurrent execution with only minimal alterations to our existing development techniques. As such, it is my goal to create a framework within either C++or Java that will utilize the semantics of message passing concurrency to veil the operation of traditional shared memory concurrency in an effort to promote easier development of concurrently executing applications. The mechanisms of this library will, ideally, operate in a memory-safe manner to eliminate developer concerns about deadlock and other such problems to the greatest extent possible.
It is important to note the difference between my intentions and those of "message passing" frameworks such as MPI or OpenMP. These libraries are designed primarily to support parallelization of execution - that is, dividing up execution of looping structures of of operations across collections among multiple processing units. The message passing they employ is also between explicit supervising processes on the distinct processing units. As such, in order to implement the features of these libraries, the programmer must, to some extent, specialice his or her code for specific machine architectures. My framework aims to focus on a broader concept of concurrent execution and to ease the need for programmers to develop with any specific architecture in mind.
Your Interest and Qualifications
Beyond being a devoted student with a great desire to somehow advance the state of computing, I have no special qualifications for this task. My interest lies in my desire to make life easier for programmers and improve the quality of the user experience. Beyond that, I feel that this project will stretch me in ways that nothing I have done before has and provide me with a better idea of it I would truly be happy pursuing a PhD. and the academic life - as is my current intention.
...(boring things cut out here)...
Research Question
Fundamentally, my project doesn't lend itself well to any sort of question. To keep it simple, my goal is to determine the feasibility of developing a framework such as the one I am suggesting and the impect of asynchronous communication between "objects" in a shared memory system.
Development Approach
I intend for this to be largely an exploratory endeavor. As such, the first and most important task before me will be in reading up on existing implementations of concurrent programming strategies and performing small scale proof of concept experiments to help determine my specifications for the final product.
As for the final product, I intend to write it in a fashion keeping in with the tenets of either Test Driven Development or Literate Programming. Both methods were devised to promote consistency and stability. Test Driven Development is an area in with Prof. Frens' expertise would be a great asset in filling in one of the weakest areas of my own development skills - software testing. Literate Programming, on the other hand, is a strategy that would seem to work well with my tendency to resolve my problems most effectively by first sorting out and establishing their semantics.
[...boring stuff until end...]
Again, if you would like to see the actual document, which looks much nicer than this, let me know.
1 comment:
This wound up not actually being the final draft of the proposal. I made some unclear wording choices in a few places. When I said "architecture agnostic", I really meant platform (i.e. OS) agnostic. I'm only actually looking for something that works on an x86 architecture.
If anybody wants to see the proposal that was actually accepted, let me know.
Post a Comment