coder.EmbeddedCodeConfig - Configuration parameters for C/C++ code generation from MATLAB code with Embedded Coder - MATLAB (original) (raw)

Main Content

Configuration parameters for C/C++ code generation from MATLAB code with Embedded Coder

Description

A coder.EmbeddedCodeConfig object contains the configuration parameters that codegen uses for generating a static library, a dynamically linked library, or an executable program with Embedded Coder®. Pass the object to the codegen function by using the-config option.

Properties

expand all

BuildConfiguration — Compiler optimization or debug settings for toolchain

'Faster Runs' (default) | 'Faster Builds' | 'Debug' | 'Specify'

Compiler optimization or debug settings for toolchain, specified as one of the values in this table.

If you set the Toolchain property to one of the available CMake toolchain definitions, the allowed values of this property are 'Release', 'Debug','RelWithDebInfo', 'MinSizeRel', and 'Specify'. See Configure CMake Build Process.

CacheDynamicArrayDataPointer — Dynamic array optimization

true (default) | false

Dynamic array optimization, specified as one of the values in this table.

See Optimize Dynamic Array Access.

CastingMode — Data type casting level

'Nominal' (default) | 'Standards' | 'Explicit'

Data type casting level for variables in the generated C/C++ code, specified as one of the values in this table.

See Control Data Type Casts in Generated Code (Embedded Coder).

ClangFormatFile — Control generation of clang-format file

'Generate' (default) | 'Existing'

Set this option to specify if you want to generate or use an existingclang-format file to format the generated code. Choose the formatting file selection method, specified as one of the values in the table.

For more information, see https://clang.llvm.org/docs/ClangFormatStyleOptions.html.

clang-format does not have native CUDA® C++ support. When generating CUDA code using GPU Coder™, setting the formatting tool to'Clang-format' might result in build failures during code compilation.

CodeCoverage — Analysis of C/C++ code coverage

false (default) | true

Coverage analysis of both generated C/C++ code and custom C/C++ during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

To use this name-value argument, you must have a MATLAB® Test™ license.

Data Types: logical

CodeExecutionProfiling — Execution time profiling during a SIL or PIL execution

false (default) | true

Execution-time profiling of entry-point functions during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

See Execution Time Profiling for SIL and PIL (Embedded Coder) and Generate Execution Time Profile (Embedded Coder).

CodeFormattingTool — Formatting tool for generated code

'Auto' (default) | 'Clang-format' | 'MathWorks'

Code formatting options for generated code, specified as one of the values in the table.

CodeProfilingCodeMetrics — PMU metric

"time" (default) | "totinstr" | "floatinsts" | "floatopts" | "intinstr" | "loadinstr" | "storeinstr" | "totcyc" | "l1dcm" | "l1icm" | "l2dcm" | "l2icm" | "tlbdm" | "tlbim" | "memstall" | "totstall"

Performance Monitoring Unit (PMU) metric profiling of functions, specified as one of the values in this table.

See Investigate Execution-Time Issues Using PMU Metrics (Embedded Coder).

Data Types: char | string

CodeProfilingInstrumentation — Execution time profiling of functions called within entry-point functions during a SIL or PIL execution

false (default) | true

Execution-time profiling of functions that are called within entry-point functions during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

Dependency: CodeExecutionProfiling enables this parameter.

See Execution Time Profiling for SIL and PIL (Embedded Coder) and Generate Execution Time Profile (Embedded Coder).

CodeProfilingSaveOptions — Collection and storage of execution-time measurements

"AllData" (default) | "SummaryOnly" | "MetricsOnly"

Options for collection and storage of execution-time measurements, specified as one of the values in this table.

Data Types: char | string

CodeStackProfiling — Stack usage profiling during a SIL or PIL execution

false (default) | true

Stack usage profiling of entry-point functions during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

See Stack Usage Profiling for Code Generated From MATLAB Code (Embedded Coder).

CodeTemplate — Code generation template for file and function banners

0-by-0 array ofcoder.MATLABCodeTemplate class (default) | coder.MATLABCodeTemplate object

Code generation template for file and function banners in the generated code. By default, CodeTemplate is empty and the code generator produces default banners. To produce custom banners, setCodeTemplate to acoder.MATLABCodeTemplate object created from a code generation template (CGT) file. See Generate Custom File and Function Banners for C/C++ Code (Embedded Coder).

CodeReplacementLibrary — Code replacement library for generated code

character vector

Code replacement library for generated code, specified as one of the values in this table:

Compatible libraries depend on these parameters:

• TargetLang
• TargetLangStandard
• ProdHWDeviceType in the hardware implementation configuration object.

Embedded Coder offers more libraries and the ability to create and use custom code replacement libraries.

MATLAB Coder™ generates the minimal set of #include statements for header files required by the selected code replacement library.

Before setting this parameter, verify that your compiler supports the library that you want to use. If you select a parameter value that your compiler does not support, compiler errors can occur.

Note

MATLAB Coder software does not support TLC callbacks.

ColumnLimit — Maximum number of columns before a line break in the generated code

80 (default) | positive integer

Maximum number of columns before a line break in the generated code, specified as a positive integer in the range [45, 65536].

Other rules for placement of the line break can take precedence over the column limit that you specify.

— Comment style in the generated code

'Auto' (default) | 'Single-line' | 'Multi-line'

Comment style in the generated code, specified as one of the values in this table.

For C code generation, specify the single-line comment style only if your compiler supports it.

Dependency: GenerateComments enables this parameter.

See Specify Comment Style for C/C++ Code (Embedded Coder).

CompileTimeRecursionLimit — Maximum number of function specializations for compile-time recursion

50 (default) | positive integer

Maximum number of function specializations for compile-time recursion, specified as a positive integer. To disallow recursion in the MATLAB code, set CompileTimeRecursionLimit to 0. The default compile-time recursion limit is large enough for most recursive functions that require this type of recursion. If code generation fails because of the compile-time recursion limit, and you want compile-time recursion, try to increase the limit. Alternatively, change your MATLAB code so that the code generator uses run-time recursion. SeeCompile-Time Recursion Limit Reached.

ConstantFoldingTimeout — Maximum number of instructions to be executed by the constant folder

40000 (default) | positive integer

Maximum number of instructions that the constant folder executes. In some situations, code generation requires specific instructions to be constant. If constant folding stops before these instructions are constant-folded, code generation fails. In this case, increase the value ofConstantFoldingTimeout.

