PatternInstrumentation::PatternBegin("SupportingStructure LoopParallelism MainParLoop");
    #pragma omp for
    for (int i = 0; i < MAX_ITERATIONS; i++)
        someCode();
    PatternInstrumentation::PatternEnd("MainParLoop");
    
  

The formal Syntax of the PatternBegin expression is as follows:
'DesignSpace PatternName Identifier'
where DesignSpace is either FindingConcurrency, AlgorithmStructure, SupportingStructure or ImplementationMechanism,
PatternName is the name of the pattern employed in this code region,
and the Identifier is a name for this exact occurence of the pattern.
Identifiers can be re-used to indicate to the tool, that two (or more) code regions belong together.

Please note that patterns that due to implementation, pattern regions have to be closed in the opposite order in which they are opened (First Opened - Last Closed).

If you have a CMake project for your source code

1. In your CMakeLists.txt, set the variable "EXPORT_COMPILE_COMMANDS" to 1 or ON: SET(EXPORT_COMPILE_COMMANDS 1)
   
2. Create/update your build system: mkdir build && cd build && cmake ..
   
3. Copy compile_commands.json to the directory containing the sources: cp compilation_commands.json path/to/src
   

If you use make (or another build tool) to build your source code
Install the Bear Tool. The tool intercepts the exec calls made by your build tool and creates a compilation database from this. Make sure to copy this compilation database to the directory of the source code.
ATTENTION: Sometimes the Bear Tool genearates multiple entries for the same file within the compilation database (compile_commands.json). If so delete those entries with non-absolute paths otherwise every Pattern is analyzed twice. Occurences, lines of codes and Fan-In Fan-Out will double. If you don't want to install the Bear Tool, you can copy the compilation commands from the make file. The syntax of the compilation database is covered in the JSON Compilation Database Format Specification.

If you want to write the compilation database from scratch by yourself consider the following tutorials: Compilation databases for Clang-based tools and JSON Compilation Database Format Specification also make shure to use absolute paths.

  #include "PatternInstrumentation.h"
int main(int argc, const char** argv){
if(true){
PatternInstrumentation::Pattern_Begin("FindingConcurrency TypeQualifiers ifA");
}
else{
PatternInstrumentation::Pattern_Begin("FindingConcurrency TypeQualifiers elseB");
}
if(true){
  PatternInstrumentation::Pattern_End("ifA");
}
else{
  PatternInstrumentation::Pattern_End("elseB");
}
return 0;

}

  #include "PatternInstrumentation.h"

  int main(int argc, const char** argv){
    if(true){
      PatternInstrumentation::Pattern_Begin("FindingConcurrency TypeQualifiers ifA");
    }
    else{
      PatternInstrumentation::Pattern_Begin("FindingConcurrency TypeQualifiers elseB");
    }

    if(true){
      PatternInstrumentation::Pattern_End("elseB");
    }
    else{
        PatternInstrumentation::Pattern_End("ifA");
    }
  	return 0;
  }

The pattern part of TypeQualifiers, ifA will appear as a parent of elseB.

  #include "PatternInstrumentation.h"
void function1(){
PatternInstrumentation::Pattern_Begin("SupportingStructure func1 One");
};
void function2(){
PatternInstrumentation::Pattern_End("One");
};
int main(int argc, const char** argv){
function1();
function2();
return 0;
}

  #include "PatternInstrumentation.h"
int main(int argc, const char** argv){
PatternInstrumentation::Pattern_Begin("SupportingStructure patternName One");
//source code
PatternInstrumentation::Pattern_Begin("SupportingStructure patternName Two");
//source code
PatternInstrumentation::Pattern_End("One");
//source code
PatternInstrumentation::Pattern_End("Two");
//source code
PatternInstrumentation::Pattern_Begin("SupportingStructure patternName Three");
//source code
PatternInstrumentation::Pattern_End("Three");
//source code
return 0;
}