coder.EmbeddedCodeConfig

Optimizes the build for shorter build times.

Optimizes the build for faster running executables.

Optimizes the build for debugging.

Enables the CustomToolchainOptions property for customization of settings for tools in the selected toolchain. If the Toolchain property is set to 'Automatically locate an installed toolchain', then setting BuildConfiguration to 'Specify' changes Toolchain to the located toolchain.

This value is the default value.

The code generator improves the execution time of generated C code by optimizing dynamic array access.

The code generator does not optimize dynamic array access.

This value is the default value.

Generates C/C++ code that uses default C compiler data type casting. For example:

short addone(short x)
{
  int i;
  i = x + 1;
  if (i > 32767) {
    i = 32767;
  }

  return (short)i;
}

Generates C/C++ code that casts data types to conform to MISRA™ standards. For example:

short addone(short x)
{
  int i;
  i = (int)x + (int)1;
  if (i > (int)32767) {
    i = (int)32767;
  }

  return (short)i;
}

Generates C/C++ code that casts data type values explicitly. For example:

short addone(short x)
{
  int i;
  i = (int)x + 1;
  if (i > 32767) {
    i = 32767;
  }

  return (short)i;
}

This value is the default value.

Creates a clang-format file for your build based on your configuration settings. The clang-format file is generated in the codegen folder.

Formats the generated code by using a clang-format file of your choice. Using clang-format enables detailed control over the formatting of your generated code.

The code generator searches for an existing clang-format file in the code generation folder and then the folder tree above the code generation folder. The code generator looks for files whose name includes _clang-format or is a .clang-format file that it finds. If it is unable to find the required file, the code generator uses the built-in format specification.

This value is the default value.

Disables code coverage analysis during a SIL or PIL execution.

This value is the default value.

Disables execution-time profiling during a SIL or PIL execution.

The code generator formats the generated code according to a clang-format file.

Uses an internal heuristic to determine if the generated code is formatted by clang-format or a MathWorks^® formatting tool.

If the code configuration property Verbosity is set to 'Verbose', the code generator produces a warning if the heuristic chooses a MathWorks formatting tool.

Causes the code generator to revert to the MathWorks formatting tool.

This value is the default value.

Extracts no metric from the PMU of the target hardware.

Extracts total instruction count.

Extracts FPU instruction count.

Extracts FPU operation count.

Extracts ALU instruction count.

Extracts load instruction count.

Extracts store instruction count.

Extracts total cycle count.

Extracts L1 data cache misses.

Extracts L1 instruction cache misses.

Extracts L2 data cache misses.

Extracts L2 instruction cache misses.

Extracts TLB data misses.

Extracts TLB instruction misses.

Extracts memory stall cycles.

Extracts total stall cycles.

This value is the default value.

Disables execution-time profiling of functions called within entry-point functions during a SIL or PIL execution.

Calculates execution times of functions called within entry-point functions, using data obtained from instrumentation code in the SIL or PIL application. Use the Code Profile Analyzer (Embedded Coder) to view the call tree and corresponding execution times for the generated code.

This value is the default value.

As execution runs, collects and immediately uploads profiling measurement and analysis data from target device to development computer. At the end of execution, saves all data in base workspace.

As execution runs, evaluates only execution-time metrics required for report and immediately uploads metrics from target device. At the end of execution, saves evaluated metrics in base workspace.

As execution runs, processes profiling data and stores certain metrics on target device. At the end of execution, uploads the stored metrics from target device.

This value is the default value.

Disables stack usage profiling during a SIL or PIL execution.

This value is the default value.

Does not use a code replacement library.

Generates calls to a specific platform, compiler, or standards code replacement library. The list of named libraries depends on:

This value is the default value.

The code generator does not convert if-elseif-else patterns to switch-case statements.

This value is the default value.

The code generator converts MATLAB enumerations to enumeration classes in the generated C++ code. This option is only supported if TargetLangStandard is set to C++11 or a newer standard.

See Code Generation for Enumerations.

The code generator produces ordinary C enumerations for MATLAB enumerations in the generated C++ code.

This value is the default value.

The code generator produces C++ classes for MATLAB classes. See Generate C++ Classes for MATLAB Classes.

The code generator produces C style structures for MATLAB classes.

This value is the default value.

The code generator produces C++ namespaces for the namespaces in your MATLAB code. See Organize Generated C++ Code into Namespaces.

The code generator does not produce C++ namespaces for the namespaces in your MATLAB code.

A string array in CustomInclude. For example, cfg.CustomInclude = ["C:\Project","C:\Custom Files"];

