Erg Advisor	Frame Advisor
Available Investigations	Findings relevant to individual ergs	Findings relevant to the frame in general
What is shown	Findings across investigations for the currently selected ergs	Findings for all ergs, regardless of the current selection
What is displayed	Investigations that have found something for the current selection	All investigations regardless of whether something was found or not
Accessing the tool	Accessed via the tab group, and behaves in an erg-centric fashion, much like the other tabs	Accessed from the Intel GPA Frame Analyzer menu

1. Open the "Erg Advisor" tab.
2. Select one or more ergs that you want to analyze.

• an increase in the complexity of GPU's, so that users have requested "hints" from Intel GPA as to what parts of their graphics code are good candidates for analysis and optimization
• an increase in customers wanting to analyze their games on configurations with smaller memory and compute resources, such as tablets and notebooks
• game developers have been switching to Microsoft Windows 7* as their primary development OS

• The addition of two new analytical tools within Intel GPA Frame Analyzer, Frame Advisor (beta) and Erg Advisor (beta). These tools automate the process of finding the most likely causes of performance issues within a frame, such as ergs which have an excessive amount of occluded geometry. This is probably the "best" feature of this latest version of Intel GPA! For detailed information about these tools, see this article.
• The addition of a "new" tool, Intel GPA System Analyzer, which functions similar to the Intel GPA System Analyzer HUD, but this version of the tool runs in a client/server mode and supports additional charting options. This is useful for analyzing netbooks and other computers with limited resources, when you want to analyze system performance in a multiple-monitor setup on a single machine, or when you need access to more than four metrics at one time. By the way, users of GPA 2.x and 3.x may recognize this tool -- it's a "supercharged" version of the "old" Intel GPA System Analyzer!
• All tools now support the Microsoft DirectX* 9 Ex API (in addition to DirectX* 9, DirectX* 10, DirectX* 10.1, and DirectX* 11). This will help Windows XP* users transition to Windows 7*.

• Support for Microsoft DirectX9Ex*

Intel® GPA Monitor

• Ability to launch Intel® GPA Frame Analyzer, Intel® GPA Platform Analyzer and Intel® System Analyzer tools from the Intel® GPA Monitor tool tray menu.
• Ability to detect the Intel graphics driver version and notify the user when a newer driver is available.

Intel® GPA Frame Analyzer

• New Erg Advisor (Beta) and Frame Advisor (Beta) functionality, helping you find potential issues in the selected ergs and in the entire frame
• Ability to enter (X, Y) coordinates and get the pixel history for that location in the Render Target View and Pixel History Tab
• Metrics descriptions added to Frame Overview and Details tabs
• Ability to reset View Selection, Metric Selections settings in the Scene Overview Panel, and  X-Axis/Y-Axis settings in the Erg Visualization Panel to the default via the Edit menu > Reset Metric Selections.
• Ability to filter the API Details by the erg number or the erg ID.
• Ability to filter the API Details on the ergs that are selected in the Ergs Visualization Panel and in the Scene Overview Panel.
• Ability to display one or more ergs, which are selected in the API Details dialog box, in the Ergs Visualization Panel.
• DirectCompute ergs are color-coded in the Erg Visualization Panel

• Ability to show/hide Logical Threads
• Task states displayed in the Task Timeline panel; this enables you to see when instrumented tasks are actually running on a CPU core or are suspended

• Similar to the Intel GPA System Analyzer HUD, but analyzes your application using a client/server mode (which is important especially for netbooks)
• Minimized performance impact on the application
• More detailed metrics resolution
• Ability to view more than four metrics at the same time
• Ability to compare several metrics by displaying them in the same chart

• New tool for performance analysis of Intel® HD Graphics 3000/2000 accelerated media applications
• Ability to create media performance trace capture files for visualization and detailed analysis in the Intel® GPA Platform Analyzer
• Capture trace files provide a system-wide picture of how your code works with Intel® Media SDK and Microsoft* DXVA2 and how media-related workloads execute on the GPU.

• Capitalize on OpenCL support for CPU analysis tasks

• Ability to analyze CPU and GPU workloads enabled by Microsoft* Internet Explorer* 9, Mozilla* Firefox* 4, and Google* Chrome*

Intel® GPA Monitor

• Ability to track media metrics (GPU utilization with break-down to GPU engines and types of media operations) in real-time while running your application

Intel® GPA System Analyzer HUD

• Ability to change which D3D device for the instrumented process is being used to collect metrics, while your graphics application works with multiple D3D devices
• Ability to create Intel® Graphic Checker data capture files for further analysis with the Intel® Graphics Checker software assessment tool; the Intel Graphic Checker generates a Tool Report File that you can upload to the Intel® Software Partner Program website for access to a customized Software Assessment Report, plus several development and marketing resources designed to increase the visibility of your gaming title

Intel® GPA Frame Analyzer

• Added Recently-Used File list to the menu
• Display Depth Buffers (on the bubble)
• Pixel History query enabled in tab
• Menu option to disable the variance display in Details tab
• Copy to clipboard support added to tree lists (CTRL+C only)
• Export render target bitmap (right-click on frame buffers or textures)
• Enhanced API log details (accessible via the menu)
• Implemented the Show All Render Targets option in the Render Target Viewer panel, in order to display all the render targets in the frame no matter which ergs are selected

