News

Archives

• June 2016 (1)
• May 2016 (1)
• April 2016 (1)
• March 2016 (2)
• February 2016 (2)
• January 2016 (1)
• November 2015 (1)
• September 2015 (1)
• August 2015 (3)
• July 2015 (1)
• June 2015 (1)
• April 2015 (1)
• March 2015 (2)
• January 2015 (1)
• December 2014 (3)
• October 2014 (2)
• September 2014 (3)
• June 2014 (1)
• April 2014 (2)
• March 2014 (1)
• February 2014 (4)
• January 2014 (3)
• December 2013 (2)
• November 2013 (2)
• August 2013 (3)
• July 2013 (1)
• June 2013 (2)
• January 2013 (1)
• December 2012 (6)
• November 2012 (2)
• October 2012 (2)
• July 2012 (1)
• June 2012 (1)
• May 2012 (1)
• April 2012 (1)
• March 2012 (1)
• December 2011 (3)
• September 2011 (1)
• August 2011 (4)
• July 2011 (1)
• June 2011 (2)
• March 2011 (1)
• November 2010 (1)
• July 2010 (3)
• June 2010 (5)
• May 2010 (2)
• April 2010 (1)
• March 2010 (2)
• February 2010 (1)
• December 2009 (1)
• November 2009 (1)
• October 2009 (2)
• September 2009 (1)
• June 2009 (1)
• May 2009 (2)
• December 2008 (3)
• November 2008 (1)
• May 2008 (1)
• April 2008 (2)
• January 2008 (1)
• November 2007 (1)
• February 2007 (1)
• January 2007 (1)
• October 2006 (1)
• September 2006 (1)
• August 2006 (1)
• July 2006 (1)
• June 2006 (2)
• May 2006 (4)
• April 2006 (3)
• March 2006 (1)
• February 2006 (3)
• January 2006 (3)
• December 2005 (2)
• November 2005 (1)

Image Galleries

• 

  September 2014 Entries

  Advanced Memory Dump Debugging

  One common thing while debugging is to search who owns/references a handle. For x86 processes you can simply search the full address space but in x64 this approach no longer works. While debugging a hang from a memory dump I did find out that the process MainWindowHandle did change to a different window which was not the main window handle. Searching for the values of NativeWindow objects did also lead to no trace on the managed heap so it must be some unmanaged window handle. First I look at the ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/fTd

  Posted On Monday, September 29, 2014 10:50 AM | Comments (0)
  
  
  Your Application The System And A Performance Bug

  When you have a performance bug you usually look at your code why something takes longer than expected. In conjunction with a debugger this is a great approach for easy bugs. Things get much harder if the issue only surfaces sporadically at customer sites. Application logging which is always on helps you to see that there was a problem but since logging must not flood the hard disc you cannot log every method call with all parameters like IntelliTrace tries to do. The next level is application tracing ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/fQZ

  Posted On Sunday, September 21, 2014 4:25 AM | Comments (0)
  
  
  Thread Contention Effects

  Recently I have seen an interesting performance question on SO which deals with Parallel.For in .NET. The code was basically Parallel.For(0,1000*1000*1000, i => {}); The actual work is simulated by an empty delegate which is an easy measure the overhead of Parallel.For. When you let this run on some multicore machines in x86 Release you get number like The running time is not constant as one might expect but sometimes there are slowdowns in the order of 6 times or more. With WPT is was quickly ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/fMr

  Posted On Sunday, September 14, 2014 10:22 AM | Comments (0)