A cell array of character vectors in CustomInclude. For example, cfg.CustomInclude = {'C:\Project','C:\Custom Files'};

A string array in CustomLibrary. For example, cfg.CustomLibrary = ["myLib1.lib","myLib2.lib"];

A cell array of character vectors in CustomLibrary. For example, cfg.CustomLibrary = {'myLib1.lib','myLib2.lib'};

A string array in CustomSource. For example, cfg.CustomSource = ["mySrc1.c","mySrc2.c"];

A cell array of character vectors in CustomSource. For example, cfg.CustomSource = {'mySrc1.c','mySrc2.c'};

This value is the default value.

The code generator uses built-in C data types.

A coder.MklDNNConfig object contains parameters specific to C++ code generation for deep learning using Intel^® MKL-DNN. To create a coder.MklDNNConfig object, use coder.DeepLearningConfig. For example:

cfg = coder.config('mex');
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('mkldnn');

See Code Generation for Deep Learning Networks with MKL-DNN.

A coder.ARMNEONConfig object contains parameters specific to C++ code generation for deep learning using the ARM^® Compute Library. To create a coder.ARMNEONConfig object, use coder.DeepLearningConfig. For example:

cfg = coder.config('lib');
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('arm-compute');

See Code Generation for Deep Learning Networks with ARM Compute Library.

A coder.CuDNNConfig object contains parameters specific to CUDA code generation for deep learning using the cuDNN library. To create a coder.CuDNNConfig object, use coder.DeepLearningConfig. For example:

cfg = coder.gpuConfig('lib');
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('cudnn');

See Code Generation for Deep Learning Networks by Using cuDNN (GPU Coder).

A coder.TensorRTConfig object contains parameters specific to CUDA code generation for deep learning using the TensorRT library. To create a coder.TensorRTConfig object, use coder.DeepLearningConfig. For example:

cfg = coder.gpuConfig('lib');
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('tensorrt');

See Code Generation for Deep Learning Networks by Using TensorRT (GPU Coder).

This value is the default value.

The code generator allocates memory dynamically on the heap for variable-size arrays whose size (in bytes) is greater than or equal to DynamicMemoryAllocationThreshold.

The code generator statically allocates memory for variable-size arrays on the stack.

The code generator allocates memory dynamically on the heap for fixed-size arrays whose size (in bytes) is greater than or equal to DynamicMemoryAllocationThreshold.

This value is the default value.

The code generator statically allocates memory for fixed-size arrays on the stack.

This is the default value. If you set the TargetLang parameter to 'C++' or 'C', this value correspondingly behaves as the same flag.

The generated code uses the C style emxArray data structure to implement dynamically allocated arrays. See Use C Arrays in the Generated Function Interfaces.

If you set the TargetLang parameter to 'C', this value is disabled.

The generated code uses the coder::array class template to implement dynamically allocated arrays. See Use Dynamically Allocated C++ Arrays in Generated Function Interfaces.

This value is the default value.

The code generator treats some common visualization functions as extrinsic functions. You do not have to declare these functions as extrinsic by using coder.extrinsic. This capability reduces the amount of time that you spend making your code suitable for code generation.

This value is the default value.

Code generator does not automatically parallelize for loops.

The code generator automatically parallelizes for loops in the generated code. Automatic parallelization can significantly improve the execution speed of the generated code. See Automatically Parallelize for Loops in Generated Code.

This value is the default value.

If you set EnableAutoParallelization to true, the code generator produces a code generation report for automatic parallelization of for loops

This value is the default value.

Custom names for the MATLAB data types are not allowed.

Custom names for the MATLAB data types are allowed. Specify custom names by using ReplacementTypes. Setting EnableCustomReplacementTypes to true enables the ReplacementTypes parameter.

This value is the default value.

The code generator allocates memory dynamically on the heap for variable-size arrays whose size (in bytes) is greater than or equal to DynamicMemoryAllocationThreshold.

This value is the default value.

The code generator enables implicit expansion in the generated code. The code generator includes modifications in the generated code to apply implicit expansion. See Compatible Array Sizes for Basic Operations.

The generated code does not follow the rules of implicit expansion.

This value is the default value.

If possible, the code generator uses the memcpy optimization. To optimize code that copies consecutive array elements, the memcpy optimization replaces the code with a memcpy call. When the number of elements to copy is known at compile time, the code generator uses the MemcpyThreshold property to determine whether to use the optimization. See memcpy Optimization.

