Well it seems like an eternity ago but at last I'm writing the followup to my initial question about synchronization complexity.
I'd like to start with this link to a summary of the synchronization costs of nearly all of the framework. And I say nearly all because I noticed that at least three methods had a synchronization cost that overflowed a 64 bit signed integer. Assumming (and I think this is safe to do) that they only spilled into the negative regions, those three entries are
System.Windows.Forms.DataGridView.ProcessLeftKey(System.Windows.Forms.Keys)count 10,823,468,784,974,500,000 complexity 20.0
System.Windows.Forms.DataGridView.ProcessRightKey(System.Windows.Forms.Keys)count 10,823,468,784,974,500,000 complexity 20.0
System.Windows.Forms.Design.DataGridViewDesigner.Initialize(System.ComponentModel.IComponent)count 9,230,518,549,563,500,000 complexity 20.0
Those are in fact the answers to the problem I posted in the original article and if you patch up those three lines in the .txt file I provided you'll have all the costs for the framework.
But what does it mean?
Well first let me remind you what the formula is. If the count is 0 then the complexity is 0. If the count is non-zero then the complexity is 1+log(count) rounded to 1 digit. So a complexity of 20 means that there were 10^19 calls to Monitor.Enter in the complete calltree of the method in question. 10^19 is a huge huge number!
OK, so what does that mean?
Well I'll tell you first what it doesn't mean. It doesn't mean that if you call that method that you can expect 10^19 calls to Monitor.Enter. Remember this is looking at the complete call graph and on any given invocation you certainly don't take both sides of every branch, ever branch of every switch and so on. You'll get some narrow slice of that calltree.
OK great, so the static count isn't the actual observed count if you call it, so what can we learn from this? Well two things.
So what can you do with this? Well there are two realizations that I hope you agree with.
Food for thought.
*For the synchronization counts I disregarded the one-time synchronizations present in the String class because they totally skew the truth and they do happen exactly once. One-time costs are the bane of static analysis