## Circuit Diagram and Performance Chart ### Overview The image presents a combination of a circuit diagram, a flowchart, and a performance chart. The circuit diagram illustrates a programming circuit with diagonal selection and ADC components. The flowchart outlines a process for selecting and programming devices based on weight polarity. The performance chart compares the weight error of different programming methods (ODP, TDP-Max-fill, and TDP-This work) against the target weight. ### Components/Axes **Part A: Circuit Diagram** * **Title:** Programming Circuit * **Components:** * GND (Ground) on the left and right sides. * ADC Left (Analog-to-Digital Converter on the left). * ADC Right (Analog-to-Digital Converter on the right). * PWM Circuit (Pulse Width Modulation Circuit at the bottom). * Diagonal Selection (indicated above the cell arrays). * Multiple "Unit cell" blocks, each labeled with "BL+ BL-", "SEL+ SEL-", "SL+ SL-". * Current flow arrows labeled "iPROG". **Part B: Flowchart** * **Title:** None explicitly stated, but it describes a device selection and programming process. * **Steps:** 1. "Select two devices based on weight polarity" 2. "SET both devices" 3. "Read both devices" 4. "Selection" block with calculations: gmax = max(g1SET, g2SET), gmin = min(g1SET, g2SET) 5. Decision branches based on gmax and gmin compared to G: * gmin + gmax < G: "Weight cannot fit on the two devices. No further updates." * gmax < G: "Weight needs both devices. Program device gmin. Leave gmax at SET." * gmax > G: "Weight fits on one device. Program device gmax. RESET device gmin." 6. "Iterative programming" **Part C: Performance Chart** * **Title:** None explicitly stated, but it shows weight error vs. target weight. * **Axes:** * X-axis: "Target weight, W" ranging from -1 to 1 in increments of 0.5. * Y-axis: "Weight error (%)" ranging from 2 to 16 in increments of 2. * **Legend (Top-Right):** * Blue squares: "ODP" * Orange diamonds: "TDP - Max-fill" * Yellow crosses: "TDP - This work" ### Detailed Analysis or Content Details **Part A: Circuit Diagram** * The circuit diagram shows a matrix-like structure with multiple unit cells. * Each unit cell has labels "BL+", "BL-", "SEL+", "SEL-", "SL+", "SL-". * The "Diagonal Selection" is indicated by dashed boxes. * Current flow (iPROG) is shown with red arrows. **Part B: Flowchart** * The flowchart describes an iterative programming process. * It starts by selecting two devices based on weight polarity and setting them. * The conductances (g1SET, g2SET) of the devices are read. * The maximum (gmax) and minimum (gmin) conductances are calculated. * Based on the relationship between gmax, gmin, and a threshold G, different programming actions are taken. **Part C: Performance Chart** * **ODP (Blue Squares):** The weight error starts at approximately 14% at W = -1, decreases to a minimum of around 3% at W = 0, and then increases to approximately 15% at W = 1. * **TDP - Max-fill (Orange Diamonds):** The weight error starts at approximately 10% at W = -1, decreases to a minimum of around 2% at W = 0, and then increases to approximately 13% at W = 1. * **TDP - This work (Yellow Crosses):** The weight error starts at approximately 7% at W = -1, decreases to a minimum of around 2% at W = 0, and then increases to approximately 8% at W = 1. ### Key Observations * The circuit diagram shows a specific architecture for a programming circuit. * The flowchart outlines a detailed algorithm for device selection and programming. * The performance chart demonstrates that "TDP - This work" generally achieves lower weight error compared to "ODP" and "TDP - Max-fill" across the target weight range. * All three methods exhibit the lowest weight error around W = 0. ### Interpretation The image presents a system for programming devices, likely for use in neuromorphic computing or similar applications. The circuit diagram shows the hardware architecture, while the flowchart details the programming algorithm. The performance chart provides evidence that the "TDP - This work" method is more effective in reducing weight error compared to the other two methods. The fact that all methods perform best around W = 0 suggests that programming devices to achieve weights close to zero is more accurate than programming them to achieve larger positive or negative weights. The iterative programming approach in the flowchart likely aims to refine the device weights to achieve the desired target weight with minimal error.

