SPLASH 2011: David Ungar - Self, ManyCore, and Embracing Non-Determinism

Play SPLASH 2011: David Ungar - Self, ManyCore, and Embracing Non-Determinism

The Discussion

  • User profile image

    This is fantastic.

  • User profile image

    A fascinating and insightful interview!

    Post updated on Nov 18th, 2011, with:

    A great interview with a computer science pioneer and a visionary of the future of computing!

    Notable points:

    - David's pioneering work in the Self programming language influenced profoundly computer science and software technology (Self's adaptive optimization [1:37], object prototyping [2:58], cartoon animation GUI [3:46])

    - the future of computer architecture [5:52]

    - the challenges of parallel programming [7:42]

    - researching new data structures & algorithms that deal with imperfect computations [12:20]

    - what apps would take advantage of a PC with 1000 cores? [13:28]

    - building systems that unleash creativity in people, matters the most to David [15:45]

    My annotations on the full video follow:

    - [0:20] Q: what's David's vision behind the Self programming language?

    - [0:23] David's preocupation was in bridging the gap BETWEEN how people think AND computer programming thinking

    - [0:54] Self was born by removing features from Smalltalk

    - [1:12] surprizing discovery: language got more powerful by removing features

    - [1:37] reference to pioneering work in Self's adaptive optimization

    - [2:38] JVM users benefit from the early optimization ideas in Self

    - [2:58] Javascript benefits from the prototype object orientation pioneered in Self

    - [3:03] prototype model better matches how people think

    - [3:12] reference to a book on experiments on how people think

    - [3:22] prototype model is a more effective way to deal with objects in class-based model

    - [3:46] application of cartoon animation to user interfaces

    - [5:15] the problem on parallel programming, not solvable by today's approaches

    - [5:52] reference to an IBM project on the future of computer architecture with cheap chips of hundered or thousand cores

    - [7:42] reference to Amdahl law, of serial limitations put by parallel-serial processing

    - [8:14] the challenge of removing the 10% serialization

    - [8:24] synchronization issue in serialization (that doesn't scale)

    - [8:50] the value in abandoning serialization

    - [9:43] the fundamental tradeoff between correctness and performance

    - [10:42] reference to David's report on a spreadsheet application and a data structure

    - [11:58] mitiation strategies

    - [12:20] reference to a new research area of data structures & algorithms to allow imperfections and go back and mitigate them

    - [13:28] what apps would take advantage of a PC with 1000 cores? Business analytics, [14:31] smarter planet apps, natural language understanding, IBM Watson, [15:34] associative search (finding info on PC the way you think)

    - [15:45] what is the biggest problem that matter the most to David?

    - [16:08] David cares about building systems that unleash creativity in people

    - [18:09] David's take on SPLASH: "mobile intelectual brigadoon"

    - [19:30] reference to IBM's culture on looking into the future

    - [20:10] the tools David is using

    - [20:35] ref to a free Virtual Machine running on 60 cores

  • User profile image

    Quite a delightful fellow, he would be a great mentor for many these days.  I wonder if he would like my conceptual solution for parallelizing sequential computation.


    It uses pipelining in a vectorized form relative to other pipelines in the system, and is a just-above abstraction above instruction level parallelism.  There's a diagram for people to enjoy too Tongue Out What do people think?

  • User profile image

    Thanks a lot for the great interview; is David's talk on video?  Or is there presentation materials I can get a hold of?

    10:30 talks about the exact problem I am dealing with right now.  We have a hashtable datastructure using locking for synchronization.  It has been giving us, alternatingly, performance problems (high CPU due to spinwait not using YieldProcessor, but an older x86 only assembly rep nop call), and duplicate key problems.  There is another race condition happening that I can't seem to prevent, where the probable cause is that lookups in the hashtable is not a critical section and if it was then we'd reduce performance and introduce deadlocks.  Some thread A wants to insert a record into the cache, A checks for an existing entry, finds none, then sleeps.  Thread B then wants to insert the record in the cache, does the lookup for an existing entry, finds none, but continues and inserts the record.  Thread A wakes up and thinks it is fine to insert the record, since it just checked, now you attempt to insert a duplicate.  There are many other problems to mitigate as well.  It becomes so complicated that you can't duplicate bugs when they occur.  

    In my research I've found this paper: Split-Ordered Lists: Lock-Free Extensible Hash Tables and related papers, such as Resizable, scalable, concurrent hash tables.  I'm interested in hearing anything anyone has to say about those papers and if anyone has implemented them, I think I will have to try it, as our product is being scaled up so much that the existing locking based hashtable simply cannot work reliably or fast enough anymore.




  • User profile image

    @HeavensRevenge:  Checking it out.  I found another paper called "Resizable, Scalable, Concurrent Hash Tables via Relativistic Programming" ... it's new to me.


  • User profile image

    @Richard.Hein: Thats a damn good paper, I had no idea my idea/term is spreading and is helping to make research progress in ways I hadn't known Tongue Out Thanks for linking that paper, I'd definitely suggest that sort of solution for your hash table not by bias but by such impressive results they got.

    Good luck with coding a prototype for your product.

Add Your 2 Cents