Intel® GPA Platform Analyzer

• Hardware tracks and tasks support: one track for each logical CPU core is added to the Task Timeline panel, displaying state information on the tasks running on each logical core
• Task states displayed in the Task Timeline panel; this enables you to see when instrumented tasks are actually running on a CPU core or are suspended
• A new track containing task groups added to the Task Timeline panel, enabling you to see time spans occupied by each task group
• New toolbar buttons for important operations
• Trace Information dialog box providing information on the trace file including task and task group counts, and system information from the environment where the trace file was collected including graphics driver version, operating system, and a preview image taken when the trace data was collected (when applicable)
• Track hiding and reordering: drag the tracks up and down to reorder them, remove unneeded tracks from the Task Timeline
• Movable panels from multiple loaded files: you can tear off panels from different loaded files and arrange them side by side for easy comparison
• Tabbed multi-document manager enabling you to quickly switch among multiple loaded files
• Ability to open and interact with large trace files (up to 1GB in size)

If you're a game developer, Intel has some great tools to help make your game "best in class"!

Intel Graphics Checker 3.0 now works together with Intel® Graphics Performance Analyzers (Intel® GPA) to help you quickly create an Intel® GPA data capture file and generate a game playability report that can be uploaded to start engaging with the Intel® Software Partner Program.

The benefits are that you will better understand the playability of your game on PCs with Intel® Graphics, access tips and tools to improve your game’s acceptance in the marketplace, and access resources that can broaden the worldwide audience for your game.

If you're already familiar with the tool and want to download the latest version now, you can get it here.

What's New

• Analysis of a special data capture file generated by Intel GPA that contains approximately 600 frames of graphics data.
• Creates an updated game playability report containing key hardware and software configuration details, plus frames per second, CPU utilization, and GPU utilization metrics.
• Ability to upload a game playability report to the Intel Software Partner Program website and access an updated, customized Software Assessment Report that compares game playability results to Intel-suggested values, provides recommendations and next steps, and displays a Software Assessment History.

Getting Started

• Download Intel GPA from this site.
• Download Intel Graphics Checker from here and install on the same PC that contains Intel GPA.
• After launching your game using the Intel GPA Monitor, use the Intel GPA System Analyzer HUD keyboard shortcut (the default is Ctrl-Shift-B) to capture approximately 600 frames of graphics data into a Intel Graphics Checker data capture file.
• After capturing an Intel® Graphics Checker data file using the Intel® GPA System Analyzer HUD keyboard shortcut, launch Intel Graphics Checker and follow the on-screen instructions to analyze the data capture and view results such as can be seen in the following example report:
  

• Your Intel Graphics Checker report can then be uploaded to the Intel Software Partner Program website, to access a customized Software Assessment Report that compares game playability results to Intel-suggested values, provides recommendations and next steps, and displays a software assessment history, such as seen here (click on the image to download a sample report in PDF format):
  

Where to Next...

If you are interested in improving your game’s playability, you’ve now got Intel GPA at your fingertips. Intel GPA is a powerful, agile tool suite enabling game developers to utilize the full performance potential of Intel® multi-core processors and Intel® processor graphics. If you are not already familiar with using Intel GPA to identify and solve game performance problems, the Getting Started Guide is an excellent place to dive in and…well, get started!

Also, there’s a couple of brief (2-3 minute) video tutorials showing how Intel GPA and Intel Graphics Checker work together: Creating an Intel Graphics Checker Data File and Analyzing an Intel Graphics Checker Data File.

To learn more about Intel® Graphics Checker, visit the Intel® Software Partner Program Software Assessment Center. If your company is not already a member, join today – enrollment is free and takes only a few minutes. In addition to valuable development resources, members can access business resources designed to increase their product visibility with a worldwide audience.

25th IEEE International Parallel & Distributed Processing Symposium