See MATLAB Coder Optimizations in Generated Code.

ConvertIfToSwitch — Conversion of if-elseif-else patterns to switch-case statements

false (default) | true

Conversion of if-elseif-else patterns toswitch-case statements in the generated code, specified as one of the values in this table.

See Controlling C Code Style (Embedded Coder).

CppGenerateEnumClass — Whether to generate C++ enumeration classes for MATLAB enumerations

true (default) | false

Whether to generate C++ code that contains enumeration classes, specified as one of the values in this table.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

CppInterfaceClassName — Interface class name for generated C++ code

'' (default) | character vector

Name of interface class when you generate C++ code withCppInterfaceStyle set to'Methods'. In this case, the generated code for MATLAB entry-point functions consists of methods contained in a C++ class with name specified by CppInterfaceClassName. This property has no effect when you setCppInterfaceStyle to'Functions'.

See Generate C++ Code with Class Interface.

CppInterfaceStyle — Interface style for generated C++ code

'Functions' (default) | 'Methods'

Style of interface to the generated C++ code for the MATLAB entry-point functions that you generate code from. By default, entry-point functions become C++ functions. If you choose'Methods', then entry-point functions become methods in a C++ class. Specify the name of the class by using the propertyCppInterfaceClassName.

See Generate C++ Code with Class Interface.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

CppNamespace — Namespace name for generated C++ code

'' (default) | character vector

Namespace for the generated C++ code. The code generator does not produce code in a namespace unless you specify a nonempty character vector.

See Organize Generated C++ Code into Namespaces.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

CppNamespaceForMathworksCode — Place C++ code generated for MathWorks code in a separate namespace

'coder' (default) | character vector

Namespace for the C++ code generated for MathWorks code. The code generator does not produce such a namespace if you specify this property as an empty character vector.

See Organize Generated C++ Code into Namespaces.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

Data Types: char

CppPreserveClasses — Generate C++ classes for MATLAB classes

true (default) | false

Whether to generate C++ classes or C style structures for MATLAB classes, specified as one of the values in this table.

When using GPU Coder, the code generator always disables this parameter.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

Data Types: logical

CppPreserveNamespaces — Generate C++ namespaces for MATLAB namespaces

true (default) | false

Whether to generate C++ namespaces for the namespaces in your MATLAB code, specified as one of the values in this table.

Dependency:

• Setting TargetLang to'C++' enables this parameter.

Data Types: logical

CustomBLASCallback — BLAS callback class

' ' (default) | character vector

Callback class for BLAS library calls in code generated for certain low-level vector and matrix operations in MATLAB code, specified as a character vector.

If you specify a BLAS callback class, for certain low-level vector and matrix functions, the code generator produces BLAS calls by using the CBLAS C interface to your BLAS library. The callback class provides the name of your CBLAS header file, the names of CBLAS data types, and the information required to link to your BLAS library. If this parameter is empty, the code generator produces code for matrix functions instead of a BLAS call.

See Speed Up Matrix Operations in Generated Standalone Code by Using BLAS Calls.

CustomFileNameStr — File name customization macro

'$N$M' (default) | character vector

Macro that specifies the customization of generated file names with additional characters and tokens. For more information, see Customize C/C++ File Names Generated from MATLAB Code (Embedded Coder).

CustomFFTCallback — Callback class for FFTW library calls

' ' (default) | character vector

Callback class for FFTW library calls in code generated for FFT functions in MATLAB code, specified as a character vector.

To improve the execution speed of FFT functions, the code generator produces calls to the FFTW library that you specify in the callback class. If this parameter is empty, the code generator uses its own algorithms for FFT functions instead of calling the FFTW library.

UseBuiltinFFTWLibrary takes precedence overCustomFFTCallback if you enable both these properties.

See Speed Up Fast Fourier Transforms in Generated Standalone Code by Using FFTW Library Calls.

— Custom code that appears at top of generated C/C++ header files

' ' (default) | character vector

Custom code that appears near the top of each C/C++ header file generated from your MATLAB code, except rtwtypes.h andrtwhalf.h, specified as a character vector.

CustomInclude — Include folders to add to include path for compiling generated code

' ' (default) | string array | cell array of character vectors | character vector

Include folders to add to the include path when compiling the generated code. Specify the list of include folders as a string array, cell array of character vector, or character vector.

To specify a single include folder, you can use a character vector or a string scalar.

To specify multiple folder names, use one of the values in this table.

CustomInitializer — Custom code to include in the generated initialize function

' ' (default) | character vector

Custom code to include in the generated initialize function, specified as a character vector.

CustomLAPACKCallback — LAPACK callback class

' ' (default) | character vector

Callback class for LAPACK library calls in code generated for certain linear algebra functions in MATLAB code, specified as a character vector.

If you specify a LAPACK callback class, for certain linear algebra functions, the code generator produces LAPACK calls by using the LAPACKE C interface to your LAPACK library. The callback class provides the name of your LAPACKE header file and the information required to link to your LAPACK library. If this parameter is empty, the code generator produces code for linear algebra functions instead of a LAPACK call.

See Speed Up Linear Algebra in Generated Standalone Code by Using LAPACK Calls.

CustomLibrary — Static library files to link with the generated code

' ' (default) | string array | cell array of character vectors | character vector

Static library files to link with the generated code, specified as a string array, cell array of character vector, or character vector.

To specify a single static library file, you can use a character vector or a string scalar.

To specify multiple static library file names, use one of the values in this table.

CustomSource — Source files to compile and link with the generated code

' ' (default) | string array | cell array of character vectors | character vector

Source files to compile and link with the generated code, specified as a string array, cell array of character vector, or character vector.

The build process searches for the source files first in the current folder, and then in the include folders that you specify inCustomInclude. If source files with the same name occur in multiple folders on the search path, the build process might use a different file than the file that you specified.

Suppose that you specify foo.cpp as a source file. Iffoo.c and foo.cpp are both on the search path, you cannot be sure whether the build process usesfoo.c or foo.cpp.

To specify a single source file, you can use a character vector or a string scalar.

To specify multiple source file names, use one of the values in this table.

CustomSourceCode — Code to appear near the top of generated .c or .cpp files

' ' (default) | character vector

Specify code to appear near the top of each generated.c or .cpp file (exceptrtwhalf.c or rtwhalf.cpp), outside of any function. Specify code as a character vector.

Do not specify a C static function definition.

CustomSymbolStrEMXArray — Custom identifier format for EMX array types

