Comments on: Current Projects

By: Peter Boothe

Peter Boothe — Sun, 01 Aug 2010 09:52:12 +0000

No video as far as I know, but my slides may be found at http://home.manhattan.edu/~peter.boothe/2010-03...

By: Lindsey Kuper

Lindsey Kuper — Sun, 01 Aug 2010 06:51:21 +0000

You gave a talk about your Ph.D. work at Google? Are there slides or a video?

By: Daniel Stutzbach

Daniel Stutzbach — Fri, 09 Jul 2010 01:01:10 +0000

What if you assume that the operating system will keep in memory the most recently used p pages each of which is k bytes, where p and k are constants (i.e., not a function of n)?

Then a linear scan is O(n) page faults, Heapsort is O(n log n) page faults, and Mergesort is ...

I guess Mergesort would work out to be O(n log n) page faults as well, but it'd be closer to O(n log_k n) page faults compared to Heapsort's O(n log_2 n) page faults. I see now your dilemma.

By: Peter Boothe

Peter Boothe — Fri, 09 Jul 2010 00:35:26 +0000

Replying to Dan, you've just pointed out the big flaw in the model. I don't see an easy way of dealing with your concern, but I agree it exists. The big hope is mostly that this new model will be “less wrong” than simply ignoring the problem.

By: Daniel Stutzbach

Daniel Stutzbach — Thu, 08 Jul 2010 02:05:06 +0000

I look forward to reading this paper after you've written it. I typically have plenty of physical memory to work with, but essentially the same reasoning applies to CPU cache which is a much scarcer resource.

I am not sure I understand your adjacent-pointer heuristic. If I make a linear scan through an array, all of my pointer accesses are adjacent but wouldn't I still incur O(n) page faults?

As a minor caveat, if the list being sorted contains pointers to objects then Mergesort is also O(n log n), since the dereference points to an essentially random piece of memory.

By: Peter Boothe

Peter Boothe — Thu, 08 Jul 2010 00:36:46 +0000

The model, currently undergoing experimental validation, attempts to estimate the number of page faults an algorithm will have. The basic idea is that you count the number of times in which a pointer is accessed that is not adjacent to an existing pointer. In this model, Heapsort has O(n lg n) page faults and Mergesort only has O(n). Thus, we have (possibly) figured out an easy way of assessing “cache friendliness” or “works well in the presence of virtual memory”. There's lots of algorithms that have this designed in – see streaming algorithms and cache oblivious algorithms – but I know of no ex-post-facto way of analyzing an algorithm to assess its friendliness. And certainly not with such an easy-to-analyze model.

By: F. Carr

F. Carr — Wed, 07 Jul 2010 23:42:33 +0000

pls can has “Model for programs under memory pressure” ?? kthxbye

By: Chris Hanusa

Chris Hanusa — Wed, 07 Jul 2010 20:24:35 +0000

I always thought that 3 3 7 7 was one of the hardest 24 puzzles.
PS. Happy late birthday! I guess you got an Orange present.

By: Peter Boothe

Peter Boothe — Wed, 07 Jul 2010 07:01:23 +0000

There seem to be no good HS textbooks. We have good calc textbooks, but somehow not for CS.

By: Daniel Stutzbach

Daniel Stutzbach — Wed, 07 Jul 2010 03:32:21 +0000

Your “Growing Programs” idea could also make a good children's or high school intro-to-programming book.