Intel Platinum Patron Night at IPDPS 2011 Intel Platinum Patron Night was a fantastic event, with a packed room of 170 attendees passionate about parallel programming in education. Watch the videos from Intel Platinum Patron Night to learn about using games to teach parallelism to undergraduates, recent innovations in design patterns, and hiring at Intel! Download the Intel Platinum Patron Night Presentation (pdf).   Opening Remarks Rowena Turner (Intel Corporation) View video Design Patterns in Practice and Teaching Michael Wrinn (Intel Corporation View video How to Use Games to Teach Parallelism to Undergraduates Ashish Amresh (Arizona State University at Polytechnic Campus) Amit Jindal (Intel Corporation) View video Choosing a Future Career at Intel Corporation Dani Napier (Intel Corporation) Lauren Dankiewicz (Intel Corporation) View video

The 1st NSF/TCPP Workshop on Parallel and Distributed Computing Education (EduPar-11) The Intel Academic Community and NSF are supporting the IEEE Computer Society Technical Committee on Parallel Processing (NSF/TCPP). NSF/TCPP is working to create a core curriculum for CS/CE undergraduates for parallel and distributed computing (PDC). The 1st workshop invited proposals from academia, industry, and other educational and research institutes to present on teaching PDC topics in undergraduate Computer Science and Engineering curriculum. Topics included: 1. Pedagogical issues in PDC 2. Novel ways of teaching PDC topics 3. Models for incorporating PDC topics in core CS/CE curriculum 4. Experience with incorporating PDC topics into core CS/CE courses. The Challenge of Teaching Program Performance Tuning David Padua (University of Illinois, Urbana-Champaign) View video NSF/TCPP Curriculum Report and Panel Discussion Coordinator: Sushil Prasad (Georgia State) Committee members and Panelists: Chtchelkanova, Almadena (NSF), Das, Sajal (University of Texas at Arlington, NSF), Das, Chita (Penn State, NSF), Dehne, Frank (Carleton University, Canada), Gouda, Mohamed (University of Texas, Austin, NSF), Gupta, Anshul (IBM T.J. Watson Research Center), Jaja, Joseph (University of Maryland), Kant, Krishna (NSF, Intel), La Salle, Anita (NSF), LeBlanc, Richard (Seattle University), Lumsdaine, Andrew (Indiana University), Padua, David (University of Illinois at Urbana-Champaign), Parashar, Manish (Rutgers, NSF), Patt, Yale (UT Austin), Prasad, Sushil (Georgia State University), Prasanna, Viktor (University of Southern California), Robert, Yves (INRIA, France), Rosenberg, Arnold (Colorado State University), Sahni, Sartaj (University of Florida), Shirazi, Behrooz (Washington State University), Sussman, Alan (University of Maryland), Weems, Chip (University of Massachusetts), and Wu, Jie (Temple University) View video Integrating Parallel and Distributed Computing Into Undergraduate Courses at All Levels Steven Bogaerts (Wittenberg University), Kyle Burke (Wittenberg University) and Eric Stahlberg (National Cancer Institute) View video Experiences of an Undergraduate Parallel Computing Course Bo Hong (Georgia Tech) View video Early Adopter: Integrating Concepts from Parallel and Distributed Computing into the Undergraduate Curriculum Eileen Kraemer (University of Georgia) View video Integration of Parallel Topics in the Undergraduate Curriculum, 2011 Joel Adams (Calvin College) View video ASU and Intel Collaboration in Parallel and Distributed Computation Violet Syrotiuk, Yinong Chen, Eric Kostelich, Yann-Hang Lee, Alex Mahalov and Gil Speyer (Arizona State) View video Parallel Computing: Keys to a Future in Computing Stephen Providence (Hampton University) View video Using Games to Teach Parallelism to Computer Science 2nd year and 3rd Year College Students Deepak Vembar and Amit Jindal (Intel) View video Teaching Parallel and Distributed Computing at Masaryk University Jiri Barnat, Lubos Brim and Ivana Cerna (Masaryk University, Czech Republic) View video Parallel Programming in the Computing Curriculum Ankur Gupta, Rahul Hardikar and Jon Sorenson (Butler University) View video PDC Modules for Every Level: A Comprehensive Model for Incorporating PDC Topics into the Existing Undergraduate Curriculum Konstantin Laufer, Chandra Sekharan and George K. Thiruvathukal (Loyola University Chicago) View video Teaching Parallel Computing to Lower-Division Undergraduates Peter Pacheco (University of San Francisco) View video Joint UIUC/UMD Parallel Algorithms/Programming Course David Padua (Urbana), Uzi Vishkin (Maryland) and Jeffrey Carver (University of Alabama) View video

Architecting Parallel Software: Design patterns in practice and teaching Design patterns can systematically identify reusable elements in software engineering, and have been particularly effective in codifying practice in object-oriented software. A team of researchers centered at UC Berkeley’s Parallel Computing Laboratory continues to investigate a design pattern approach to parallel software; the effort has matured to the point that an undergraduate course was delivered on the topic in Fall 2010. This talk will briefly describe the pattern language itself, then demonstrate its application in examples from both image processing and game design.

Michael Wrinn manages Intel's Innovative Software Education team, which collaborates with universities to bring parallel computing to the mainstream of undergraduate education. His prior assignments include managing Intel's software engineering lab in Shanghai, and directing the human interface technology research. He was Intel's representative to the committee which produced the first OpenMP specification, and remains active in the parallel computing community. Before joining Intel, Michael worked at Accelrys (San Diego), implementing commercial and research simulation codes on a wide variety of parallel/HPC systems. He holds a Ph.D. (in quantum mechanics) and a B.Sc.(math/chemistry/physics) from McGill University.

Teaching Parallelism Using Games Academic institutions do not have to spend expensive multi-core hardware to support game-based courses to teach parallelism.   We will discuss what teaching methodologies educators can use for integrating parallel computing curriculum inside a game engine. We will talk about the full game development process, from game design to game engineering and how parallelism is critical.   We will show five game demos that mirror current trends in the industry and how educators can use in these games in the classroom. We will also show the learning outcomes, what parallelism topics are appropriate to teach students at various levels.  We will demonstrate how to take games running serially and modify them to run parallel.

Ashish Amresh leads the Computer Gaming curriculum initiatives at the School of Computing and Informatics at Arizona State University. He completed his MS in computer science from ASU in 2000, then worked in the video game industry as a graphics engineer programmer, and returned to ASU to work on his doctorate in computer science. While working on his doctoral degree, Amresh led the efforts in building the prototype that eventually resulted in the launching of the Decision Theatre at ASU in May 2005. In the same year he was awarded the Graduate College Teaching Excellence Award.

An Intel veteran of 11 years, Amit Jindal is a Performance Lead at Intel's Digital Home Group, enabling high-performance of Intel-powered Smart TVs. Prior to this role, Amit was involved with performance optimization of large-scale enterprise applications (primarily SAP). Amit started his career at Intel in 2000 as an automation engineer developing, simulating, and optimizing performance of automation in Intel factories. Amit has been a threading/ parallelism evangelist since 2005, teaching courses for Intel Academic Program, serving as panelist in academic conferences, and working with Universities in setting their curriculums. Amit holds an MBA Degree in Global Management, and MS Degree in Computer Science.

Choosing a Future Career at Intel Intel's Dani Napier will introduce why Intel is a great place to work-- it's challenging, has great benefits and is abundant with rewarding growth opportunities. She will expand on why parallelism is crucial to Intel's growth strategy and give an overview of the various types of jobs in which knowledge of parallel and distributed processing apply at Intel. Finally, Dani will explain the new hire development process and why Intel is the company that will help you become successful in your desired career path. Lauren Dankiewicz will discuss the recruiting process and how to approach finding a job that is the right fit for you!

Hi, there! My name is Dani. I've been with Intel for almost 14 years, mostly in Chandler, Arizona. I started out as an intern in New Mexico's fabs. Then I was hired into a full-time job and have held a variety of engineering and business roles ever since. When I first started as an Intel engineer I wished I had done three things: 1) I wish I would've taken a couple of business courses 2) I wish I would've taken more stats courses, and 3) I wish I would've learned to give presentations more effectively. All these things I eventually learned at Intel through all the coursework they have in place for employees. I can tell you that in my entire career I have never stopped learning, either from coursework or from brilliant peers.