'emxArray_$M$N' (default) | character vector

Custom identifier format for generated EMX Array types (Embeddable mxArray types), specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomSymbolStrEMXArrayFcn — Custom identifier format for EMX array utility functions

'emx$M$N' (default) | character vector

Custom identifier format for generated EMX Array (Embeddable mxArrays) utility functions, specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomSymbolStrFcn — Custom identifier format for local function identifiers

'm_$M$N' (default) | character vector

Custom identifier format for generated local function identifiers, specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomSymbolStrField — Custom identifier format for field names in global type identifiers

'$M$N' (default) | character vector

Custom identifier format for generated field names in global type identifiers, specified as a character vector. To specify the format, seeCustomize Generated Identifiers (Embedded Coder).

CustomSymbolStrGlobalVar — Custom identifier format for global variable identifiers

'$M$N' (default) | character vector

Custom identifier format for generated global variable identifiers, specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomSymbolStrMacro — Custom identifier format for constant macro identifiers

'$M$N' (default) | character vector

Custom identifier format for generated constant macro identifiers, specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomSymbolStrTmpVar — Custom identifier format for local temporary variable identifiers

'$M$N' (default) | character vector

Custom identifier format for generated local temporary variable identifiers, specified as a character vector. To specify the format, seeCustomize Generated Identifiers (Embedded Coder).

CustomSymbolStrType — Custom identifier format for global type identifiers

'$M$N' (default) | character vector

Custom identifier format for generated global type identifiers, specified as a character vector. To specify the format, see Customize Generated Identifiers (Embedded Coder).

CustomTerminator — Code that appears in the generated terminate function

' ' (default) | character vector

Code that appears in the generated terminate function, specified as a character vector.

CustomToolchainOptions — Custom settings for tools in selected toolchain

cell array

Custom settings for tools in selected toolchain, specified as a cell array.

Dependencies:

• The Toolchain property determines which tools and options appear in the cell array.
• Setting the BuildConfiguration property toSpecify enablesCustomToolchainOptions.

First, get the current settings. For example:

cfg = coder.config('lib'); cfg.BuildConfiguration='Specify'; opt = cfg.CustomToolchainOptions

Then, edit the values in opt.

These values derive from the toolchain definition file and the third-party compiler options. See Custom Toolchain Registration.

DataTypeReplacement — Data type replacement in generated code

'CBuiltIn' | 'CoderTypeDefs'

Data type replacement in generated code, specified as one of the values in this table.

DeepLearningConfig — Configuration object for deep learning code generation

coder.MklDNNConfig object | coder.ARMNEONConfig object | coder.CuDNNConfig object | coder.TensorRTConfig object

Configuration object for code generation for deep learning networks, specified as specified as one of the objects in this table.

Dependency: If DeepLearningConfig is set,codegen sets TargetLang toC++.

Description — Object description

'class CodeConfig: C code generation configuration.' (default) | character vector

Object description, specified as a character vector.

DynamicMemoryAllocation — Dynamic memory allocation mode

'Threshold' (default) | 'AllVariableSizeArrays' | 'Off'

Dynamic memory allocation mode, specified as one of the values in this table.

Unbounded variable-size arrays require dynamic memory allocation.

Dependencies:

• EnableVariableSizing enables this parameter.
• Setting this DynamicMemoryAllocation to'Threshold' enables theDynamicMemoryAllocationThreshold parameter.

See Generate Code for Variable-Size Data.

Note

DynamicMemoryAllocation configuration option will be removed in a future release. To dynamically allocation memory for variable-sized arrays, use theEnableDynamicMemoryAllocation option. To set the threshold, use theDynamicMemoryAllocationThreshold option.

DynamicMemoryAllocationForFixedSizeArrays — Dynamic memory allocation for fixed-size arrays

false (default) | true

Dynamic memory allocation for fixed-size arrays, specified as one of the values in this table.

Dependency:

• Setting EnableDynamicMemoryAllocation totrue enables this option.

See, Control Dynamic Memory Allocation for Fixed-Size Arrays.

DynamicMemoryAllocationInterface — Dynamically allocated array at generated function interface

'Auto' (default) | 'C' | 'C++'

Implementation of dynamically allocated array at the interface of the generated C/C++ function, specified as one of the values in this table.

When using GPU Coder, the code generator always uses the C style emxArray data structure.

Dependency:

• EnableVariableSizing enables this parameter.

DynamicMemoryAllocationThreshold — Size threshold for dynamic memory allocation of variable-size arrays

65536 (default) | positive integer

Size threshold for dynamic memory allocation of fixed-size and variable-size arrays, specified as a positive integer. The code generator uses dynamic memory allocation for fixed-size and variable-size arrays whose size (in bytes) is greater than or equal to the threshold.

Dependency:

• Setting DynamicMemoryAllocation to'Threshold' enables this parameter.

See Generate Code for Variable-Size Data.

EnableAutoExtrinsicCalls — Automatic extrinsic function calls

true (default) | false

Automatic extrinsic function calls, specified as one of the values in this table.

Some common visualization functions are plot,disp, and figure. See Use MATLAB Engine to Execute a Function Call in Generated Code.

EnableAutoParallelization — Automatic parallelization of for loops

false (default) | true

Automatic parallelization of for loops, specified as one of the values in this table.

When using GPU Coder, the code generator always enables automatic parallelization of for loops.

Data Types: logical

EnableAutoParallelizationReporting — Reporting for automatic parallelization of for loops

true (default) | false

Reporting for automatic parallelization of for loops, specified as one of the values in this table.

EnableCustomReplacementTypes — Custom names for data types in generated code

false (default) | true

Custom names for MATLAB data types in generated C/C++ code, specified as one of the values in the table.

EnableDynamicMemoryAllocation — Enable dynamic memory allocation for variable-size arrays

true (default) | false

Dynamic memory allocation for variable-size arrays, specified as one of the values in this table.

EnableImplicitExpansion — Implicit expansion capabilities in generated code

true (default) | false

Implicit expansion capabilities in the generated code, specified as one of the values listed in this table.

Data Types: logical

EnableMemcpy — memcpy optimization

true (default) | false

memcpy optimization, specified as one of the values in this table.

When using GPU Coder, the code generator always disables Memcpy optimization.

EnableOpenMP — Parallelization of parfor-loops

true (default) | false

Parallelization of parfor-loops, specified as one of the values in this table.

See parfor.

