Index: MemoryManager.cs
===================================================================
--- MemoryManager.cs	(revision 908)
+++ MemoryManager.cs	(working copy)
@@ -32,6 +32,7 @@
 		}
 
 		private static Header* firstNode = null;
+        private static Header* lastFreeNode = null;
 
 		public static unsafe void Setup ()
 		{
@@ -40,23 +41,30 @@
 
 			firstNode = (Header*) memoryStart;
 			firstNode->Previous = null;
-			firstNode->Next = null;
+			firstNode->Next = firstNode;
 			firstNode->Size = memoryEnd - memoryStart - (uint) sizeof (Header);
 			firstNode->Free = true;
+            lastFreeNode = firstNode;
 		}
 
 		public static unsafe void* Allocate (uint allocate_size)
 		{
 			Kernel.Diagnostics.Assert (firstNode != null, "MemoryManager.Allocate(uint): Unable to allocate because the MemoryManager has not been initialized");
-			Header* currentNode = firstNode;
+			
+            Header* currentNode = lastFreeNode;
 
 			// FIXME: Use a free list as this is VERY slow but works, asgeirh 2007-11-16
-			while (currentNode != null) {
+			while (true) {
 				if (currentNode->Free && currentNode->Size >= allocate_size) {
 					break;
 				}
 
 				currentNode = currentNode->Next;
+                if (currentNode == lastFreeNode)
+                {
+                    currentNode = null;
+                    break;
+                }
 			}
 
 			Diagnostics.Assert (currentNode != null, "MemoryManager.Allocate(uint): Unable to allocate memory; no sufficiently sized nodes available");
@@ -79,17 +87,20 @@
 				nextNode->Previous = currentNode;
 				nextNode->Next = null;
 
-				if (currentNode->Next != null) {
-					// There are more nodes in list so injection is required
-					Header* tmpNext = currentNode->Next;
+                Header* tmpNext = currentNode->Next;
 
-					nextNode->Next = tmpNext;
-					tmpNext->Previous = nextNode;
-				}
+                nextNode->Next = tmpNext;
+                tmpNext->Previous = nextNode;
 
-				currentNode->Next = (Header*) nextPtr;
+				currentNode->Next = nextNode;
 			}
 
+            //Check to see if the next node is free, larger in size than lastFreeNode, and is also
+            //lower in range than lastFreeNode.  If all these are true, set lastFreeNode to the next
+            //node.
+            if (currentNode->Next->Free == true && currentNode->Next->Size > lastFreeNode->Size && currentNode->Next < lastFreeNode)
+                lastFreeNode = currentNode->Next;
+
 			uint retPtr = (uint) currentNode + (uint) sizeof (Header);
 			allocated += (ulong) currentNode->Size;
 
@@ -110,8 +121,10 @@
 			freeHeader->Free = true;
 
 			Header* currentNode = freeHeader;
+            Header* startingPoint = currentNode;
+
 			//Scan forward for the last consecutive free node
-			while (currentNode->Next != null && currentNode->Next->Free)
+			while (currentNode->Next != firstNode && currentNode->Next->Free)
 				currentNode = currentNode->Next;
 			//Now scan backwards and consolidate free nodes
 			while (currentNode->Previous != null && currentNode->Previous->Free) {
@@ -126,6 +139,8 @@
 
 				currentNode = currentNode->Previous;
 			}
+            if (currentNode->Next->Free == true && currentNode->Next->Size > lastFreeNode->Size && currentNode->Next < lastFreeNode)
+                lastFreeNode = currentNode;
 		}