The code generator does not use the memcpy optimization.

This value is the default value.

If possible, the code generator uses the OpenMP library to produce loop iterations that run in parallel.

The code generator treats parfor-loops as for-loops.

This value is the default value.

Recursive functions are allowed in the generated code.

Recursive functions are not allowed in the generated code.

This value is the default value.

The code generator uses signed left shifts for multiplication by powers of two. An example of generated C code that uses signed left shift for multiplication by eight is:

i <<= 3;

The code generator does not use signed left shifts for multiplication by powers of two. An example of generated C code that does not use signed left shift for multiplication by eight is:

i = i * 8;

This value is the default value.

The code generator uses signed right shifts. An example of generated C code that uses a signed right shift is:

i >>= 3

The code generator replaces right shifts on signed integers with a function call in the generated code. For example:

i = asr_s32(i, 3U);

This value is the default value.

The code generator does not use the strength reduction optimization.

The code generator tries to use the strength reduction optimization to simplify array indexing in loops in the generated code. When possible, for array indices in loops, the code generator replaces multiply operations with add operations. Multiply operations can be expensive. When the C/C++ compiler on the target platform does not optimize the array indexing, the strength reduction optimization is useful. Even when the optimization replaces the multiply operations in the generated code, it is possible that the C/C++ compiler can generate multiply instructions.

This value is the default value.

The code generation report includes code traceability. See Interactively Trace Between MATLAB Code and Generated C/C++ Code (Embedded Coder).

The code generation report does not include code traceability.

This value is the default value.

Variable-size arrays are allowed for code generation.

Variable-size arrays are not allowed for code generation.

This value is the default value.

The code generator produces separate C/C++ files for each MATLAB language file.

This value is the default value.

The code generator does not run static code metrics analysis at code generation time. You can run the analysis and produce the report later by clicking Code Metrics on the Summary tab of the code generation report.

The code generator runs static code metrics analysis and produces the report at code generation time.

This value is the default value.

The code generator produces C/C++ source code and builds object code.

The code generator produces C/C++ source code, but does not invoke the make command or build object code. When you iterate between modifying MATLAB code and generating C/C++ code, generating only code can save time.

This value is the default value.

The code generator does not produce a code replacements report.

The code generator produces a code replacements report that summarizes the replacements from the selected code replacement library. The report provides a mapping between each code replacement instance and the line of MATLAB code that triggered the replacement.

This value is the default value.

The code generator places comments in the generated code.

This value is the default value.

The code generator might not generate a default case for some switch statements.

This value is the default value.

The code generator generates an example C/C++ main function but does not compile it.

The code generator does not generate an example C/C++ main function.

The code generator generates an example C/C++ main function and compiles it to create a test executable. This executable does not return output.

If the GenCodeOnly parameter is true, the code generator does not compile the C/C++ main function.

This value is the default value.

The code generator generates a makefile during the build process.

This value is the default value.

The code generator produces the support files for nonfinite data (Inf and NaN) only if the generated code uses nonfinite data.

The code generator always produces the support files for nonfinite data (Inf and NaN).

This value is the default value.

The code generator produces a report only if error or warning messages occur, or if you set LaunchReport to true.

The code generator produces #ifndef style #include guards.

This value is the default value.

This code generation report does not highlight potential data type issues.

The code generation report highlights MATLAB code that results in single-precision or double-precision operations in the generated C/C++ code. If you have Fixed-Point Designer™, the report also highlights expressions in the MATLAB code that result in expensive fixed-point operations in the generated code.

The code generation report displays potential efficiency issues due to row-major layout. (This value is the default value.)

This value is the default value.

The code generator produces an initialize function.

The code generator does not produce an initialize function. If you set IncludeInitializeFcn to false and an initialize function is required, for example, to call supporting code for nonfinite data (Inf or NaN), the code generator produces an error message.

See MATLAB Code Patterns That Require a Nonempty Initialize Function in Generated Code (Embedded Coder).

This value is the default value.

The code generator produces a terminate function.

The code generator does not produce a terminate function. If you set IncludeTerminateFcn to false and a terminate function is required, for example, to free memory, the code generator issues a warning.

This value is the default value.

For blocks within a function, an opening brace is on the same line as its control statement. For example:

void addone(const double x[6], double z[6])
{
  int i0;
  for (i0 = 0; i0 < 6; i0++) {
    z[i0] = x[i0] + 1.0;
  }
}

For blocks within a function, an opening brace is on its own line at the same indentation level as its control statement. For example:

void addone(const double x[6], double z[6])
{
  int i0;
  for (i0 = 0; i0 < 6; i0++)
  {
    z[i0] = x[i0] + 1.0;
  }
}

This value is the default value.

If possible, the code generator uses the memset optimization for assignment of floating-point zero to consecutive array elements. To assign consecutive array elements, the memset optimization uses a memset call. When the number of elements to assign is known at compile time, the code generator uses the MemcpyThreshold property to determine whether to use the optimization. See memset Optimization.

The code generator does not use the memset optimization for assignment of float and double zero to consecutive array elements.

This value is the default value.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Always performs inlining at a call site.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Always performs inlining at a call site.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Always performs inlining at a call site.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

The code generator does not add annotations to the generated C/C++ code.

This value is the default value.

The code generator writes large constants for a deep neural network (DNN) in binary data files.

The code generator embeds large constants for a deep neural network (DNN) in the generated source code.

This value is the default value.

If errors or warnings occur, or if GenerateReport is true, the code generator produces a report, but does not open the report.

This value is the default value.

The code generator includes MATLAB function help text in the function banner in the generated code.

The code generator treats the help text as a user comment.

This value is the default value.

The code generator does not insert MATLAB source code as comments in the generated code. The code generator does not include the MATLAB function signature in the function banner.

The code generator inserts MATLAB source code as comments in the generated code. A traceability tag immediately precedes each line of source code. The traceability tag helps you to locate the corresponding MATLAB source code. See Tracing Generated C/C++ Code to MATLAB Source Code.

If you have Embedded Coder, in the code generation report, the traceability tag links to the source code.

The code generator also includes the MATLAB function signature in the function banner.

This value is the default value.

The code generator does not produce multi-instance, reentrant code.

The code generator produces reusable, multi-instance code that is reentrant.

This value is the default value.

Code generator does not generate SIMD code for reduction operations.

To use this parameter, you must select an instruction set for the InstructionSetExtensions parameter. The code generator uses the specified instruction set to generate SIMD code for reduction operations.

This value is the default value.

Code generator does not automatically parallelize for-loops performing reduction operations.

The code generator automatically parallelizes for-loops performing reduction operations in the generated code, only if you set EnableAutoParallelization to true.

This value is the default value.

The code generator inserts parentheses to balance readability and visual complexity. For example:

Out = ((In2 - In1 > 1.0) && (In2 > 2.0));

The code generator includes parentheses to specify meaning without relying on operator precedence. Code generated with this setting conforms to MISRA requirements. For example:

 Out = (((In2 - In1) > 1.0) && (In2 > 2.0));

The code generator inserts parentheses where required by ANSI^® C or C++, or to override default precedence. For example:

Out = In2 - In1 > 1.0 && In2 > 2.0;

If you generate C/C++ code that uses the minimum level, for certain settings in some compilers, you can receive compiler warnings. To eliminate these warnings, try the nominal level.

This value is the default value.

The generated code passes structures by reference, which reduces memory usage and execution time by minimizing the number of copies of parameters at entry-point function boundaries.

This value is the default value.

The code generator includes the extern keyword in declarations for external functions.

The code generator removes the extern keyword from function declarations.

Generate code that uses one-dimensional indexing. (This value is the default value.)

This value is the default value.

The code generator produces the C/C++ code by removing the unused properties and fields in the generated code.

The code generator produces the C/C++ code by preserving the unused properties and fields in the generated code.

This value is the default value.

The code generator does not have to preserve any variable names. It can reuse any variables that meet the requirements for variable reuse.

If your code uses large structures or arrays, setting PreserveVariableNames to 'None' can reduce memory usage or improve execution speed.

The code generator preserves names that correspond to variables that you define in the MATLAB code. It does not replace your variable name with another name and does not use your name for another variable. To improve readability, set PreserveVariableNames to 'UserNames'. Then, you can more easily trace the variables in the generated code back to the variables in your MATLAB code.

Setting PreserveVariableNames to 'UserNames' does not prevent an optimization from removing your variables from the generated code or prevent the C/C++ compiler from reusing the variables in the generated binary code.

Preserve all variable names. This parameter value disables variable reuse. Use it only for testing or debugging, not for production code.

This value is the default value.

The code generator allows floating-point data and operations.

The code generator does not allow floating-point data or operations. If the code generator detects floating-point data or operations, code generation ends with an error.

A string array in ReservedNameArray. For example, cfg.ReservedNameArray = ["reserve1","reserve2","reserve3"].