Lauren Dankiewicz joined Intel in April 2011 as a Recent College Graduate (RCG). At Intel, she is a marketing manager in the Academic Community. Lauren graduated from University of California, Berkeley in 2009 with a B.A. in Chinese Language (Mandarin) and B.S. in Business Administration. She is now pursuing a Master's degree in Computer Science.

Using Games to Teach Parallelism to Undergraduates- Presentation at the NSF/TCPP Workshop on Parallel and Distributed Computing Education (EduPar-11) The Visual Computing Software Enabling (VCSE) group at Intel has developed some exciting game demos that are ideal for teaching the basic tenets of parallelism, including data and task decomposition, scheduling techniques, and software architecture. These demos are designed for an audience ranging from 2nd to 4th year, while retaining the emphasis on hands-on, laboratory instruction. Intel’s faculty collaborators have liked this approach, as today’s students are familiar with multi-media and rich visualization, and games act as immediately likable and interesting delivery vehicles for learning these important parallelism concepts. We have two primary objectives: update undergraduate curriculum with a laboratory-based 2nd year course on parallel computation, and introduce some of the parallelism concepts and profiling tools used in the industry. This approach will help students adopt a “think parallel” mentality early and to see the importance of using profiling tools to develop correct and high-performance code for greater effectiveness. Further, we will share methodologies that improve student understanding of the basic principles of parallel computing.

Deepak Vembar is an Engineer at Intel where he focuses on developing and optimizing graphics and game technologies on Intel hardware. Prior to joining Intel, Deepak was a graduate student at Clemson University and received his Master's and PhD degrees in Computer Science.

An Intel veteran of 11 years, Amit Jindal is a Performance Lead at Intel's Digital Home Group, enabling high-performance of Intel-powered Smart TVs. Prior to this role, Amit was involved with performance optimization of large-scale enterprise applications (primarily SAP). Amit started his career at Intel in 2000 as an automation engineer developing, simulating, and optimizing performance of automation in Intel factories. Amit has been a threading/ parallelism evangelist since 2005, teaching courses for Intel Academic Program, serving as panelist in academic conferences, and working with Universities in setting their curriculums. Amit holds an MBA Degree in Global Management, and MS Degree in Computer Science.

Programmers, meet a new tool to search for errors in source code of software written in C/C++. Within the scope of the PVS-Studio analyzer, we implemented a new set of general-purpose rules. This functionality is free for now. You may download PVS-Studio here http://www.viva64.com/en/pvs-studio-download/.

The article briefly describes new features of PVS-Studio and demonstrates the usage of new diagnostic capabilities with the example of static analysis of the TortoiseSVN project's source code.

PVS-Studio is a state-of-the-art source code analyzer integrated into Microsoft Visual Studio 2005/2008/2010 environment. The analyzer lets you conveniently handle the warning list and enables multi-core processing for analysis. PVS-Studio is meant for developers of modern Windows-software in C/C++/C++0x.

