I added a lot of content to this draft, and was unsure exactly what was appropriate to mention and what would not be suitable (either by being too simple or more relevant in my final dissertation), so I’m glad this was cleared up. Changes are also to be made to the overall structure of the proposal. Finally, I’ll attempt to reduce the number of references and leave some of them for my dissertation, as apparently half a dozen references would be a more suitable amount for a proposal. I think this reduction will largely occur naturally when I restructure the proposal, however.

Here’s the second outline draft, the finished proposal should be up within the next week.

Here’s my initial outline, which I am expanding on for our next meeting and will redraft into a complete proposal over Christmas.

We discussed a number of points, most of them common to each of our proposals. As well as this, Dr Ozveren gave further advice during his lecture on Thursday which will be addressed in my redraft.

• In terms of structure, “Motivation” deals with too many points and could become condescending to someone who is familiar with the topic. Splitting the proposal to deal with literature review under its own subheading will help to address this and to emphasise the research work which has taken place.
• The basic outline did not make it clear which points were taken or referencing literature and which were my own, obviously this is vital in the final proposal and as such should be demonstrated in the redraft.
• The section “Addressing the Question” might be better separated into “Issues”, “Methodology” and “Evaluation”
• The proposal should also include objectives and milestones, and optionally constraints, assumptions and risks.

Hey, sounds like a cool idea. Sounds like it might be quite a difficult project to undertake considering the need for multiple computers to be running the same simulation.

Although multiple computers will be used for the simulation, bear in mind that I can run both a server and several client nodes on one machine during implementation and to perform limited tests. I will need to make use of several computers to properly test the application, especially when it comes to networking and synchronisation issues, however hopefully this can be done in the evening, at home, or when the labs are less busy.

Will you start from one computer and then work you up by having more join the simulation?

Partially. Obviously my aim would be to start with the simplest working solution possible, and build from there in several steps:

1. Experiment with multi-threading techniques within a single application.
2. Experiment with networking between several machines.
3. Combine these approaches to create a very simple client-server framework for distributing tasks.
4. Design and build a simple basis for the simulation on top of this – get characters being processed on multiple machines.
5. Expand on the simulation and improve the underlying architecture.

Or will there be a minimum to start with and also maybe a maximum?

The number of machines which will be useful for the simulation will depend on how complicated the processing required is – for example how many entities are created. If the project is successful the simulation should run, albeit slowly, on one machine and faster as the work is distributed over multiple machines, limited by Amdahl’s law. I doubt I will achieve this ideal and the research question can still be answered even if the simulation runs slower in a distributed situation.

I take it the actions performed will just be general tasks such as moving place to place, interacting with other characters or objects, etc?

I am still deciding, to some extent, what tasks would be performed. It is important that more than one task or is handled as this creates a different type of simulation from performing an identical process on each piece of data (character).
My initial plan is to have the character choose a point in a simple 2D city to aim to go to, and then have them navigate there. Next, collisions with other data (characters) could be considered, greatly increasing the complexity of the situation. Finally, the characters could perform simple interactions with items in the world or other characters; However, I think it is unlikely I will have time to implement this option.

Will these action just be randomly assigned to any computer as long as they are free to do so?

This is a major part of what I will be investigating. Tasks will most likely be assigned to nodes spatially – in terms of an area of a 2D map, although other methods will be tested. I would especially like to try partitioning the world based on the density of characters in an area in order to try and create even workloads for different machines.

Or will certain task that may need more processing power be sent to the computer with the best processing power?

This will really depend on the hardware I have available. Ideally, I would like to measure each node’s networking and processing performance and base the amount of work distributed on this. If it is possible to use my laptop on the uni network then there will be more opportunities here than if I am working with identical lab machines. It might also be possible to simulate different hardware using virtual machines.

Thanks again for the questions!

Although I haven’t had as much time as I would have hoped for to construct another research question and I realise my ideas still require a lot of refinement, I have a (very) rough first draft of my proposal below. Hopefully I can re-write and revise this based on any feedback I receive. It’s all text from here on in because this is serious business – photo thanks to Daniel Conway..

Introduction

The aim of the investigation is to demonstrate how a series of computers, working in parallel, can be used to process and manage entities in a simple virtual world. Techniques to manage distribution and handle a range of tasks concurrently, as well as for dealing with scalability and fault tolerance will be considered.

