Function: init

Applicability

Function Usage

Performs initialization.

Prototype

• C Prototype

  1	aclError aclInit(const char *configPath)

• Python Function

  1	ret = acl.init(config_path)

Parameter Description

Return Value Description

Restrictions

• acl.init must be called before app development using pyacl APIs. Otherwise, an error may occur during the initialization of internal system resources, causing other service exceptions.

• aclInit can be called multiple times in a process, but the aclFinalize or aclFinalizeReference API must be called for deinitialization.
  • The configuration must be consistent each time aclInit is called. Otherwise, only the configuration of the first call is valid. Calling the aclInit API again may cause errors.
  • To be compatible with earlier versions, if the aclInit API is called repeatedly, the error code ACL_ERROR_REPEAT_INITIALIZE will be returned. You can ignore this error and continue to process services.
  • The aclInit and aclFinalize APIs can be called repeatedly for initialization and deinitialization, respectively. Only sequential calls are available for the two APIs.

    aclInit --> service processing --> aclFinalize --> aclInit --> service processing --> aclFinalize

    After you call aclInit multiple times, you only need to call aclFinalize once to perform deinitialization. The aclInit reference count will be reset to 0.

  • If the aclInit and aclFinalizeReference APIs are called for initialization and deinitialization, respectively, the two APIs need to be called in pairs.

    aclFinalizeReference involves reference counting. Each time aclInit is called, the reference count increases by 1. Each time aclFinalizeReference is called, the reference count decreases by 1. Deinitialization is performed only when the reference count decreases to 0.

    Initialization and deinitialization can be performed repeatedly. Both sequential and concurrent calls are available for the two APIs.

    • Sequential API calls

      

    • Concurrent API calls

      

Example of Overflow/Underflow Operator Dump Configuration

{
    "dump":{
        "dump_path":"output",
        "dump_debug":"on"
    }
}

Dump Watch Configuration for Operators

Set dump_scene to watcher to enable dump watch for operators. Below is an example of the content in the configuration file. The configuration effect is as follows: (1) After operators A and B are executed, the output of operators C and D is dumped; (2) After operators C and D are executed, the output of operators C and D is also dumped. The dump files of operators C and D in (1) will be compared with those in (2) to check whether operator A or B overwrites the output memory of operator C or D.

{
    "dump":{
        "dump_list":[
            {
                "layer":["A", "B"],
                "watcher_nodes":["C", "D"]
            }
        ],
        "dump_path":"/home/",
        "dump_mode":"output",
        "dump_scene":"watcher"
    }
}

The details are as follows:

• If the operator dump watch mode is enabled, the overflow/underflow operator dump (by configuring the dump_debug parameter) or the single-operator model dump (by configuring the dump_op_switch parameter) cannot be enabled. Otherwise, an error will be reported. Dump watch cannot be applied in the single-operator API dump scenario.
• In dump_list, the layer parameter is used to configure the names of the operators that may overwrite the memory of other operators, and the watcher_nodes parameter is used to configure the names of the operators with accuracy issues possibly due to output memory being overwritten by other operators.
  • If layer is unspecified, the output of the operators configured for watcher_nodes is dumped after all operators that support dump in the model are executed.
  • If an operator configured for layer and watcher_node is not in the static graph and static subgraph, the configuration does not take effect.
  • If an operator name configured for layer and watcher_node is duplicate, or an operator configured for layer is a collective communication operator (the operator type starts with Hcom, for example, HcomAllReduce), only the dump file of the operator configured for watcher_node is exported.
  • For a fusion operator, its name configured for watcher_node must be the name of the operator after fusion. If the name of an operator before fusion is configured, no dump file will be exported.
  • Currently, model_name cannot be configured in dump_list.
• If the operator dump watch mode is enabled, dump_path, which is the path for storing the exported dump file, must be configured.

  The exported dump files cannot be viewed using a text tool. To view the content of a dump file, convert the dump file to a NumPy file and then view the NumPy file using Python. For details about the conversion procedure, see "Viewing Dump Files" in Accuracy Debugging Tool Guide.

  dump_path can be either absolute or relative.

  • An absolute path starts with a slash (/), for example, /home.
  • A relative path starts with a directory name, for example, output.
• dump_mode is used to specify the data of the operators configured for watcher_nodes to be exported. Currently, only output can be configured.

Example of Default Device Configuration

The value of default_device is a device ID, which can be 0 or a decimal positive integer. You can call aclrtGetDeviceCount to obtain the number of available devices. The device ID range is [0, (Number of available devices – 1)].

The following is an example of the configuration file:

{
    "defaultDevice":{
        "default_device":"0"
    }
}

Example of AI Core Stack Size Configuration

Use aicore_stack_size to set the stack size, in bytes. The value must meet the following requirements:

• The value of aicore_stack_size must be an integer multiple of 16 KB. Otherwise, the value will be rounded up to meet this requirement.
• The minimum value of aicore_stack_size is 32 KB. If the input value is smaller than that, the default value 32 KB will be used.
• The maximum value of aicore_stack_size for each product is as follows:

  For Atlas A3 training products / Atlas A3 inference products , the maximum value of aicore_stack_size is 192 KB.

  For Atlas A2 training products / Atlas A2 inference products , the maximum value of aicore_stack_size is 192 KB.

  For Atlas 200I/500 A2 inference products , the maximum value of aicore_stack_size is 7,680 KB.

The following is an example of the configuration file:

{
    "StackSize":{
        "aicore_stack_size":32768
    }
}

Example of Configuring the Event Resource Scheduling Mode

Value range of event_mode: 0 is the default value, indicating the memory mode, where the number of event resources is limited by the memory. 1 indicates the hardware acceleration mode, where the number of event resources is limited by hardware specifications, but the performance is better.

The following is an example of the configuration file:

{
    "acl_graph":{
        "event_mode":"0"
    }
}

Reference

For the API call example, see Initialization and Deinitialization.

More flexible APIs are provided for enabling dump or profiling. Unlike aclInit, these APIs can be called repeatedly in a process, allowing varied dump or profiling configurations with each call.

• Obtains dump data: Function: init_dump, Function: set_dump, Function: finalize_dump If dump data does not need to be written to a file, you can obtain the dump data by using a callback function. For details, see Function: dump_reg_callback.
• Obtains profile data: Profile Data Collection