Until now, PVS-Studio included two rule sets. The first was intended for detecting issues in 64-bit software while the second was intended for detecting issues in parallel software based on the OpenMP technology.

Now our analyzer has a third universal set of rules that allows detecting various errors in code. This rule set is free and may be used without any restrictions. We cannot say whether this set will become paid or not in future since we are only starting our way in the sphere of general-purpose static analysis.

Currently you may study the new set of rules by downloading PVS-Studio 4.00 BETA. We will be glad to receive feedback from you concerning bugs and your wishes of how we could improve the tool. I would like to note it right away that we implemented only 50 general-purpose rules for a start. It is not too much, so if you fail to find any interesting issues in your code after you have downloaded and tried PVS-Studio, please do not jump to conclusions. We suggest that you try PVS-Studio in future when the set of diagnoses is greatly extended. We intend to significantly enlarge the base of diagnostic rules soon (if we have enough health and luck).

Let us demonstrate the use of PVS-Studio's new rule set by the example of TortoiseSVN. TortoiseSVN is a client for the Subversion version control system implemented as a Windows plugin. TortoiseSVN is well known by many developers, so I think there is no need to describe this application in detail. I only want to note that TortoiseSVN was acknowledged as the best project in the category "tools and utilities for developers" in year 2007 on SourceForge.net.

Step 1

Download PVS-Studio from OOO "Program Verification Systems" company's site (that's us). I hope you will appreciate that you do not have to fill in any forms or solve captchas. Simply download the tool.

Step 2

Install PVS-Studio. Do not hesitate to click the "Next" button because you do not have to set anything. The PVS-Studio package is signed with a digital signature. However, some antiviruses might get alerted about integration of PVS-Studio into Visual Studio. So you should allow any activity if asked by your antivirus.

Step 3

Download the package of source code of the TortoiseSVN project. We employed version 1.6.11 of source code.

Step 4

Open the TortoiseSVN project and launch the analysis by choosing the Check Solution command in the PVS-Studio menu.

Step 5

The analyzer will think a bit (the TortoiseSVN project is rather complex and includes a lot of files), so do not perform any actions and just wait for a while. The progress dialogue will appear soon and the analysis will start. The analysis' speed depends upon the number of processor cores in your computer. If PVS-Studio consumes too many resources, you may restrain its appetite in the settings.

The analyzer generates messages in its own window that has controls for enabling/disabling different types of messages. We will use these capabilities because we are not interested in a large number of errors related to 64 bits now. Besides, the 64-bit analysis module is charged and therefore is shipped in the trial mode (for more detailed information about the trial mode, go here).

In the window, you may see a group of three buttons responsible for displaying messages of the three rule sets.

1) 64 is responsible for displaying diagnostic messages about 64-bit issues (Viva64);

2) MP shows diagnostic messages about parallel defects (VivaMP);

3) GA shows the General Analysis diagnostic messages.

Now we are interested only in the general analysis rule set. Uncheck the other buttons and the unnecessary messages will be also hidden in the list.

Wait for the analysis to finish.

Step 6

Analysis is over and we may see the list of all the fragments in the program where code review is necessary.

All the warnings are arranged according to 3 priority levels (this is a new feature in PVS-Studio 4.00). Usually you have to review only messages of the 1-st and 2-nd levels. PVS-Studio 4.00 BETA generated 33 warnings of the 1-st level, 14 warnings of the 2-nd level and 8 warnings of the 3-rd level.

You'd better start examining the messages with the first level warnings. So you may uncheck the button responsible for displaying messages of the second level. The third level is disabled by default.

Step 7

Let's examine interesting code fragments the analyzer has found.

Case 1

In the beginning, there are two messages at once that refer to the same function. I hope that this function is not used too often in the code.

V530 The return value of function 'empty' is required to be utilized. contextmenu.cpp 434

V530 The return value of function 'remove' is required to be utilized. contextmenu.cpp 442

STDMETHODIMP CShellExt::Initialize(....)
{
  ...
  ignoredprops.empty();
  for (int p=0; p<props.GetCount(); ++p)
  {
    if (props.GetItemName(p).
          compare(SVN_PROP_IGNORE)==0)
    {
      std::string st = props.GetItemValue(p);
      ignoredprops = UTF8ToWide(st.c_str());
      // remove all escape chars ('\\')
      std::remove(ignoredprops.begin(),
                  ignoredprops.end(), '\\');
      break;
    }
  }
  ...
}

Here and further we will give only brief comments on code fragments. To learn more why these code fragments are considered unsafe, refer to PVS-Studio's online-documentation (in Russian or English). The PVS-Studio distribution package also includes documentation in the pdf format (it is absolutely the same as the online-documentation). Further we will give links to the corresponding descriptions of the diagnostic messages.

The V530 message warns us that "ignoredprops.empty()" does not clear the string at all while "std::remove()" will never remove the characters.

Case 2

Here it is checked whether a variable of the 'char' type is above or equal to value 0x80.

V547 Expression 'c >= 0x80' is always false. The value range of signed char type: [-128, 127]. pathutils.cpp 559

