## System Architecture Diagram: Layered Processing Model
### Overview
The image displays a technical architecture diagram illustrating a three-layered system for processing computational tasks, specifically distinguishing between "Subgraph-based" and "Graph-based" approaches. The diagram shows a top-down flow of data or control from a high-level class layer, through a wrapper/runtime layer, to a low-level kernel layer. The overall system is labeled "AOCX" at the bottom.
### Components/Layers
The diagram is organized into three horizontal layers, labeled on the right side:
1. **L3: Class Layer** (Top)
* Contains two primary components:
* `Customized Layer Subgraph-based`
* `Customized Layer Graph-based`
* Each of these components contains a yellow-highlighted sub-component labeled `Forward_Tags`.
2. **L2: Wrapper Layer** (Middle)
* Contains two runtime components:
* `Subgraph-based Runtime`
* `Graph-based Runtime`
* These are connected to the L3 components above by downward-pointing blue arrows.
3. **L1: Kernel Layer** (Bottom)
* Contains two kernel components:
* `Subgraph-based Kernels`
* `Graph-based Kernels`
* These are connected to the L2 components above by downward-pointing blue arrows.
* The entire L1 layer is enclosed in a dashed box labeled `AOCX` at the bottom.
**Additional Text Elements:**
* Ellipses (`......`) appear to the left of the L3 components and below the L1 layer, suggesting the diagram is part of a larger or extensible system.
* The text "L3: Class Layer", "L2: Wrapper Layer", and "L1: Kernel Layer" are positioned to the right of their respective layers.
### Detailed Analysis
The diagram defines a clear, parallel processing pipeline with two distinct paths:
* **Path 1 (Left):** `Customized Layer Subgraph-based` (L3) → `Subgraph-based Runtime` (L2) → `Subgraph-based Kernels` (L1).
* **Path 2 (Right):** `Customized Layer Graph-based` (L3) → `Graph-based Runtime` (L2) → `Graph-based Kernels` (L1).
The `Forward_Tags` component within each L3 class layer is highlighted in yellow, indicating it is a key functional unit or data structure passed down the pipeline. The blue arrows consistently point downward, indicating a unidirectional flow of information or command from the higher abstraction layer (Class) to the lower execution layer (Kernel).
### Key Observations
1. **Symmetrical Design:** The architecture is perfectly symmetrical, with identical structural layers for both the Subgraph-based and Graph-based processing paradigms.
2. **Clear Separation of Concerns:** Each layer has a distinct responsibility: L3 for high-level customization/class definition, L2 for runtime management/wrapping, and L1 for low-level kernel execution.
3. **Unified Lower Layer:** Both processing paths converge into the single `AOCX` system at the Kernel Layer (L1), suggesting a common underlying execution framework or hardware abstraction.
4. **Forward_Tags Emphasis:** The yellow highlighting on `Forward_Tags` in the Class Layer suggests this is a critical data packet or metadata container that initiates the processing flow.
### Interpretation
This diagram represents a **modular, dual-pathway computational framework** designed to handle both subgraph-level and graph-level operations. The architecture prioritizes abstraction and separation of concerns.
* **What it demonstrates:** The system is built to support two complementary computational models (subgraph and graph) through a clean, layered interface. This allows for specialized optimization at each level (class, runtime, kernel) while maintaining a unified backend (`AOCX`).
* **Relationships:** The vertical relationships are hierarchical (abstraction to execution). The horizontal relationship between the Subgraph and Graph paths is one of parallel specialization; they are alternative or complementary methods processed by the same layered infrastructure.
* **Notable Design Choice:** The encapsulation of `Forward_Tags` within the Class Layer implies that the initial processing directive or data context is defined at the highest level and propagated downward, ensuring each subsequent layer has the necessary metadata to perform its function correctly. The ellipses (`......`) indicate this is a scalable or extensible pattern, not a closed system.
**Language Note:** All text in the image is in English.
