Parallelism Tools –
Checking for Memory Access
Violations    1

Activity 1 - Choose, Build and Run
a project    1

Activity 2 - Configure and Run
Analysis    8

Activity 3 - Manage result data
after analysis    12

Activity 1 – Choose, Build and Run a Project

The
application is a 2-D ray tracer/renderer called tachyon written in C++.
The code is small enough that you may be able to identify potential memory
access violations by visual inspection. If you identify and make a list of
problems, check your list with the list that Parallel Inspector XE identifies.

Choose a project

1. With
   Windows Explorer*, locate the samples folder in the Parallel
   Inspector XE directory.


2. From the
   Microsoft Visual Studio* menu, choose File > Open >
   Project/Solution.


3. In the Open Project dialog box, open
   the filesamples\windows\tachyon_insp_xe\vc8\tachyon_insp_xe.sln fileby double-clicking it.

   This
   should now display tachyon_insp_xe solution in the
   Solution Explorer.

1. In the
   Solution Explorer, right-click the
   find_and_fix_memory_errors project and choose Set as
   Startup Project from among the menu options.

Build a project

1. We first
   need to verify debug mode is configured to produce the best results. So in the
   Solution Explorer, right-click the
   find_and_fix_memory_errors project and choose
   Properties to display the Property Pages
   dialog box.


2. Verify
   the Configuration drop-down list is set to
   Debug or Active(Debug).

   

1. In the left pane, choose Configuration
   Properties > C/C++ > General.


2. Verify the Debug Information
   Format is set to Program Database (/Zi) or
   Program Database for Edit & Continue (/ZI).

   



3. In the left pane, choose Configuration
   Properties > C/C++ > Optimization.


4. Verify the Optimization
   field is set to Disabled (/Od).

   



5. In the left pane, choose Configuration
   Properties > C/C++ > Code Generation.


6. Verify the Runtime Library
   field is set to Multi-threaded DLL (/MD) or
   Multi-threaded Debug DLL (/MDd).

   



7. In the
   left pane, choose Configuration Properties > Linker >
   Debugging.


8. Verify the Generate Debug
   Info field is set to Yes (/DEBUG).

   



9. Verify
   the project is set to build in debug mode. Click the Configuration
   Manager button and verify the Active solution
   configuration drop-down list is set to Debug.

   



10. Click the Close button to
    close the Configuration Manager dialog box.


11. Click the OK button to close
    the Property Pages dialog box.

Run a project

1. From the Visual Studio* menu, choose
   Debug > Start Without Debugging.


2. When the Visual Studio* IDE responds this
   project is out of date, click Yes to build the project.


3. The application is run but the application
   output window will be empty and grey because of memory errors in the code!


4. You verified the find_and_fix_memory_errors
   project is set to produce the most accurate, complete results, compiled and
   linked the project and ensured the resulting find_and_fix_memory_errors.exe
   file runs on your system outside the Inspector XE.

Activity 2 – Configure and Run analysis

1. After you finish experimenting, ensure your
   Analysis Type window resembles the following window:

   



2. You
   chose a preset analysis type of intermediate scope to detect memory errors in
   the find_and_fix_memory_errors.exe file.

Run
a memory error analysis

1. Click
   the Analyze button on the Analysis Type
   window to:

• Execute
  the find_and_fix_memory_errors.exe file.


• Identify
  memory errors that may need handling.


• Collect
  the result in a folder in the tachyon_insp_xe\vc8\My Inspector XE 2011
  Project - find_and_fix_memory_errors folder.


• Finalize
  the result (convert symbol information into filenames and line numbers,
  perform duplicate elimination, and form problem sets).

1. During
   collection, the Inspector XE displays a Collection Log window
   similar to the following:

Activity 3 – Manage result data after analysis

After
analysis (both collection and finalization) completes successfully, the
Inspector XE displays the Summary window:

Choose
Problem Set

Start
exploring a memory error.

    Interpret
the Summary window

Choose
a problem set

Double-click the data row for the
Mismatched allocation/deallocation problem set source file to
display the Sources window, which provides more visibility into
the error:

Interpret
Result Data

In
this section, we will see how to determine the cause of the detected memory
error.

To
interpret the Sources window:

To
interpret window icons:

To
understand the issue:

Look at the code in the Focus Observation
Code pane and the Related Observation Code pane.

The code in the Allocation site
observation in the Related Observation Code pane contains a new
allocator, while the code in the Mismatched deallocation site
observation in the Focus Observation Code pane contains a free() deallocator.

A Mismatched
allocation/deallocation problem occurs when you attempt a deallocation
with a function that is not the logical reflection of the allocator. In the C++
programming language, the following are matched reflections:

• newanddelete


• new[]anddelete[]


• malloc()andfree()

Only the matching deallocation technique is
uniquely aware of all the memory allocation techniques and internal data storage
used by the allocation technique. Using the wrong deallocation technique will
almost certainly corrupt memory reclamation, its sole job.

Activity 4 – Resolve, Rebuild and Rerun

Resolve
an issue:

1. Double-click the
   highlighted code in the Focus Observation Code pane to open
   the find_and_fix_memory_errors.cpp source file in a separate tab where you can
   edit it with the Visual Studio* editor:

1. Comment
   free(drawing);and uncomment//delete
   drawing;:

1. Click
   the r000mi2 tab to redisplay the Sources
   window:

1. Click
   the Summary button to redisplay the Summary
   window:

Resolve
another issue:

Now resolve another detected memory error by
following the below steps:

Chooseanother problem
set:

In the Problem Sets pane on the
Summary window, double-click the data row for a Memory
Leak problem set to display the Sources window:

To access more information on
interpreting and resolving problems:

1. Right-click the
   Allocation site observation in the Observations in
   Problem Set pane.


2. Choose
   Explain Problem to display Inspector XE Help information for
   the Memory Leak problem type.

To interpret result data:

A Memory leak problem occurs
when a block of memory is allocated and never released.

The Allocation site observation
represents the location from which the memory block was allocated. Here, the
source code shows a malloc()
allocator.

Scroll the source code to near line 180:

The issue is obvious: The free()
call that releases the memory allocated by the malloc()
call is commented out.

To resolve memory leak problems (while avoiding
related mismatched allocation/deallocation problems): Match anymalloc()call
with afree()call,
anewwith adelete, and
anew[]with adelete[]as
soon as all use of the allocated space has occurred, but not sooner. Never mix
and match.

Be aware:

• If you
  do not deallocate soon enough, you waste space the program might need.


• If you
  deallocate too soon, you may do one of the following:
  • Corrupt your
    memory allocator or the space it manages when you later write to that space.
  
  
  • End up
    with bogus data if you later read that space when you previously returned it
    to the memory allocator.


• Make
  sure you free any space allocated within a function prior to exiting that
  function, or else make sure the function caller does the deallocation for the
  called function.

To resolve the issue:

1. Click
   the find_and_fix_memory_errors.cpp tab to redisplay the
   find_and_fix_memory_errors.cpp source file in the Visual Studio*
   editor:

1. Uncomment//free(local_mbox);:

1. Click
   the r000mi2 tab to redisplay the Sources
   window:

Rebuild
and Rerun Analysis

To see if
your edits resolved the memory errors:

• Rebuild
  the project with your edited source code.


• Run
  another analysis.


• Start
  managing result data after collection.

To
rebuild the project:

1. Right-click the
   find_and_fix_memory_errors project in the Solution
   Explorer.


2. Choose Build.

To
run another analysis:

From the
Visual Studio* menu, choose Tools > Intel Inspector
XE 2011 > Analyze As... > Memory Error
Analysis / Detect Memory Problems to run another analysis of the same
analysis type:

Notice the
image now displays.

To
start managing result data after collection:

After
analysis (both collection and finalization) completes successfully, the
Inspector XE displays the Summary window:

Notice the
Inspector XE:

• Created
  a new result tab.


• No
  longer detected Mismatched allocation/deallocation and
  Memory leak problems.