Use of the OpenMP library is not compatible with just-in-time (JIT) compilation. If EnableJIT andEnableOpenMP are true, the code generator uses JIT compilation and treats parfor-loops asfor-loops.

When using GPU Coder, the code generator always treats parfor-loops asfor-loops.

EnableRuntimeRecursion — Run-time recursion support

true (default) | false

Run-time recursion support, specified as one of the values in this table.

Some coding standards, such as MISRA, do not allow recursion. To increase the likelihood of generating code that is compliant with MISRA C™, set EnableRuntimeRecursion tofalse.

If your MATLAB code requires run-time recursion andEnableRuntimeRecursion is false, code generation fails.

See Code Generation for Recursive Functions.

EnableSignedLeftShifts — Replacement of multiplications by powers of two with signed left bitwise shifts

true (default) | false

Replacement of multiplications by powers of two with signed left bitwise shifts in the generated C/C++ code, specified as one of the values in this table.

GPU Coder always sets theEnableSignedLeftShifts property to true.

Some coding standards, such as MISRA, do not allow bitwise operations on signed integers. To increase the likelihood of generating MISRA C compliant code, set EnableSignedLeftShifts to false.

See Control Signed Left Shifts in Generated Code (Embedded Coder).

EnableSignedRightShifts — Signed right bitwise shifts in generated code

true (default) | false

Signed right bitwise shifts in generated code, specified as one of the values in this table.

GPU Coder always sets theEnableSignedRightShifts property to true.

Some coding standards, such as MISRA, do not allow bitwise operations on signed integers. To increase the likelihood of generating MISRA-C:2004 compliant code, setEnableSignedRightShifts tofalse.

EnableStrengthReduction — Strength reduction optimization

false (default) | true

Strength reduction optimization, specified as one of the values in this table.

EnableTraceability — Traceability in code generation report

true (default) | false

Traceability in code generation report, specified as one of the values in this table.

EnableVariableSizing — Variable-size array support

true (default) | false

Variable-size array support, specified as one of the values in this table.

Dependency:

• Enables Dynamic memory allocation.

See Code Generation for Variable-Size Arrays.

FilePartitionMethod — File partitioning mode

'MapMFileToCFile' (default) | 'SingleFile'

File partitioning mode specified as one of the values in this table.

See How MATLAB Coder Partitions Generated Code.

GenerateCodeMetricsReport — Static code metrics report

false (default) | true

Static code metrics report, specified as one of the values in this table.

To open a code metrics report, click the Code Metrics link on the Summary tab of the code generation report.

Dependency:

• The code generator produces a static code metrics report only if GenerateReport istrue or if you specify the-report option of thecodegen report.

See Generating a Static Code Metrics Report for Code Generated from MATLAB Code (Embedded Coder).

GenCodeOnly — Generation of only source code

false (default) | true

Generation of only source code, specified as one of the values in this table.

GenerateCodeReplacementReport — Code replacement report

false (default) | true

Code replacement report, specified as on of the values in this table.

— Comments in generated code

true (default) | false

Comments in generated code, specified as one of the values in this table.

If you set GenerateComments to true, the code generator places default comments, such as inferred argument types, in the generated code. The code generator also copies code comments that you make inside your MATLAB functions into the generated code, with some exceptions. For example, the generated code generally does not include code comments from MATLAB functions that are removed due to internal optimizations.

If you generate code for a live function (.mlx file), the code generator does not include the text sections in the generated code, even if GenerateComments is set totrue. To include live function text sections as comments in the generated code, first save the .mlx file as a .m file, which converts the text sections to code comments within the function body. Because the code generator gives precedence to functions in .mlx files over those in.m files, you must rename one of the functions or move one of the files to a different folder. Then, generate code for the function in the .m file. The code generator includes the text sections as comments in the generated code.

GenerateDefaultInSwitch — Default case for all switch statements

false (default) | true

Default case for all switch statements, specified as one of the values in this table.

Some coding standards, such as MISRA, require the default case for switch statements.

GenerateExampleMain — Example C/C++ main file generation

'GenerateCodeOnly' (default) | 'DoNotGenerate' | 'GenerateCodeAndCompile'

Example C/C++ main file generation, specified as one of the values in this table.

An example main function is a template to help you to write a C/C++ main function that calls generated C/C++ code. See Incorporate Generated Code Using an Example Main Function.

GenerateMakefile — Makefile generation

true (default) | false

Makefile generation during the build process, specified as one of the values in this table.

GenerateNonFiniteFilesIfUsed — Generate support files for nonfinite data only if nonfinite data is used

true (default) | false

Generation of support files for nonfinite data, specified as one of the values in this table.

Dependency:

• Setting SupportNonFinite totrue enables this parameter.

GenerateReport — Code generation report

false (default) | true

Code generation report, specified as one of the values in this table.

GpuConfig — Configuration object for GPU code generation

GpuCodeConfig object

Configuration object for generating CUDA GPU code using GPU Coder. A GpuCodeConfig object contains parameters specific to CUDA GPU code generation. To create aGpuCodeConfig object, use coder.gpuConfig (GPU Coder). For example:

cfg = coder.gpuConfig('lib'); cfg.GpuConfig

ans =

GpuCodeConfig with properties:

                Enabled: 1
             MallocMode: 'discrete'
       KernelNamePrefix: ''
           EnableCUBLAS: 1
         EnableCUSOLVER: 1
            EnableCUFFT: 1
           Benchmarking: 0
              SafeBuild: 0
      ComputeCapability: 'Auto'
CustomComputeCapability: ''
          CompilerFlags: ''
    StackLimitPerThread: 1024
        MallocThreshold: 200
 MaximumBlocksPerKernel: 0
    EnableMemoryManager: 1
       SelectCudaDevice: -1

For more information, see Generate Code Using the Command Line Interface (GPU Coder).

Dependencies: If GpuConfig is set,codegen modifies thecoder.EmbeddedCodeConfig properties to values in this table.

Hardware — Object that specifies a hardware board

coder.Hardware object

Object that specifies a hardware board. To create the coder.Hardware object, use coder.hardware. For example:

cfg = coder.config('lib'); hw = coder.hardware('Raspberry Pi'); cfg.Hardware = hw;

Before you use coder.hardware, you must install the support package for the hardware board.

Dependencies:

• Setting Hardware customizes the hardware implementation object and other configuration parameters for a particular hardware board.
• If DeepLearningConfig is set to acoder.ARMNEONConfig object andHardware is empty, thencodegen sets theGenCodeOnly property totrue.