\n ## Diagram: Programming Circuit and Weight Error Analysis ### Overview The image presents a schematic diagram of a programming circuit for memory devices, alongside a flowchart illustrating a weight polarity selection process, and a graph showing weight error analysis for different programming strategies. The diagram appears to relate to analog weight storage using memory cells, likely for neuromorphic computing applications. ### Components/Axes **Part a (Programming Circuit):** * **Labels:** "Programming Circuit", "PWM Circuit", "ADC Left", "ADC Right", "Diagonal Selection", "GND", "I_prog", "BL+", "BL-", "SEL", "SE". * **Components:** An array of memory cells arranged in a grid. The cells are connected to programming circuitry (I_prog) and Analog-to-Digital Converters (ADCs) on the left and right. "Diagonal Selection" lines connect to the cells. * **Flow:** Current (I_prog) flows from the programming circuit to the memory cells. Signals are read by the ADCs. Diagonal selection appears to control which cells are programmed. **Part b (Weight Polarity Selection):** * **Labels:** "Select two devices based on weight polarity", "SET both devices", "Read both devices", "Selection", "Iterative programming", "g₁", "g₂", "g_SET", "g_max", "g_min", "G". * **Flowchart:** A decision-making process based on comparing weight values (g₁, g₂) to a target weight (G) and a set value (g_SET). The flowchart outlines conditions for setting, resetting, and leaving devices unchanged. * **Equations:** * g_max = max(g₁, g₂^SET) * g_min = min(g₁^SET, g₂^SET) **Part c (Weight Error Analysis):** * **Axes:** * X-axis: "Target weight, W" (ranging from approximately -1.0 to 1.0, with increments of 0.1) * Y-axis: "Weight error (%)" (ranging from approximately 4% to 16%, with increments of 2%) * **Legend (Top-Right):** * ODP (Blue Diamonds) * TDP - Max-fill (Orange Squares) * TDP - This work (Yellow Triangles) ### Detailed Analysis or Content Details **Part a (Programming Circuit):** The circuit consists of multiple identical "Unit cell" blocks. Each unit cell has BL+, BL-, SEL, and SE connections. The diagonal selection lines appear to activate rows of cells. The ADC Left and ADC Right blocks suggest a differential sensing scheme. The PWM circuit likely controls the programming current (I_prog). **Part b (Weight Polarity Selection):** The flowchart describes an iterative programming algorithm. If the maximum weight (g_max) is less than the target weight (G), both devices are set. If g_max is greater than G, one device is reset. If g_max equals G, no further updates are made. The equations define how g_max and g_min are calculated based on the individual device weights (g₁, g₂) and the set value (g_SET). **Part c (Weight Error Analysis):** * **ODP (Blue Diamonds):** The line starts at approximately ( -1.0, 14%), decreases to approximately (-0.5, 8%), increases to approximately (0.0, 10%), and then decreases to approximately (0.5, 8%), and finally increases to approximately (1.0, 14%). * **TDP - Max-fill (Orange Squares):** The line starts at approximately (-1.0, 12%), decreases to approximately (-0.5, 6%), increases to approximately (0.0, 8%), and then decreases to approximately (0.5, 6%), and finally increases to approximately (1.0, 12%). * **TDP - This work (Yellow Triangles):** The line starts at approximately (-1.0, 14%), decreases to approximately (-0.5, 6%), increases to approximately (0.0, 7%), and then decreases to approximately (0.5, 6%), and finally increases to approximately (1.0, 14%). All three lines exhibit a U-shaped curve, indicating that the weight error is minimized near a target weight of 0 and increases as the target weight moves away from 0 in either direction. ### Key Observations * The weight error is generally lower for all three methods near a target weight of 0. * "TDP - This work" and "TDP - Max-fill" show similar performance, with "TDP - Max-fill" having slightly lower error at -0.5 and 0.5. * ODP has the highest weight error at the extreme target weights (-1.0 and 1.0). * The iterative programming algorithm in Part b is designed to refine the weights towards the target value. ### Interpretation The diagram illustrates a system for analog weight storage and programming, potentially for neuromorphic computing. The programming circuit (Part a) provides a mechanism for setting and resetting memory cells. The weight polarity selection algorithm (Part b) ensures that the weights are adjusted iteratively towards the desired target. The weight error analysis (Part c) demonstrates the accuracy of different programming strategies. The U-shaped error curves suggest that the system has limited dynamic range and that the accuracy degrades as the target weight moves further from the center. The "TDP - Max-fill" strategy appears to offer a slight improvement in accuracy compared to the other methods, particularly near the target weight of 0. The iterative programming approach is crucial for achieving accurate weight storage, as it allows for fine-tuning of the weights based on feedback from the memory devices. The diagonal selection scheme likely helps to reduce interference between adjacent cells during programming. The use of ADCs suggests that the system relies on precise analog-to-digital conversion for weight sensing and control.

