Building with profiling enabled

For an existing project, when you build your project to profile an application to capture performance information, profiling can provide you with decision-making capabilities to help discover functions that consume the most CPU time. However, to instrument your code, you'll need to change the existing configuration options so that you can build your project with profiling enabled. The IDE will then insert code before each function to gather call information (Call Count instrumentation) or just after the function enters, and just before the function exits (Function Instrumentation).

To configure profiling for the selected project, depending on your type of project, do one of the following:

For a QNX C/C++ project:
1. In the Project Explorer view, right-click your project and select Properties.
2. In the left pane, select QNX C/C++ project.
3. In the right pane, select the Options tab.
4. Do one of the following:
  - Select Build for Profiling (Function Instrumentation) to enable Function Instrumentation mode.
  - Select Build for Profiling (Call Count Instrumentation) to enable Call Count mode.
5. Click OK.
6. When prompted, click Yes to rebuild your project.
For a managed project:
1. Right-click on a project and select Properties.
2. From the menu, select C/C++ Build > Settings > Tools settings .
3. Switch to the Profile configuration using the Manage Configurations button, or create a new configuration if one doesn't currently exist.
4. From the list on the right, for your compiler from the list, i.e. QCC Compiler, select an item from the list and select Output Control.
5. Do one of the following:
  - To enable Function Instrumentation mode, select the Build for Profiling (Function Instrumentation) option.
  - To enable Call Count Instrumentation mode, select the Enable call count profiling (-p) option.
6. From the list on the right, for your linker in the list (i.e. QCC Linker), select an item from the list, then select Output Control.
7. Do one of the following:
  - To enable Function Instrumentation mode, select the Build for Profiling (Function Instrumentation) (-lprofilingS) option.
  - To enable Call Count Instrumentation mode, select the Build for Profiling (Call Count) (-p) option.
8. Click OK.
9. Run a project Clean for your project, and then build the project.
For a Makefile:
- For Function Instrumentation:
  1. To compile the application or library with Function Instrumentation, add the option -finstrument-functions.
  2. For linking, add the argument -lprofilingS.
- For Call Count instrumentation, use the -p option for compiling and linking.
  Note:
  For example, your Makefile might have a line like this:
```
CFLAGS=-p CXXFLAGS=-p LDFLAGS=-p
```
  For a standard Makefile that uses default rules, your file would have the -finstrument-functions and -lprofilingS options for profiling, and it would look similar to this:
```
CFLAGS += -g -O0 -finstrument-functions 
LDLIBS += -lprofilingS
```
  If the Makefile doesn't use the default linking and compile rules, flags and/or library, for profiling you'll need to manually include the -finstrument-functions and -lprofilingS options as in the following example:
```
main.o 
       qcc -g -O0 -finstrument-functions -o main.o main.c
binary: 
       qcc -o binary main.o -lprofilingS
```
  For QNX recursive Makefiles, you would also have the -finstrument-functions and profilingS options, and the Makefile would look similar to the following:
```
CFLAGS += -g -O0 -finstrument-functions 
LIBS += profilingS
```
  The LIBS variable adds the list of libraries to include into the appropriate compiler options for profiling; you don't use LDFLAGS or LDOPTS to add libraries.
  
  Notice that in the examples above, the -l option appears at the end of each statement. This positioning occurs because qcc doesn't understand the -l option before source and objects files; it must appear at the end.
Note:
The QNX Application Profiler uses the information in the debuggable executables to correlate lines of code in your executable and the source code. To maximize the information you get while profiling, use executables with debug information for both running and debugging.