CString CPathUtils::PathUnescape (const char* path)
{
  // try quick path
  size_t i = 0;
  for (; char c = path[i]; ++i)
    if ((c >= 0x80) || (c == '%'))
    {
      // quick path does not work for
      // non-latin or escaped chars
      std::string utf8Path (path);
      CPathUtils::Unescape (&utf8Path[0]);
      return CUnicodeUtils::UTF8ToUTF16 (utf8Path);
    }
  ...
}

The V547 message tells you that such a check is meaningless. A 'char'-value is always below 0x80, so the condition above is always false. Perhaps it is because of this error that developers left the comment "quick path does not work for non-latin or escaped chars". Surely it does not, but not because of the code failing to convert the string: when it encounters a non-latin character, we simply cannot get inside the 'if' operator's body.

Case 3

Many threads are spawned and terminated by functions CreateThread/ExitThread. Therefore we risk quickly overflowing a thread's stack or failing to release some resources when a thread is terminated. For more information, refer to the V513 warning's description. It is much safer to use functions _beginthreadex() and _endthreadex() for these purposes.

There is no need to give the code sample here, and the text of all the messages is the same:

V513 Use _beginthreadex/_endthreadex functions instead of CreateThread/ExitThread functions. crashhandler.cpp 379

Case 4

It refers to TortoiseSVN companion utilities. It is highly probable that when you handle CrashLog, you will encounter another Crash.

V510 The 'printf_s' function is not expected to receive class-type variable as fourth actual argument. excprpt.cpp 199

string CExceptionReport::getCrashLog()
{
  ...
  _tprintf_s(buf, _T("%s\\%s.xml"),
  getenv("TEMP"), CUtility::getAppName());
  ...
}

The V510 message warns you that it is a bad thing to pass an argument of the std::string type into the printf_s function. But it is std::string that the CUtility::getAppName() function returns. The error here is that the programmer forgot to write ".c_str()". This may result either in an incorrect data output or program crash.

Case 5

The developers intended to clear an array here but failed.

V530 The return value of function 'empty' is required to be utilized. mailmsg.cpp 40

CMailMsg& CMailMsg::SetFrom(string sAddress,
                            string sName)
{
   if (initIfNeeded())
   {
      // only one sender allowed
      if (m_from.size())
         m_from.empty();
      m_from.push_back(TStrStrPair(sAddress,sName));
   }
   return *this;
}

Again, the V530 message tells us that it is "empty()" which is accidentally written instead of "clear()".

Case 6

In the SetTo() function, the developers also failed to clear an array.

V530 The return value of function 'empty' is required to be utilized. mailmsg.cpp 54

CMailMsg& CMailMsg::SetTo(string sAddress,
                          string sName)
{
   if (initIfNeeded())
   {
      // only one recipient allowed
      if (m_to.size())
         m_to.empty();

      m_to.push_back(TStrStrPair(sAddress,sName));
   }
   return *this;
}

Case 7

Of course the analyzer generates false alarms as well. For instance, this code fragment from the zlib library is included into the TortoiseSVN project. There is no error here but it is rather helpful to mark such a fragment with the V501 warning.

V501 There are identical sub-expressions to the left and to the right of the '-' operator: size - size zutil.c 213

voidpf zcalloc (opaque, items, size)
    voidpf opaque;
    unsigned items;
    unsigned size;
{
  /* make compiler happy */
  if (opaque) items += size - size;
  return (voidpf)calloc(items, size);
}

Of course the compiler feels happy here, but the subtraction operation looks suspicious.

Case 8

There are other grey areas concerning encodings. Here is one more condition which is always false.

V547 Expression '* utf8CheckBuf >= 0xF5' is always false. The value range of signed char type: [-128, 127]. tortoiseblame.cpp 312