## Technical Diagram and Chart Analysis ### Overview The image is a composite technical figure containing three distinct parts labeled **a**, **b**, and **c**. It appears to describe a hardware system for programming and verifying weights in a resistive memory or neuromorphic computing array, along with a performance evaluation chart. ### Components/Axes **Part a: Circuit Diagram** * **Title/Label:** "Programming Circuit" (top center). * **Major Blocks:** * "Programming Circuit" (top, dashed box). * "Diagonal Selection" (two instances, dashed boxes). * "ADC Left" and "ADC Right" (left and right sides, dashed boxes). * "PWM Circuit" (bottom, dashed box). * **Unit Cell Structure:** Multiple identical "Unit cell" blocks are shown. Each contains internal labels: * `BL+`, `BL-` (Bit Lines) * `SEL+`, `SEL-` (Select Lines) * `SL+`, `SL-` (Source Lines) * **Signals & Connections:** * `GND` (Ground) lines are shown at the top and right. * `i_PROG` (Programming Current) is indicated with red arrows pointing downward into two unit cells. * Orange lines represent connections from the "PWM Circuit" to the unit cells. * Black lines represent other control and data paths. * Ellipses (`...`) indicate the array extends further. **Part b: Flowchart** * **Process Flow:** A top-down flowchart describing an algorithm. * **Text Blocks (in order):** 1. "Select two devices based on weight polarity" 2. "SET both devices" 3. "Read both devices" 4. "→ g₁^SET, g₂^SET" 5. "Selection" (central node) 6. "g_max = max(g₁^SET, g₂^SET)" 7. "g_min = min(g₁^SET, g₂^SET)" * **Decision Logic (Three branches from "Selection"):** * **Condition 1:** "g_min + g_max < G" * **Outcome:** "Weight cannot fit on the two devices. No further updates." * **Condition 2:** "g_max < G" * **Outcome:** "Weight needs both devices. Program device g_min. Leave g_max at SET." * **Condition 3:** "g_max > G" * **Outcome:** "Weight fits on one device. Program device g_max. RESET device g_min." * **Final Step:** All branches lead to "Iterative programming". **Part c: Line Chart** * **Chart Type:** Line chart with markers. * **X-Axis:** * **Label:** "Target weight, W" * **Scale:** Linear, from -1 to 1. Major ticks at -1, -0.5, 0, 0.5, 1. * **Y-Axis:** * **Label:** "Weight error (%)" * **Scale:** Linear, from 2 to 16. Major ticks at 2, 4, 6, 8, 10, 12, 14, 16. * **Legend (Top-Left Corner):** * **Blue line with square markers:** "ODP" * **Orange line with diamond markers:** "TDP - Max-fill" * **Yellow line with 'x' markers:** "TDP - This work" ### Detailed Analysis **Part a: Circuit Operation** The diagram illustrates a programming scheme for a crossbar-like array of memory cells. The "Programming Circuit" and "PWM Circuit" provide the necessary signals. "Diagonal Selection" logic appears to activate specific unit cells. The red `i_PROG` arrows indicate that programming current is injected into selected cells. The presence of "ADC Left" and "ADC Right" suggests readout circuitry for measuring cell states (conductance). **Part b: Algorithm Logic** The flowchart details a "TDP" (likely Two-Device Programming) algorithm. It uses a pair of devices (with conductances g₁^SET and g₂^SET) to represent a single target weight. The core logic compares the sum and maximum of the two conductances against a threshold `G` to decide how to program the weight: using both devices, using one device (and resetting the other), or deeming the weight unrepresentable. **Part c: Performance Data** * **Trend Verification:** * **ODP (Blue Squares):** Forms a symmetric "V" shape. Error is highest (~15%) at the extremes (W = -1 and W = 1) and lowest (~2.5%) at the center (W = 0). * **TDP - Max-fill (Orange Diamonds):** Also forms a "V" shape but is consistently lower than ODP. Error ranges from ~11% at W = -1 to a minimum of ~2.5% at W = 0, then back to ~13% at W = 1. * **TDP - This work (Yellow 'x's):** Shows a different, flatter profile. Error is relatively stable between ~6% and 8% across the entire range of W, with a slight dip near W = 0 (~3%). It has the lowest error for |W| > 0.2 approximately. * **Key Data Points (Approximate):** * At W = -1: ODP ~15%, TDP-Max-fill ~11%, TDP-This work ~7.5%. * At W = 0: All methods converge to a minimum error of ~2.5-3%. * At W = 1: ODP ~15%, TDP-Max-fill ~13%, TDP-This work ~8%. ### Key Observations 1. **Spatial Layout:** The legend in chart **c** is placed in the top-left quadrant, avoiding overlap with the data lines which are concentrated in the center and right. 2. **Symmetry:** The ODP and TDP-Max-fill error curves are roughly symmetric around W = 0, suggesting the programming error is a function of the weight's magnitude, not its sign. 3. **Performance Inversion:** The proposed method ("TDP - This work") trades off a slightly higher minimum error at W=0 for significantly improved (lower) error across most of the weight range, especially for larger magnitude weights. It eliminates the high-error "V" shape. 4. **Algorithm-Chart Link:** The flowchart in **b** explains the mechanism behind the "TDP" lines in chart **c**. The "ODP" likely stands for "One-Device Programming," serving as a baseline. ### Interpretation This figure presents a complete technical narrative: a hardware architecture (**a**), a novel programming algorithm for that hardware (**b**), and empirical results proving the algorithm's superiority (**c**). The data demonstrates that the proposed Two-Device Programming (TDP) method, particularly the variant labeled "This work," provides a more uniform and generally lower weight programming error compared to both One-Device Programming (ODP) and an alternative TDP strategy ("Max-fill"). The key innovation appears to be the decision logic in the flowchart that intelligently assigns weights to one or two devices based on conductance thresholds, avoiding the high-error regimes seen in the other methods at extreme weight values. This suggests the method is more robust and reliable for implementing neural networks or other analog computing tasks where accurate weight representation across a full range is critical. The circuit diagram confirms this is implemented in a scalable array architecture with peripheral programming and readout circuits.