Motivation

Concurrency has become more and more of a prominent issue within software development, even a necessity to make the most of modern advances in hardware (Davies and Shrout, 2009). With the majority current gaming systems sporting multiple-core CPUs (Valve Corporation, 2009) and consoles tailored towards parallel computation (Stokes, 2008), the importance and currency of this issue is particularly applicable to games programming.

However, nowhere is this issue more apparent than concerning the development of servers for Massively Multi-player Online Games. These systems must be capable of managing a range of tasks concurrently, dealing with variations in load while still maintaining a stable throughpu (Waldo, 2008). Even if it were possible to use a single machine for this endeavour, running costs alone(Atwood, 2007) make employing a variable number of distributed nodes a worthwhile consideration.

As such this specialised area of games development combines the problems of developing parallel applications with the issues of distributed computing, but unlike render farms which can take hours to produce movie frames (Christensen, P. H. et al, 2006), or scientific investigations which might extend for years at a time (SETI@home, 2009), results must be calculated in fractions of a second to allow the game to progress.

Improvements to the organisation and throughput of clusters of locally distributed machines can offer clear benefits to the scope and hardware requirements for running massively multi-player online games.

Research Question

How can the processing of a real-time virtual environment benefit from parallelisation over multiple distributed computer systems?

Addressing the Question

Initially, a simplest-solution framework will be created to allow for parallel tasks to be distributed over multiple networked systems, overseen by a central server. The desired simulation will be built on this and will involve the creation of a simple 2D environment, and characters which will be made to navigate and perform actions within it. From this point the simulation will be optimised and improved, in particular investigating whether and how load balancing can increase performance and minimise hardware requirements.

Although performance of the simulation will be measured in terms of throughput, a range of factors will be considered when evaluating the solution and simply allowing processing to occur over multiple systems should answer the question to a large extent.

Resources and Requirements

Although ideally a Beowulf cluster (Beowulf, 2009) could be set up to allow a range of existing software to be utilised, this would involve additional requirements – most notably the installation of the Linux (or another *NIX) operating system to multiple machines. There are few reasons why a similar setup could not be achieved using the Windows operating system currently installed on available lab computers. Multi-platform support could possibly be investigated through my own hardware, if suitable libraries and approaches were chosen for the project.

Although the project will focus on distributed computation, systems with multiple CPU cores should prove beneficial to the simulation. These should be available through the dual-core processors in the lab computers.

In terms of software, again the laboratory machines should provide the necessary packages, which might be supplemented with open source tools and libraries.

References

• Davies, L and Shrout, R. 2009. Who Moved the Goal Posts? The Rapidly Changing World of CPUs [online] Available from: http://www.gamasutra.com/view/feature/4168/sponsored_feature_who_moved_the_.php [Accessed October 2009]
   
• Valve Corporation. 2009. Steam Hardware Survey [online] Available from: http://store.steampowered.com/hwsurvey/ [Accessed October 2009]
   
• Stokes, J. 2008. Game Console Architecture In-Depth [online] Available from: http://arstechnica.com/hardware/news/2008/09/game-console-architecture-in-depth.ars [Accessed 2009]
   
• Waldo, J. 2008. Scaling in Games & Virtual Worlds. ACM Queue. 6(7), pp.10-16.
   
• Atwood, J. 2007. When Hardware is Free, Power is Expensive [online] http://www.codinghorror.com/blog/archives/000868.html [Accessed May 2007]
   
• Christensen, P. H. et al, 2006. Ray Tracing for the Movie ‘Cars’. In: Proceedings of the IEEE Symposium on Interactive Ray Tracing 2006, Salt Lake City USA September 18-20. IEEE. pp.1-6. [online] Available from: http://graphics.pixar.com/library/RayTracingCars/paper.pdf. [Accessed October 2009]
   
• SETI@home, 2009. [online] http://setiathome.berkeley.edu/sah_about.php[Accessed October 2009]
   
• Beowulf. 2009 [online] http://www.beowulf.org/overview/index.html [Accessed 2008]
   

Bibliography

As this is a rough draft, please see my relevant delicious links. These are missing references to books, ACM publications, journals I can/could only read within the university and older bookmarks which I have found useful, so I will attempt to update in the near future with a refined, current listing.