Note:

• Suppose that you create a coder.CodeConfig object cfg in a MATLAB session and use it in another MATLAB session. If the MATLAB host computer for the second session does not have the hardware board specified in thecfg.Hardware property installed on it, this parameter reverts to its default value. The default value is []. Setting the Hardware Board option to MATLAB Host Computer in the app is equivalent to using cfg.Hardware andcfg.HardwareImplementation.ProdHWDeviceType with their default value.

To specify a hardware board for PIL execution, see PIL Execution with ARM Cortex-A at the Command Line (Embedded Coder).

HardwareImplementation — Hardware implementation object

coder.HardwareImplementation object

Hardware implementation object that specifies hardware-specific configuration parameters for C/C++ code generation. coder.config creates acoder.EmbeddedCodeConfig object with theHardwareImplementation property set to a coder.HardwareImplementation object with default parameter values for the MATLAB host computer.

— Style of preprocessor directive in generated code

UseIncludeGuard (default) | UsePragmaOnce

To prevent compilation errors due to multiple inclusion of header files, the code generator produces either #ifndef or#pragma once constructs in generated header files. If your project uses distinct files that use the same preprocessor macros, then generate code with the #pragma once construct. The compilation behavior of #pragma once is not standardized.

Specify HeaderGuardStyle as one of the values in this table.

HighlightPotentialDataTypeIssues — Highlighting of potential data type issues in the code generation report

false (default) | true

Highlighting of potential data type issues in the code generation report, specified as one of the values in this table.

HighlightPotentialRowMajorIssues — Potential row-major layout issues

true (default) | false

Display of potential row-major layout efficiency issues, specified as one of the values in this table.

See Code Design for Row-Major Array Layout.

IncludeInitializeFcn — Initialize function generation

true (default) | false

Initialize function generation, specified as one of the values in this table.

When using GPU Coder, the code generator always produces an initialize function.

IncludeTerminateFcn — Terminate function generation

true (default) | false

Terminate function generation, specified as one of the values in this table.

When using GPU Coder, the code generator always produces an terminate function.

IndentSize — Number of characters per indentation level

2 (default) | positive integer

Number of characters per indentation level, specified as a positive integer in the range [2,8].

IndentStyle — Style for placement of braces in the generated code

'K&R' (default) | 'Allman'

Style for placement of braces in the generated code, specified as one of the values in this table.

InitFltsAndDblsToZero — Assignment of float and double zero with memset

true (default) | false

Assignment of float and double zero with memset, specified as one of the values in this table.

InlineBetweenMathWorksFunctions — Control inlining between MathWorks functions

'Speed' (default) | 'Always' | 'Readability' | 'Never'

Inlining behavior at all call sites where a MathWorks calls another MathWorks function, specified as one of the values in this table.

Even if you select the 'Always' or the'Never' option for a setting, in certain cases, the code generator might not strictly follow that instruction. For example, if there is a conflict, the coder.inline('always') orcoder.inline('never') directive placed inside a function body overrides this option. For more information, see Control Inlining to Fine-Tune Performance and Readability of Generated Code.

InlineBetweenUserAndMathWorksFunctions — Control inlining between user-written functions and MathWorks functions

'Readability' (default) | 'Always' | 'Speed' | 'Never'

Inlining behavior at all call sites where a function that you wrote calls a MathWorks function, or a MathWorks function calls a function that you wrote. Specified as one of the values in this table.

Even if you select the 'Always' or the'Never' option for a setting, in certain cases, the code generator might not strictly follow that instruction. For example, if there is a conflict, the coder.inline('always') orcoder.inline('never') directive placed inside a function body overrides this option. For more information, see Control Inlining to Fine-Tune Performance and Readability of Generated Code.

InlineBetweenUserFunctions — Control inlining between user-written functions

'Speed' (default) | 'Always' | 'Readability' | 'Never'

Inlining behavior at all call sites where a function that you wrote calls another function that you wrote, specified as one of the values in this table.

Even if you select the 'Always' or the'Never' option for a setting, in certain cases, the code generator might not strictly follow that instruction. For example, if there is a conflict, the coder.inline('always') orcoder.inline('never') directive placed inside a function body overrides this option. For more information, see Control Inlining to Fine-Tune Performance and Readability of Generated Code.

InstructionSetExtensions — SIMD instruction set for target hardware

'Auto' (default) | 'SSE' | 'SSE2' | 'SSE4.1' | 'AVX' | 'AVX2' | 'FMA' | 'AVX512F' | 'Neon v7' | 'None'

Instruction sets to generate single instruction, multiple data (SIMD) code for target hardware. This list shows the dependency of the instruction sets, where each instruction set depends on the instruction sets that precede it. The code generator loads the selected instruction set and the instruction sets that it depends on. For example, if you select AVX, the code generator loads AVX, SSE4.1,SSE2, and SSE.

If you select Auto, the default setting, the code generator selects an instruction set according to your hardware board:

• MATLAB Host Computer, Intel, or AMD® － SSE2
• ARM
  － None

See Generate SIMD Code from MATLAB Functions for Intel Platforms.

When using GPU Coder, the code generator always disables InstructionSetExtensions.

InstructionSetExtensionsConfig — Options for SIMD instruction sets

InstructionSetExtensionsConfig object

Options for the SIMD instruction sets of theInstructionSetExtensions setting, specified as aInstructionSetExtensionsConfig object. Use the properties of the object to specify the options for the instruction sets. This parameter is applicable for only the instruction set Neon v7.

Example: 'InstructionSetExtensionsConfig.FMA = true'

FMA — Whether to use SIMD instructions for fused multiply add operations

false (default) | true

Whether to use SIMD instructions from theInstructionSetExtensions setting for fused multiply add operations, specified astrue or false.

JustifyMISRAViolations — Add annotations to suppress known MISRA/AUTOSAR violations

false (default) | true

Annotates the generated C/C++ code to suppress known MISRA and AUTOSAR violations, specified as one of the values in this table.

LargeConstantGeneration — Whether to write large deep learning constants to binary data files

'WriteOnlyDNNConstantsToDataFiles' (default) | 'KeepInSourceFiles'

Whether the code generator embeds large constants for a deep neural network (DNN) in the generated source code or writes these constants to binary data files, specified as one of the values in the following table. To specify the threshold (in bytes) above which the DNN constants are written to binary data files, set the LargeConstantThreshold property. The default value of this property is131072.