## Circuit Diagram: Programmable Device Architecture ### Overview The diagram illustrates a programmable circuit architecture with diagonal selection, unit cells, and analog-to-digital converters (ADC). It includes a programming circuit, diagonal selection logic, and a PWM circuit. ### Components/Axes - **Top Section**: - **Programming Circuit**: Contains labeled unit cells (e.g., "BL", "BL'", "SEL", "SEL'") with bidirectional current paths (red arrows labeled *I_PROG*). - **Diagonal Selection**: Connects unit cells via orange lines, with labels like "BL-BL'", "SEL-SEL'". - **ADC Left/Right**: Grounded (GND) and connected to unit cells via black lines. - **Bottom Section**: - **PWM Circuit**: Grounded and linked to unit cells via black lines. ### Detailed Analysis - **Unit Cells**: Each cell has labeled terminals (e.g., "BL", "BL'", "SEL", "SEL'") with bidirectional current flow. - **Connections**: Diagonal selection paths (orange) link unit cells across rows. - **Current Flow**: Red arrows (*I_PROG*) indicate programming current direction. ### Key Observations - Symmetrical design with mirrored ADC left/right sections. - Diagonal selection enables cross-row connectivity between unit cells. --- ## Flowchart: Iterative Programming Algorithm ### Overview The flowchart outlines an iterative programming method for device selection and weight adjustment. ### Components/Axes 1. **Initial Step**: - **Select two devices based on weight polarity**. - **SET both devices** and **read both devices** to compute $ g_1^{SET}, g_2^{SET} $. 2. **Selection Logic**: - $ g_{max} = \max(g_1^{SET}, g_2^{SET}) $, $ g_{min} = \min(g_1^{SET}, g_2^{SET}) $. - Three conditional branches: - **Weight cannot fit**: $ g_{min} + g_{max} < G $ → No further updates. - **Weight needs both devices**: $ g_{max} < G $ → Leave $ g_{max} $ at SET. - **Weight fits on one device**: $ g_{max} > G $ → Reset $ g_{min} $. 3. **Iterative Programming**: Loop back to device selection. ### Key Observations - Conditional logic adapts based on weight polarity and magnitude. - Emphasizes iterative optimization of device states. --- ## Line Graph: Weight Error vs. Target Weight ### Overview The graph compares weight error (%) for three methods (ODP, TDP - Max-fill, TDP - This work) across target weights $ W \in [-1, 1] $. ### Components/Axes - **X-axis**: Target weight $ W $ (range: -1 to 1). - **Y-axis**: Weight error (%) (range: 0 to 16%). - **Legend**: - **ODP**: Blue squares (lowest error). - **TDP - Max-fill**: Red diamonds (moderate error). - **TDP - This work**: Yellow triangles (highest error). ### Detailed Analysis - **Trends**: - All methods show a V-shaped error curve with minima near $ W = 0 $. - **ODP** consistently has the lowest error (e.g., ~2% at $ W = 0 $). - **TDP - This work** exhibits the highest error (e.g., ~14% at $ W = 0 $). - **Notable Outliers**: - TDP - This work shows a sharp peak at $ W = 0.5 $ (~12% error). ### Key Observations - ODP outperforms other methods across all $ W $. - TDP - This work has significantly higher errors, suggesting suboptimal performance. --- ## Interpretation 1. **Circuit and Algorithm Synergy**: - The programmable circuit (a) enables dynamic device selection via diagonal paths, while the flowchart (b) formalizes the iterative logic for optimizing device states. - The PWM circuit likely modulates current for precise weight adjustments. 2. **Graph Insights**: - **ODP’s Efficiency**: Its low error suggests superior weight precision, possibly due to optimized device selection. - **TDP - This work’s Limitations**: Higher errors may stem from less effective programming strategies (e.g., suboptimal $ g_{min} $ resets). 3. **Practical Implications**: - ODP is ideal for applications requiring minimal weight error. - TDP - This work may need refinement for real-world deployment. 4. **Unresolved Questions**: - Why does TDP - This work underperform? Is it due to algorithmic constraints or hardware limitations? - How does diagonal selection impact error rates compared to other architectures?