BOOL TortoiseBlame::OpenFile(const TCHAR *fileName)
{
  ...
  // check each line for illegal utf8 sequences.
  // If one is found, we treat
  // the file as ASCII, otherwise we assume
  // an UTF8 file.
  char * utf8CheckBuf = lineptr;
  while ((bUTF8)&&(*utf8CheckBuf))
  {
    if ((*utf8CheckBuf == 0xC0)||
        (*utf8CheckBuf == 0xC1)||
        (*utf8CheckBuf >= 0xF5))
    {
      bUTF8 = false;
      break;
    }

   ...
  }

By the way, conditions "*utf8CheckBuf == 0xC0" and "*utf8CheckBuf == 0xC1" are always false too. That is why the code "bUTF8 = false;" will never get control. The fact that the PVS-Studio analyzer kept silent about the "*utf8CheckBuf == 0xC0" expression is its drawback. We have noted it and will make the analyzer to scold this issue in the next version.

Case 9

The next message is not so simple: in theory we have an error but in practice everything works well.

V507 Pointer to local array 'stringbuf' is stored outside the scope of this array. Such a pointer will become invalid. mainwindow.cpp 277

LRESULT CALLBACK CMainWindow::WinMsgHandler(....)
{
  ...
  if (pNMHDR->code == TTN_GETDISPINFO)
  {
    LPTOOLTIPTEXT lpttt;

    lpttt = (LPTOOLTIPTEXT) lParam;
    lpttt->hinst = hResource;

    // Specify the resource identifier of the
    // descriptive text for the given button.
    TCHAR stringbuf[MAX_PATH] = {0};
    ...
    lpttt->lpszText = stringbuf;
  }
  ...
}

The V507 message warns you that the object is being used after it has been destroyed. The 'stringbuf' buffer will be used after exiting the 'if' operator's body.

If 'stringbuf' was a class object (for instance, of std::string class), the code would behave incorrectly. We would use an already destroyed object in that case. But here 'stringbuf' is an array created in the stack. The Visual C++ compiler does not use this stack fragment once again, so the buffer will continue to exist until the 'CMainWindow::WinMsgHandler' function terminates. Thus, there is no error yet this code is potentially dangerous.

Case 10

Here is one more fragment like the previous one. Again we have code that works but it is rather fragile.

V507 Pointer to local array 'stringbuf' is stored outside the scope of this array. Such a pointer will become invalid. picwindow.cpp 443

if ((HWND)wParam == m_AlphaSlider.GetWindow())
{
  LPTOOLTIPTEXT lpttt;

  lpttt = (LPTOOLTIPTEXT) lParam;
  lpttt->hinst = hResource;
  TCHAR stringbuf[MAX_PATH] = {0};
  _stprintf_s(stringbuf, .....);
  lpttt->lpszText = stringbuf;
}

Case 11

It is a bad idea to throw exceptions and not to handle them in the destructor.

V509 The 'throw' operator inside the destructor should be placed within the try..catch block. Raising exception inside the destructor is illegal. cachefileoutbuffer.cpp 52

CCacheFileOutBuffer::~CCacheFileOutBuffer()
{
  if (IsOpen())
  {
    streamOffsets.push_back (GetFileSize());
    size_t lastOffset = streamOffsets[0];
    for (size_t i = 1,
         count = streamOffsets.size();
         i < count; ++i)
    {
      size_t offset = streamOffsets[i];
      size_t size = offset - lastOffset;

      if (size >= (DWORD)(-1))
        throw CStreamException("stream too large");

      Add ((DWORD)size);
      lastOffset = offset;
    }

    Add ((DWORD)(streamOffsets.size()-1));
  }
}

The V509 message warns you that if the CcacheFileOutBuffer object is destroyed while an exception is being handled, a new exception will cause a program crash.

Case 12

One more meaningless comparison.

V547 Expression 'endRevision < 0' is always false. Unsigned type value is never < 0. cachelogquery.cpp 999

typedef index_t revision_t;
...
void CCacheLogQuery::InternalLog (
   revision_t startRevision
 , revision_t endRevision
 , const CDictionaryBasedTempPath& startPath
 , int limit
 , const CLogOptions& options)
{
  ...
  // we cannot receive logs for rev < 0
  if (endRevision < 0)
    endRevision = 0;
  ...
}

There simply cannot be any negative values here. The endRevision variable has the unsigned type and therefore endRevision is always above or equal to 0. The potential issue here is that if a negative value has been cast to unsigned type somewhere earlier, we will start handling a very large number. This cannot be checked.

Case 13

There are no more useful messages of the first level. Well, for now. It is only the first step in trying PVS-Studio's capabilities. We intend to develop not fewer than 150 issues we must teach our tool to detect. I would like to thank once again those readers who responded to our previous articles and sent us samples where one can detect errors with the help of static analysis at the stage of writing the code.

Let's look at the second level. We found one interesting error related to using the Copy-Paste method. By the way, there was nothing interesting at the third level, so it is not for nothing that we disable it by default.

V524 It is odd that the 'GetDbgHelpVersion' function is fully equivalent to the 'GetImageHlpVersion' function (SymbolEngine.h, line 98). symbolengine.h 105

BOOL GetImageHlpVersion(DWORD &dwMS, DWORD &dwLS)
{
  return(GetInMemoryFileVersion(("DBGHELP.DLL"),
                                dwMS,
                                dwLS)) ;
}

BOOL GetDbgHelpVersion(DWORD &dwMS, DWORD &dwLS)
{
  return(GetInMemoryFileVersion(("DBGHELP.DLL"),
                                dwMS,
                                dwLS)) ;
}

The V524 message is generated if the analyzer finds two suspiciously similar functions. It is most likely that the first function must get the "imagehlp.dll" version of the file instead of "dbghelp.dll ".

Step 8

Now we must fix the errors we have found. This step is clear and we will skip it.

Concerning the errors found, we will report them to TortoiseSVN's developers.

Step 9

Now let's speak a bit about false alarms. Let me give you some examples to explain what false alarms are and how we can deal with them.

Here is the first false alarm: PVS-Studio did not understand the playing with the operation of memory copying.

V512 A call of the 'memcpy' function will lead to a buffer overflow or underflow. resmodule.cpp 838

const WORD*
CResModule::CountMemReplaceMenuExResource(....)
{
  ...
  if (newMenu != NULL) {
    CopyMemory(&newMenu[*wordcount], p0, 7 * sizeof(WORD));
  }
   ...
}

The V512 warning informs you that we have a buffer underflow or, vice versa, a buffer overflow. The analyzer made a mistake this time having suggested that we want to copy 7 objects but intend to handle only one object of the WORD type.

Here is the second false alarm. The analyzer suggests that we processed only a part of the array.

V512 A call of the 'memcmp' function will lead to a buffer overflow or underflow. sshsha.c 317

static int sha1_96_verify(....)
{
  unsigned char correct[20];
  sha1_do_hmac(handle, blk, len, seq, correct);
  return !memcmp(correct, blk + len, 12);
}

Right, it is only a part of the 'correct' array participating in the comparison operation but we made it intentionally.

The third example of a false alarm.

V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. tree234.c 195

static void *add234_internal(....)
{
  ...
  if ((c = t->cmp(e, n->elems[0])) < 0)
    childnum = 0;
  else if (c == 0)
    return n->elems[0]; /* already exists */
  else if (n->elems[1] == NULL
       || (c = t->cmp(e, n->elems[1])) < 0)
         childnum = 1;
  else if (c == 0)
    return n->elems[1]; /* already exists */
  else if (n->elems[2] == NULL
       || (c = t->cmp(e, n->elems[2])) < 0)
         childnum = 2;
  else if (c == 0)
    return n->elems[2]; /* already exists */
  else
    childnum = 3;
  ...
}

The analyzer does not like that the check 'c == 0' is present in code several times. The code is correct since the 'c' variable is changed inside the other conditions "c = t->cmp(e, n->elems[2])". But this situation is rather rare. Usually the V517 message points to real defects in code.

We will not consider all the rest of false alarms because there is nothing interesting about them. A programmer can easily understand that they are false alarms and he does not have to examine them too closely.

You may handle false alarms in several ways:

1) You may rewrite the code. Sometimes it is rather reasonable. Refactoring would be very helpful for the last sample with a false alarm (I mean the add234_internal function and warning V517).