This property is applicable only if you generate code that does not depend on third-party deep learning libraries.

The generated binary data files are located in the code generation folder and are loaded by the generated code at run time. If you relocate these files, set the environment variable CODER_DATA_PATH to this new location before running the generated code.

The code generator always embeds the non-DNN constants in the generated source code, irrespective of the sizes of these constants.

Dependency:

• EnableDynamicMemoryAllocation enables this parameter.

LargeConstantThreshold — Threshold above which the code generator writes DNN constants to binary data files

131072 (default) | integer

The LargeConstantThreshold property specifies the threshold (in bytes) above which the constants for a deep neural network (DNN) are written to binary data files. The code generator by default sets this threshold to 131072 bytes. Depending on your application, you can set this threshold to a different integer value.

This property is applicable only if you generate code that does not depend on third-party deep learning libraries.

Dependencies: To enable this property, perform both these actions.

• Set EnableDynamicMemoryAllocation totrue.
• Set LargeConstantGeneration to'WriteOnlyDNNConstantsToDataFiles'.

LaunchReport — Automatic open of code generation report

false (default) | true

Automatic open of code generation report, specified as one of the values in this table.

LoopUnrollThreshold — Threshold on the number of iterations that determines whether to automatically unroll a for-loop and aparfor-loop

5 (default) | positive integer

Loops with fewer iterations than this threshold are candidates for automatic unrolling by the code generator. This threshold applies to allfor-loops and parfor-loops in your MATLAB code. For an individual for-loop, acoder.unroll directive placed immediately before the loop takes precedence over the loop unrolling optimization. The threshold can also apply to somefor-loops produced during code generation.

See Unroll for-Loops and parfor-Loops.

MATLABFcnDesc — MATLAB function help text in function banner

true (default) | false

MATLAB function help text in function banner in generated code specified as one of the values in this table.

If not selected, MATLAB Coder treats the help text as a user comment.

Dependencies:

• GenerateComments enables this parameter.

— Inclusion of MATLAB source code as comments in generated code

false (default) | true

Inclusion of MATLAB source code as comments in generated code, specified as one of the values in this table.

Dependency:

• GenerateComments enables this parameter.

See Tracing Generated C/C++ Code to MATLAB Source Code.

— Include line numbers of MATLAB source code as comments in the generated code

true (default) | false

Whether to include line numbers of MATLAB source code as comments in the generated code, specified astrue or false. Setting this property to false removes traceability tags from the code generation report.

Dependency:

• Setting GenerateComments totrue enables this parameter.

MaxIdLength — Maximum number of characters in generated identifiers

31 | 1024 | positive integer

Maximum number of characters in generated identifiers, specified as a positive integer in the range [31, 2048]. This property applies to generated function, type definition, and variable names. To avoid truncation of identifiers by the target C/C++ compiler, specify a value that matches the maximum identifier length of the target C/C++ compiler.

This property does not apply to exported identifiers, such as the generated names for entry-point functions or emxArray API functions. If the length of an exported identifier exceeds the maximum identifier length of the target C/C++ compiler, the target C/C++ compiler truncates the exported identifier.

Default values:

• If TargetLang is set to'C', the default value ofMaxIdLength is31.
• If TargetLang is set to'C++', the default value ofMaxIdLength is1024.

MemcpyThreshold — Minimum size for memcpy or memset optimization

64 (default) | positive integer

Minimum size, in bytes, for memcpy or memset optimization, specified as a positive integer.

To optimize generated code that copies consecutive array elements, the code generator tries to replace the code with a memcpy call. To optimize generated code that assigns a literal constant to consecutive array elements, the code generator tries to replace the code with a memset call.

The number of bytes is the number of array elements to copy or assign multiplied by the number of bytes required for the C/C++ data type.

If the number of elements to copy or assign is variable (not known at compile time), the code generator ignores theMemcpyThreshold property.

See memcpy Optimization and memset Optimization.

MultiInstanceCode — Multi-instance, reentrant code

false (default) | true

Multi-instance, reentrant code, specified as one of the values in this table.

See Reentrant Code.

This option is not supported by the GPU Coder product.

Name — Object name

'EmbeddedCodeConfig' (default) | character vector

Object name, specified as a character vector.

OptimizeReductions — Generate SIMD code for reduction operations | Parallelize for-loops performing reduction operations

'false' (default) | 'true'

To generate SIMD code for reduction operations, use one of the values as specified in this table.

See Generate SIMD Code from MATLAB Functions for Intel Platforms.

To generate parallel for-loops performing reduction operations, use one of the values as specified in this table.

See Reduction Operations Supported for Automatic Parallelization of for-loops.

OutputType — Output to build from generated C/C++ code

'LIB' | 'DLL' | 'EXE'

Output to build from generated C/C++ code, specified as one of the values in this table.

ParenthesesLevel — Parenthesization level in the generated code

'Nominal' (default) | 'Minimum' | 'Maximum'

Parenthesization level in the generated code, specified as one of the values in this table.

PassStructByReference — Pass structures by reference

true (default) | false

Pass structures by reference to entry-point functions, specified as one of the values in this table.

This parameter applies only to entry-point functions.

See Pass Structure Arguments by Reference or by Value in Generated Code.

PostCodeGenCommand — Command to customize build processing

'' (default) | character vector

Command to customize build processing after MEX function generation withcodegen, specified as a character vector.

See Build Process Customization.

PreserveExternInFcnDecls — Preservation of the extern keyword in function declarations

true (default) | false

Preservation of the extern keyword in function declarations in the generated code, specified as one of the values in this table.

PreserveArrayDimensions — N-dimensional indexing

false (default) | true

Generation of code that uses N-dimensional indexing, specified as one of the values in this table.

See Generate Code That Uses N-Dimensional Indexing.

PreserveInputData — Whether to protect entry-point input data from modification

false (default) | true

Since R2024b

Whether to protect entry-point input data from modification when the generated code is called from your custom C/C+ code, specified asfalse or true. See Generate Code That Preserves Entry-Point Input Data.

If you enable this setting, the generated code might include extra copies of the input data. If you pass large-size data, this behavior might increase the execution time and memory use of the generated code.

If you generate code for a MATLAB entry-point function that uses the same variable as both an input and an output, the code generator does not preserve this input data even when you set the PreserveInputData configuration property to true. See Avoid Data Copies of Function Inputs in Generated Code.

