ChimeraUnsupportedOperators
Overview When ingesting an ONNX model, certain operators may not be supported by the system. The ChimeraUnsupportedOperators exception is thrown in such cases, indicating the presence of one or more unsupported operators within the model.
- Exception Handling Process Attempt to Ingest ONNX Model: The initial step involves attempting to ingest the ONNX model to identify any unsupported operators.
- Catch ChimeraUnsupportedOperators Exception: If unsupported operators are detected, a ChimeraUnsupportedOperators exception is raised. This exception is caught and processed to handle the unsupported operators gracefully.
- Create Test Case Folder: A folder designated for the test case is created if it does not already exist. This is to store files related to the handling of unsupported operators. Within the testcase folder the following files will be created:
CGCUnsupported.yaml: a manifest of all unsupported operators and their source onnx node names.cgcunsupported_custom_operation_seed.hpp: a seed file for custom operations to be replaced using custom operators flows supported by CGC.
- Logging: The system logs the outcome of the handling process, indicating whether the unsupported operations were successfully replaced and a seed file was provided.
ChimeraLRMOverflow
The ChimeraLRMOverflow exception is raised when a Live Register Memory (LRM) overflow occurs. This scenario happens when the aggregate size of all buffers in the live-set exceeds the total available LRM size, indicating that not all data can be concurrently live without exceeding memory constraints.
Exception Triggering Condition LRM Overflow Check: The system checks for LRM overflow by evaluating if the cumulative size of all buffers in the live-set (at any point during execution) exceeds the capacity of the available LRM.
Mitigation:
Increase the size of LRM. Future CGC optimizations may allow for the failing case to work in desired memory.
ChimeraExtSplitL2MOverflow
The ChimeraExtSplitL2MOverflow exception is triggered during the process of attempting to partition a computational graph's execution across different memory regions without exceeding the L2M constraints. This exception occurs when no viable partitioning strategy can be found that accommodates all live tensors without surpassing the available L2M space.
Partitioning Process
The system attempts to partition the computational workload into smaller, manageable segments that can fit within the L2M limitations. This involves iterating through various split strategies based on the dimensions of width and height, as well as considering different types of splits. The goal is to find a partitioning strategy that allows the workload to execute within the memory constraints.
Exception Raising Condition
If the search concludes without finding a viable split configuration that accommodates all live tensors within the L2M limits, it's determined that the current L2M size is insufficient for the given computational workload.
Mitigation:
Increase the size of LRM. Future CGC optimizations may allow for the failing case to work in desired memory.
ChimeraGeneralConvExtSplit
The ChimeraGeneralConvExtSplit exception is raised specifically in the context of attempting to perform external splitting on generalized convolution operations that cannot be accommodated within the current L2M configuration. This situation occurs when a generalized convolution operation requires data aggregation that exceeds the capabilities of the available memory and the splitting strategy.
Triggering Conditions
Generalized Convolution Detection: The system identifies a convolution operation (Conv2D) that requires generalized data aggregation. This determination is based on specific criteria or characteristics of the convolution operation that make it more complex or demanding in terms of memory requirements.
External Splitting Check: If the convolution operation is flagged for requiring generalized data aggregation and there's an attempt to apply an external split strategy to manage its memory requirements, the system checks for the feasibility of such an approach.
Infeasibility of External Splitting: When it's determined that the external splitting strategy is not supported for the specific convolution operation due to its complexity and memory demands, the system recognizes the need to alert the developer or operator to this limitation.
Mitigation
Future versions of CGC will support external splitting for General Convolution handling cases. Further we will implement optimized handling for the General Convolution case, where external splitting will be supported.
Please share the exact Conv2D parameters, input and output shapes with Support.
ChimeraNotImplemented
The ChimeraNotImplemented exception is a specialized form of the built-in NotImplementedError in Python, tailored specifically for the Chimera Graph Compiler (CGC) context. This exception is raised in scenarios where certain features, operations, or behaviors are recognized as desirable and planned for future support but are currently not implemented in the CGC. It serves as a clear signal to developers and users that, while the requested functionality is not currently available, it is acknowledged and considered for inclusion in subsequent versions of the software.
Please submit your feedback and specific use case to help us prioritize the use case in our roadmap of support.
GPNPULicenseError
The GPNPULicenseError exception is raised when an attempt is made to access or utilize features within a software system that require additional entitlements not covered by the current license. This specifically pertains to features or functionalities that are gated behind a licensing mechanism, necessitating a valid license key for access. It signals that the operation in question cannot proceed without the appropriate licensing entitlements.
ChimeraISSTimeoutError
This error is raised when a timeout occurs while waiting for input from a subprocess in the context of the Chimera ISS.
Causes
The ChimeraISSTimeoutError can occur due to the following reasons:
- A subprocess fails to produce output within the specified timeout period.
- The connection between the main process and the subprocess is interrupted or becomes unresponsive.
ChimeraISSRunimeError
This error is raised when a subprocess in the context of the Chimera ISS completes execution with a nonzero (error) exit code.
Causes
The ChimeraISSRuntimeError can occur due to the following reasons:
- The subprocess encountered an error during execution, leading to a nonzero exit code.
- Unexpected behavior or issues within the subprocess result in an abnormal termination.
Other
ChimeraException
The base ChimeraException class that all others are derived from.
ChimeraAssert
The ChimeraAssert exception is a critical error signal within a system, indicating that an unexpected condition has been encountered, one that violates the assumptions or invariants of the software's operation. This exception typically reflects scenarios where the system's state is such that continuing operation could lead to incorrect behavior, data corruption, or security vulnerabilities. The difficulty in directly pinpointing the source node or operation where the assertion failed makes it challenging to diagnose and address without further investigation.