2) You may disable some diagnoses in the settings which always produce false alarms in your projects. After you disable them, all the corresponding messages will disappear from the warning list. For more details, see "Settings: Detectable Errors".

3) If false alarms refer to code that does not need to be checked, you may exclude separate files or folders from analysis. You may also use masks. For details, see "Settings: Don't Check Files". This method is convenient for excluding third-party libraries from analysis.

4) You may use the mechanism of suppressing messages containing particular text. For details, see "Settings: Message Suppression".

5) There are cases when you should suppress a particular false alarm. Then you may use the "Mark as False Alarm" option. If you use it, the analyzer adds a small comment of the "//-Verror_code" kind into the code. You may hide code fragments marked with this comment by the FA button that enables or disables displaying the marked messages. For details, see: "False alarm suppression".

Thank you for your attention. Try PVS-Studio. Send us your feedback. Ask us questions. Give us your interesting samples. Offer new diagnostic rules we could implement.

Sincerely yours, Andrey Karpov, one of the PVS-Studio's developers.

You may contact us on page "Feedback".

Or by e-mail: support[@]viva64.com , karpov[@]viva64.com.

Write to us, we have a wonderful support service. It is me, the author of this article, who will personally participate in communication unlike most companies where you deal with some abstract human-robot.

Intel Academic Community at SIGCSE 2010.

Intel Academic Community was at SIGCSE 2010 in Milwaukee, Wisconsin on March 10-13, 2010. Dr. Michael Wrinn did the keynote address on Saturday, March 13, 2010:

 Here are some pictures of the Intel Booth at SIGCSE 2009:

Intel @ SIGCSE 2010 blogs:

• Subscribe to the Intel Academic Community blog RSS feed

Intel Academic Community Black Belts at SIGCSE 2010:

• Matthew Wolf, Georgia Tech University (Dr. Wolf's blog)
• Tom Murphy, Contra Costa College (Dr. Murphy's blog, @wolfmurphy on Twitter)

Call for Poster Participation, IDF 2009, San Francisco, California, USA

On September 22-24^th in San Francisco over 100 senior academic technologists from Parallel Computing, Multi-core Programming, Open Innovation and Collaborative Communities will get together at the Intel Developer Forum for an Academic Summit Track. This will be hosted by Pat Gelsinger, Executive Vice President of the Digital Enterprise Group, and Andrew Chien, Vice President of Research, Intel Labs, Vice President and Director of Future Technologies Research with responsibility for academic collaborations.

The Academic Track will feature a poster session on September 23^rd in the late afternoon . You are invited to submit a proposal to present your work at this poster session. The goal of the poster session will be to paint a comprehensive picture of what tools and methods are being used, some early results, and the main technological and business challenges in delivering new advanced topics in the academic environment, especially those related to:

• Parallel Computing
• Multi-core programming
• Collaborative Communities
• Open Innovation

We encourage you to send in your poster proposal to innovation@intel.com by August 11^th with the following information:

• Names of Poster Presenters
• Topic of the Poster
• Three key messages on the poster - What will the audience learn or be interested in hearing more about?
• Research findings
• Contact information

This is an invitation-only event and poster presenters will receive a complimentary pass to IDF that is valued at up to $1,595. Participants need to cover their own transportation and lodging to the event. For more information see www.intel.com/idf