PreserveUnusedStructFields — Preserve unused class properties or structure fields in the generated C/C++ code

false (default) | true

Preserve unused class properties or structure fields in the generated C/C++ code, specified as one of the values in this table.

See Preserve Unused Class Properties in Generated C/C++ Code (Embedded Coder).

PreserveVariableNames — Variable names to preserve in the generated code

'None' (default) | 'UserNames' | 'All'

Variable names to preserve in the generated code, specified as one of the values in this table.

See Preserve Variable Names in Generated Code.

PurelyIntegerCode — Detection of floating-point code

false (default) | true

Detection of floating-point code, specified as one of the values in this table.

Dependency:

• Setting PurelyIntegerCode totrue disables theSupportNonFinite parameter. SettingPurelyIntegerCode tofalse enables theSupportNonFinite parameter.

ReplacementTypes — Specify custom names for MATLAB data types

coder.ReplacementTypes object

Specify custom names for these MATLAB built-in data types: double,single, uint8,uint16, uint32,uint64, int8,int16, int32,int64, char, andlogical that are in the generated C/C++ code.

Dependency:

• Setting EnableCustomReplacementTypes totrue enables theReplacementTypes parameter. See Customize Data Type Replacement (Embedded Coder).

ReportInfoVarName — Name of variable containing code generation report information

'' (default) | character vector

Name of variable to which you export information about code generation, specified as a character vector. The code generator creates this variable in the base MATLAB workspace. This variable contains information about code generation settings, input files, generated files, and code generation messages.

See Access Code Generation Report Information Programmatically andcoder.ReportInfo Properties.

ReportPotentialDifferences — Potential differences reporting

true (default) | false

Potential difference reporting, specified as one of the values in this table:

See Potential Differences Reporting.

ReqsInCode — Include requirements links as comments

false (default) | true

Option to include requirement links (Requirements Toolbox™) as comments, specified as true orfalse.

The comments appear as hyperlinks in the code generation report that navigate to the requirement and linked MATLAB code range. See Requirements Traceability for Code Generated from MATLAB Code (Requirements Toolbox).

ReservedNameArray — Names that code generator must not use for functions or variables

'' (default) | string array | cell array of character vectors | character vector

List of names that the code generator must not use for functions or variables, specified as a string arrays, cell array of character vectors, or character vector.

Multiple reserved names, specified as one of the values in this table.

RowMajor — Row-major array layout

false (default) | true

Generation of code that uses row-major array layout, specified as one of the values in this table.

See Generate Code That Uses Row-Major Array Layout.

RunInitialzeFcn — Automatically run the initialize function

true (default) | false

Generation of a call to the initialize function at the beginning of the generated entry-point functions, specified as one of the values in this table.

Dependency:

• Setting IncludeInitializeFcn andIncludeTerminateFcn totrue enables this parameter.
• Setting MultiInstanceCode totrue disables this parameter.

See Use Generated Initialize and Terminate Functions.

RuntimeChecks — Run-time error detection and reporting in generated code

false (default) | true

Run-time error detection and reporting in generated code, specified as one of the values in this table.

See Generate Standalone C/C++ Code That Detects and Reports Run-Time Errors.

SaturateOnIntegerOverflow — Integer overflow support

true (default) | false

Integer overflow support, specified as one of the values in this table.

This parameter applies only to MATLAB built-in integer types. It does not apply to doubles, singles, or fixed-point data types.

See Disable Support for Integer Overflow or Nonfinites.

SILPILDebugging — Debugging of generated code during a SIL or PIL execution

false (default) | true

Debugging of generated code during a software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

See Debug Generated Code During SIL or PIL Execution (Embedded Coder).

SILPILCheckConstantInputs — Constant input checking mode for a SIL or PIL execution

true (default) | false

Constant input checking mode for a SIL or PIL execution, specified as one of the values in this table.

See Speed Up SIL/PIL Execution by Disabling Constant Input Checking and Global Data Synchronization (Embedded Coder)

SILPILSyncGlobalData — Global data synchronization mode for a SIL or PIL execution

true (default) | false

Global data synchronization mode for a SIL or PIL execution, specified as one of the values in this table.

See Speed Up SIL/PIL Execution by Disabling Constant Input Checking and Global Data Synchronization (Embedded Coder)

SILPILVerbosity — Display communication I/O information during SIL or PIL execution

'off' (default) | 'on'

Display of communication I/O information during software-in-the-loop (SIL) or processor-in-the-loop (PIL) execution, specified as one of the values in this table.

See Troubleshooting Host-Target Communication (Embedded Coder).

StackUsageMax — Maximum stack usage per application

200000 (default) | positive integer

Maximum stack usage per application, in bytes, specified as a positive integer. Set a limit that is lower than the available stack size. Otherwise, a run-time stack overflow might occur. The C compiler detects and reports stack overflows.

See Disable Support for Integer Overflow or Nonfinites.

SupportNonFinite — Support for nonfinite values

true (default) | false

Support for nonfinite values, specified as one of the values in this table.

See Disable Support for Integer Overflow or Nonfinites.

TargetLang — Language to use in generated code

'C' (default) | 'C++'

Language to use in generated code, specified as 'C' or'C++'.

When using GPU Coder, the code generator sets TargetLang toC++.

Dependency: If DeepLearningConfig is set,codegen sets TargetLang toC++.

TargetLangStandard — Language standard to use for the generated code

'Auto' (default) | 'C89/C90 (ANSI)' | 'C99 (ISO)' | 'C++03 (ISO)' | 'C++11 (ISO)' | 'C++14 (ISO)' | 'C++17 (ISO)' | 'C++20 (ISO)'

Language standard to use for the generated code, specified as one of these character vectors:

• 'Auto'
• 'C89/C90 (ANSI)'
• 'C99 (ISO)'
• 'C++03 (ISO)'
• 'C++11 (ISO)'
• 'C++14 (ISO)'
• 'C++17 (ISO)'
• 'C++20 (ISO)'

Selecting the 'Auto' option sets theTargetLangStandard property based on the value of theTargetLang property. For C, the default standard is'C99 (ISO)'. For C++, the default standard is'C++11 (ISO)'. The code generator uses the language features and the math libraries available in the selected C/C++ standard. See Change Language Standard Used for Code Generation.

Toolchain — Toolchain to use for building a C/C++ library or executable program

'Automatically locate an installed toolchain' (default) | character vector