A cell array of character vectors in ReservedNameArray. For example, cfg.ReservedNameArray = {'reserve1','reserve2','reserve3'}.

A semicolon-separated list of reserved names in ReservedNameArray. For example, cfg.ReservedNameArray = 'reserve1;reserve2;reserve3'.

Generate code that uses column-major array layout. (This value is the default value.)

This value is the default value.

A call to the initialize function is included at the beginning of the generated entry-point functions. The generated code includes checks to make sure that the initialize function is called only once, even if there are multiple entry-point functions.

The generated entry-point functions do not include calls to the initialize function.

This value is the default value.

The generated code does not check for errors such as out-of-bounds array indexing.

The generated code checks for errors such as out-of-bounds array indexing.

The error-reporting software uses fprintf to write error messages to stderr. It uses abort to terminate the application. If fprintf and abort are not available, you must provide them. The abort function abruptly terminates the program. If your system supports signals, you can catch the abort signal (SIGABRT) so that you can control the program termination.

Error messages are in English.

This value is the default value.

The code generator produces code to handle integer overflow. Overflows saturate to either the minimum or maximum value that the data type can represent.

The code generator does not produce code to handle integer overflow. Do not set SaturateOnIntegerOverflow to false unless you are sure that your code does not depend on integer overflow support. If you disable integer overflow support and run-time error checking is enabled, the generated code produces an error for overflows. If you disable integer overflow support and you disable run-time error checking, the overflow behavior depends on your target C compiler. In the C standard, the behavior for integer overflow is undefined. However, most C compilers wrap on overflow.

This value is the default value.

Disables debugging of generated code during a SIL or PIL execution.

Enables the debugger to observe code behavior during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution.

Supported debuggers for SIL execution:

For information about installing the support package, see https://www.mathworks.com/matlabcentral/fileexchange/103555-matlab-coder-interface-for-visual-studio-code-debugging.

For information about setting up debuggers for PIL execution, see Set Up PIL Connectivity by Using Target Framework (Embedded Coder).

This value is the default value.

The SIL or PIL execution compares the value that a test file provides for a constant input argument with the value specified at code generation time. If the values do not match, an error occurs.

The SIL or PIL execution does not compare the value that a test file provides for a constant input argument with the value specified at code generation time. The SIL or PIL execution uses the value specified at code generation time. If the test file uses a different value, then the results in MATLAB might differ from the results in the SIL or PIL execution.

It is possible to speed up a SIL or PIL execution by setting SILPILCheckConstantInputs to false.

This value is the default value.

A SIL or PIL execution synchronizes the values of global variables in the SIL or PIL execution environment with the values in the MATLAB workspace. If a global variable is constant and its value in the SIL or PIL execution environment differs from its value in the MATLAB workspace, an error occurs.

The SIL or PIL execution does not synchronize the values of global variables in the SIL or PIL execution environment with the values in the MATLAB workspace. If the values are not synchronized, the results in MATLAB might differ from the results in the SIL or PIL execution.

It is possible to speed up a SIL or PIL execution by setting SILPILSyncGlobalData to false.

This value is the default value.

The code generator does not display communication I/O information during SIL or PIL execution.

The code generator displays communication I/O information during SIL or PIL execution.

This value is the default value.

If GenerateNonFiniteFilesIfUsed is set to true, the code generator produces code to support nonfinite values (Inf and NaN) only if they are used.

If GenerateNonFiniteFilesIfUsed is set to false, the code generator always produces code to support nonfinite values (Inf and NaN).

The code generator does not produce code to support nonfinite values.

This value is the default value.

The code generator does not produce calls to the built-in FFTW library for FFT functions in your MATLAB code.

The code generator produces calls to the built-in FFTW library for FFT functions in your MATLAB code.

For C/C++ code generation, this value is the default value.

The code generator prefers to use the available platform-specific precompiled libraries.

This setting is an appropriate choice when you want to optimize the performance of the generated code for specific platforms.

For CUDA code generation (requires GPU Coder), this value is the default value.

The code generator uses platform-specific precompiled libraries only if no alternative implementations of their algorithms are available.

This setting is useful when you want to create portable applications that can run on many platforms.

This value is the default value.

The code generator does not display code generation progress.

The code generator displays code generation progress, including code generation stages and compiler output.

If code generation succeeds without warning, all messages are suppressed, including when you generate a report.

Warning and error messages are displayed.

This value is the default value.

Compared to the 'Silent' mode, if code generation succeeds, these additional messages are displayed:

In addition to the messages shown in the 'Info' mode, code generation status and target build log messages are displayed.