Toolchain to use for building a C/C++ library or executable program, specified as a character vector. The list of available toolchains depends on the host computer platform, and can include custom toolchains that you added. If you do not specify a toolchain, the code generator locates an installed toolchain.

Note:

• Suppose that you create a coder.CodeConfig object cfg in a MATLAB session and use it in another MATLAB session. If the MATLAB host computer for the second session does not have the toolchain specified in the cfg.Toolchain property installed on it, this parameter reverts to its default value. The default value is 'Automatically locate an installed toolchain'.

UseBuiltinFFTWLibrary — Generate code that uses the FFTW library shipped with MATLAB

false (default) | true

Whether to generate code that produces calls to the FFTW library shipped with MATLAB for fast Fourier transform (FFT) functions in your MATLAB code, specified as one of the values in this table.

UseBuiltinFFTWLibrary takes precedence overCustomFFTCallback if you enable both these properties.

Data Types: logical

UsePrecompiledLibraries — Whether to use precompiled libraries in generated code

'Prefer' | 'Avoid'

Since R2024b

Extent to which the generated code uses platform-specific precompiled libraries, specified as one of the values in this table.

For certain precompiled libraries (for example, BLAS, LAPACK, and FFTW), there exist individual configuration parameters that allow you to customize their usage. The UsePrecompiledLibraries parameter does not affect the use of these libraries.

Verbose — Code generation progress display (to be removed)

false (default) | ltrue

Code generation progress display, specified as one of the values in this table.

Verbosity — Code generation progress display

'Info' (default) | 'Silent' | 'Verbose'

Whether to display the status of the code generation progress at the MATLAB command line, specified as one of the values in this table.

Examples

collapse all

Specify Configuration Parameters for Generation of Standalone Code with Embedded Coder

Write a MATLAB function from which you can generate code. This example uses the function myadd that returns the sum of its inputs.

function c = myadd(a,b) c = a + b; end

Create a configuration object for generation of standalone C/C++ code (a static library, a dynamically linked library, or an executable program). For example, create a configuration object for generation of a static library.

cfg = coder.config('lib');

If Embedded Coder is installed, coder.config creates acoder.EmbeddedCodeConfig object.

Change the values of the properties for which you do not want to use the default values. For example,change the comment style in the generated code to single-line comments preceded by//.

cfg.CommentStyle = 'Single-line';

TheCommentStyle property is available only in an Embedded Coder configuration object.

Generate code by using codegen. Pass the configuration object to codegen by using the-config option. Specify that the input arguments are scalar double.

codegen myadd -config cfg -args {1 1} -report

Alternative Functionality

To use default configuration parameters for build types 'LIB','DLL', or 'EXE', use thecodegen option -config:lib,-config:dll, or -config:exe, respectively. Then, you do not have to create and pass a configuration object tocodegen.

Version History

Introduced in R2011a

expand all

R2024b: Change to default value of InlineBetweenUserAndMathWorksFunctions property

The default setting for theInlineBetweenUserAndMathWorksFunctions code configuration option is now 'Readability'.

R2024b: Support for additional language standards

In addition to C++03 (ISO) and C++11 (ISO), the code generator can generate C++ code compatible with C++14 (ISO), C++17 (ISO), and C++20 (ISO).

R2024b: CodeProfilingCodeMetrics Property Added

New property CodeProfilingCodeMetrics allows you to profile generated code using metrics from the Performance Monitoring Unit (PMU) of the hardware.

R2024b: UsePrecompiledLibraries Property Added

New property UsePrecompiledLibraries allows you to specify the extent to which the generated code uses platform-specific precompiled libraries.

R2024b: PreserveInputData Property Added

New property PreserveInputData allows you to generate code that protects entry-point input data from modification when the generated code is called from your custom C/C+ code.

R2024a: Using Quotes to Specify a Single Filename or Path That Contains White Spaces has been Removed

If you try to use quotes to specify a single filename or path that contains white space (for example, '"folder1\folder2\sp ace\fun3.c"') for theCustomInclude, CustomLibrary, andCustomSource code configuration parameters, the code generator produces an error.

R2023b: Specifying Multiple Entries in Code Configuration Objects by Using Character Vector Errors

Specifying multiple file names, paths, or reserved names in code configuration objects by using character vectors or string scalars that have delimiters produces an error. Use string arrays and a cell array of character vector instead. For example, to include multiple folder names, you can use either a string array inCustomInclude as cfg.CustomInclude = ["C:\Project","C:\Custom Files"]; or a cell array of character vectors as cfg.CustomInclude = {'C:\Project','C:\Custom Files'}; to include the path for compiling the generated code.

R2023b: Using Quotes to Specify Single Filename or Path That Contains White Spaces Warns

Using quotes to specify a single filename or path that contains white spaces (for example, '"sp ace/fun3.c"') for theCustomInclude, CustomLibrary, andCustomSource code configuration properties produces a warning and will be removed in a future release.

R2023a: DynamicMemoryAllocation Property To Be Removed

In a future release, the DynamicMemoryAllocation property will be removed.

To dynamically allocate memory for variable-size arrays, use theEnableDynamicMemoryAllocation property. To configure the dynamic memory allocation threshold, useDynamicMemoryAllocationThreshold property.

R2022b: Capability to Specify Multiple Entries in Code Configuration Objects by Using Character Vector Warns

Specifying multiple file names, paths, or reserved names in code configuration objects by using character vectors or string scalars that have delimiters produces a warning and will be removed in a future release. Use string arrays and a cell array of character vector instead. For example, to include multiple folder names, you can use either a string array in CustomInclude ascfg.CustomInclude = ["C:\Project","C:\Custom Files"]; or a cell array of character vectors as cfg.CustomInclude = {'C:\Project','C:\Custom Files'}; to include the path for compiling the generated code.

R2021a: Capability to Specify Multiple Entries in Code Configuration Objects by Using Character Vector Will Be Removed

In a future release, specifying multiple file names, paths, or reserved names in code configuration objects by using character vectors or string scalars that have delimiters will be removed. Use string arrays and a cell array of character vector instead. For example, to include multiple folder names, you can use either a string array in CustomInclude as cfg.CustomInclude = ["C:\Project","C:\Custom Files"]; or a cell array of character vectors as cfg.CustomInclude = {'C:\Project','C:\Custom Files'}; to include the path for compiling the generated code.

R2021a: Verbose Property To Be Removed

In a future release, the Verbose property will be removed.

To configure the code generation progress display, use theVerbosity property.