Multi-die integrated circuit with data processing engine array

The multi-die IC with a DPE array and flexible interface addresses integration challenges by enabling efficient signal routing and predictable performance across dies with different technologies and domains, enhancing design flexibility and reducing complexity.

KR1020260161667APending Publication Date: 2026-11-09XILINX INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
KR1020267036094
Authority / Receiving Office
KR · KR
Patent Type
Applications
Current Assignee / Owner
Priority Date
2020-09-28
Filing Date
2021-09-21
Publication Date
2026-11-09

AI Technical Summary

Technical Problem

Existing integrated circuits (ICs) face challenges in efficiently integrating multiple dies with different process technologies, power domains, and clock domains, leading to complex signal routing and limited flexibility in design.

Method used

The implementation of a multi-die IC with a data processing engine (DPE) array that allows for communication through shared memory, stream switches, and direct core-to-core connections, along with a DPE interface supporting both logical and physical interfaces, enabling flexible integration of dies with different process technologies and independent power/clock domains.

Benefits of technology

This approach enhances design flexibility, allows for efficient signal routing, and ensures predictable performance by eliminating cache coherency overhead and input interrupts, while supporting diverse process technologies and independent power/clock domains.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure PAT00005_ABST
    Figure PAT00005_ABST
Patent Text Reader

Abstract

A multi-die integrated circuit (IC) may include an interposer and a first die coupled to the interposer. The first die may include a data processing engine (DPE) array, and the DPE array includes a plurality of DPEs and a DPE interface coupled to the plurality of DPEs. The DPE interface has a logical interface and a physical interface. The multi-die IC may also include a second die coupled to the interposer. The second die may include a die interface. The DPE interface and the die interface are configured to communicate through the interposer.
Need to check novelty before this filing date? Find Prior Art

Description

Technology Field

[0001] The present disclosure relates to integrated circuits (ICs), and more specifically, to multi-die ICs comprising a data processing engine array. Background Technology

[0002] Integrated circuits (ICs) may be implemented using various different architectures. A single-die architecture is one in which a single die is contained within a package. The dies may be homogeneous in that the die contains multiple similar or identical circuits. In other cases, the dies may be heterogeneous in that the die contains various different types of circuits and / or systems. A multi-die architecture is one in which multiple dies are contained within a single package. Within the package, the dies are linked to communicate with each other. For reference, the technology forming the background of the present invention is disclosed in the following published patent application. (Patent Document 1) US 2019 / 0303328A1 (2019.10.03)

[0003] In one embodiment, a multi-die integrated circuit (IC) comprises an interposer and a first die coupled to the interposer. The first die comprises a data processing engine (DPE) array, and the DPE array comprises a plurality of DPEs and a DPE interface coupled to the plurality of DPEs. The DPE interface has a logical interface and a physical interface. The multi-die IC may also comprise a second die coupled to the interposer. The second die may comprise a die interface. The DPE interface and the die interface are configured to communicate through the interposer.

[0004] In another embodiment, the multi-die IC comprises a package substrate, a first die coupled to the package substrate—the first die is configured as an interconnect bridge—and a second die coupled to the package substrate and the first die. The second die comprises a DPE array, the DPE array comprises a plurality of DPEs and a DPE interface coupled to the plurality of DPEs. The DPE interface has a logical interface and a physical interface. The multi-die IC may also comprise a third die coupled to the package substrate and the first die, and the third die comprises a die interface. The DPE interface and the die interface are configured to communicate through the first die.

[0005] The description section of this invention is provided solely to introduce specific concepts, not to identify any core or essential features of the gist of the claimed invention. Other features of the inventive arrangements of the invention will be apparent from the accompanying drawings and the following detailed description. Brief explanation of the drawing

[0006] Arrangements of the present invention are illustrated by way of example in the accompanying drawings. However, the drawings should not be construed as limiting the arrangements of the present invention only to the specific embodiments illustrated. Various aspects and advantages will become apparent from a review of the following detailed description and by reference to the drawings.

[0007] FIGS. 1A and FIGS. 1B illustrate exemplary embodiments of a device having a plurality of dies.

[0008] FIGS. 2A and FIGS. 2B illustrate other exemplary embodiments of a device having a plurality of dies.

[0009] FIG. 3 illustrates another exemplary embodiment of a device having a plurality of dies.

[0010] FIG. 4 illustrates an exemplary implementation of a data processing engine (DPE) array.

[0011] FIGS. 5A and 5B illustrate exemplary architectures of DPEs of DPE arrays.

[0012] Figures 6a, 6b, and 6c illustrate exemplary architectures for the tiles of the logical interface of the DPE interface.

[0013] Figure 7 illustrates an exemplary implementation of the interface of a tile of a logical interface.

[0014] Figure 8 illustrates another exemplary implementation example of the interface of a tile of a logical interface.

[0015] FIG. 9 illustrates an exemplary implementation of a direct memory access engine of a tile of a logical interface.

[0016] FIG. 10 illustrates an exemplary implementation of physical interfaces for a device having multiple dies.

[0017] FIG. 11 illustrates another exemplary implementation of physical interfaces for a device having multiple dies.

[0018] FIG. 12 illustrates another exemplary implementation of physical interfaces for a device having multiple dies.

[0019] FIG. 13 illustrates an exemplary implementation including a plurality of DPE interfaces.

[0020] FIG. 14 illustrates another exemplary implementation including multiple DPE interfaces.

[0021] FIG. 15 illustrates another exemplary implementation including multiple DPE interfaces.

[0022] FIG. 16 illustrates another exemplary implementation including multiple DPE interfaces.

[0023] FIG. 17 illustrates another exemplary implementation including multiple DPE interfaces. Specific details for implementing the invention

[0024] The present disclosure is concluded by claims defining novel features, but it is believed that the various features described in the present disclosure will be better understood in conjunction with the description in the drawings. The process(s), machine(s), manufacture(s), and any variations thereof described in the present disclosure are provided for illustrative purposes. Specific structural and functional details described in the present disclosure should be interpreted not as limiting, but solely as grounds for the claims and as representative grounds to instruct those skilled in the art to adopt the features described in any suitable detailed structure. Furthermore, the terms and phrases used in the present disclosure are not intended to be limiting, but rather to provide an understandable description of the features described.

[0025] The present disclosure relates to integrated circuits (ICs), and more specifically, to multi-die ICs comprising a data processing engine (DPE) array. A DPE array refers to a plurality of hardwired and configurable circuit blocks referred to as data processing engines (DPEs) together with a DPE interface. Each DPE may include a core capable of performing data processing operations together with a memory module. DPEs within a DPE array may communicate with each other through various different mechanisms. In one embodiment, DPEs may communicate with each other through a shared memory architecture in which the cores can access a memory module in the same DPE and one or more other memory modules located in different DPEs. In another embodiment, DPEs may communicate with each other through stream switches capable of transmitting data streams among the DPEs. In yet another embodiment, the cores of a DPE array may be directly connected by cascade connections that allow one core to directly transmit data from its internal registers to one or more other cores of other DPEs in the DPE array.

[0026] The DPE interface implements circuitry that enables one or more other circuits to communicate with the DPE array. These different circuits may be implemented on the same die as the DPE array, on other dies within the same package as the DPE array, or outside the package containing the DPE array. For example, in the context of a device in which one (or more) dies are implemented using multiple dies containing the DPE array, the DPE interface facilitates communication with other circuits on the same die, with one or more circuits implemented on different dies of the device, with circuits outside the package containing the DPE array, or with any combination of the aforementioned.

[0027] The DPE interface of the DPE array may include a logical interface and a physical interface. The logical interface may be implemented using a tiled architecture in which each tile can communicate with a subset of the DPEs of the DPE array. The physical interface may be implemented using one or more different architectures described in this disclosure with reference to the drawings. In some cases, the physical interface may be implemented using a standardized interface that allows different types of dies to be included in a package and may communicate with the DPE array using the standardized interface.

[0028] Significant flexibility is provided to IC designers by implementing a DPE array on a specific die or on its own dedicated die, and by including different types of dies in the same package. In this regard, the arrays of the invention described in this disclosure provide various advantages through different types of monolithic, single-die architectures. For example, a die implementing the DPE array may be implemented using a specific type of process technology (e.g., feature size, technology node, or process node), while other dies that are communicably linked to the DPE array may be implemented using different process technologies. The term "process technology" refers to a specific semiconductor manufacturing process and the design rules for that specific semiconductor manufacturing process. Different process technologies often, generally, refer to different circuit creations and architectures where the smaller the technology node with respect to the process technology, the smaller the feature size of the electronic components.

[0029] In one or more exemplary embodiments, different dies of a package may be contained in different power domains. A power domain refers to a circuit portion that is powered by the same power supply or power rail. Different power domains may have different potentials and may be powered on and / or off independently of other power domains. In the exemplary embodiments described in this disclosure, each die may be powered on or off independently of other dies or dies.

[0030] In one or more exemplary embodiments, different dies of a package may be contained in different clock domains. A clock domain refers to a circuit portion powered by the same clock source. Different clock domains may have different clock sources and, as such, may use independent clock signals. For example, the clock signals of different clock domains may have different clock frequencies and / or phases. In the exemplary embodiments described in this disclosure, each die may be clocked by a different clock source and, as such, may operate based on clock signals of different frequencies and / or phases.

[0031] Further embodiments of the arrangements of the present invention will be described in more detail below with reference to the drawings. For the purpose of simplifying and clarifying the example, the elements depicted in the drawings are not necessarily drawn to scale. For example, the dimensions of some elements may be exaggerated relative to others for clarity. Furthermore, where deemed appropriate, reference numbers are repeated in the drawings to indicate corresponding, similar, or alike features.

[0032] FIGS. 1a and FIGS. 1b are taken collectively to illustrate an exemplary embodiment of an IC (100). For the purposes of discussion, FIGS. 1a and FIGS. 1b may be collectively referred to as “ FIGS. 1.” In the example of FIGS. 1, the IC (100) is implemented as a multi-die IC. Furthermore, one or more of the dies include a DPE array (110). In the present disclosure, the term “multi-die IC” means an integrated circuit implemented to include two or more dies that are communically linked and contained within a single package.

[0033] FIG. 1a illustrates a topographical view of an IC (100). In the example of FIG. 1a, the IC (100) is implemented as a "stacked die" type device formed by stacking a plurality of dies. The IC (100) includes an interposer (102), a die (104), a die (106), and a package substrate (108). Each of the dies (104 and 106) is attached to a surface of the interposer (102), e.g., a top surface. In one embodiment, the dies (104 and 106) are attached to the interposer (102) using flip-chip technology. The interposer (102) is attached to the top surface of the package substrate (108).

[0034] Generally, the interposer (102) is an intermediate die placed between the dies (104, 106) and the package substrate (108). The interposer (102) is implemented to provide interconnection, routing, and / or ground / power planes. The package substrate (108) provides mechanical base supports for the package and electrical interfaces for connecting nodes outside the package. For convenience of illustration, the IC (100) may include a cap portion not shown in FIG. 1 or FIG. 2.

[0035] In the example of FIG. 1a, the interposer (102) is a die having a flat surface on which the dies (104 and 106) are stacked horizontally. As illustrated, the dies (104 and 106) are located side by side on the flat surface of the interposer (102). The number of dies shown on the interposer (102) in FIG. 1a is for illustrative purposes only and is not for limitation. In other exemplary embodiments, more than two dies may be mounted on the interposer (102).

[0036] The interposer (102) provides a common mounting surface and electrical coupling for each of the dies (104 and 106). The manufacture of the interposer (102) may include one or more process steps that allow the deposition of one or more conductive layers patterned to form wires. These conductive layers may be formed of aluminum, gold, copper, nickel, various silicides, and / or other suitable materials. The interposer (102) may also be manufactured using one or more additional process steps that allow the deposition of one or more dielectric or insulating layer(s), such as silicon dioxide, for example. The interposer (102) may also include vias and through vias (TVs). The TVs may be through silicon vias (TSVs), through glass vias (TGVs), or other via structures, depending on the specific materials used to implement the interposer (102) and its substrate. When the interposer (102) is implemented as a passive die, the interposer (102) may only have various types of solder bumps, vias, wires, TVs, and under bump metallization (UBM). When the interposer (102) is implemented as an active die, the interposer (102) may include additional process layers that form one or more active devices by reference to electrical devices such as transistors, diodes, etc., including PN junctions.

[0037] The die (104) may be implemented as an active die and may include one or more DPE arrays (110). An active die is a die that includes one or more active devices. In one embodiment, the die (104) may include only the DPE array (110) (e.g., only the DPE array (110) that includes any circuit part necessary to communicate with other circuits located outside the die (104)). In another embodiment, the die (104) may include the DPE array (110) and additional circuit blocks capable of performing other functions. The die (106) may be implemented as a passive die or an active die. For illustrative purposes, the die (104) may include one or more DPE arrays (110), while the die (106) implements one or more different subsystems. Exemplary subsystems are described in this disclosure. In one embodiment, the die (106) may also include one or more DPE arrays (110). The examples provided in this disclosure are for illustrative purposes only and are not intended to be limiting. For example, the IC (100) may include more than two dies that are of different types and / or provide functions different from those described in this disclosure.

[0038] FIG. 1b is a side cross-sectional view of the IC (100) of FIG. 1a. FIG. 1b illustrates a drawing of the IC (100) taken along the 1B-1B cross-section line from FIG. 1a. Each of the dies (104 and 106) is electrically and mechanically bonded to a first planar surface of the interposer (102) through solder bumps (112). In one example, the solder bumps (112) are implemented as micro-bumps. Still, any of the various other techniques may be used to attach the dies (104 and 106) to the interposer (102). For example, bond wires or edge wires may be used to mechanically and electrically attach the dies (104 and 106) to the interposer (102). In another example, an adhesive material may be used to mechanically attach the dies (104 and 106) to the interposer (102). Attachment of the dies (104 and 106) to the interposer (102) using solder bumps (112) is provided for illustrative purposes only and is not intended as a limitation, as illustrated in FIG. 1b.

[0039] The interposer (102) includes one or more conductive layers (114), exemplified by dashed or dotted lines in the interposer (102). The conductive layers (114) are implemented using any metal layer among various metal layers such as those previously described. The conductive layers (114) are processed to form patterned metal layers that implement the wires (116) of the interposer (102). A wire coupling at least two different dies, e.g., dies (104 and 106), is referred to as an inter-die wire. In the example of FIG. 1b, the wires (116) formed by the patterned metal layers (114) within the interposer (102) are inter-die wires. The wires (116) transmit inter-die signals between the dies (104 and 106). For example, each of the wires (116) allows for the exchange of signals between the dies (104 and 106) by coupling the solder bump (112) under the die (104) to the solder bump (112) under the die (106). The wires (116) may be data wires. In another embodiment, the wires (116) may include one or more power wires. The power wire may be a wire that carries a potential or a wire that has a ground or reference potential.

[0040] Different types of the conductive layers (114) and wires (116) may be coupled together using vias (118). Generally, via structures are used to implement vertical conductive paths. A vertical conductive path refers to a conductive path perpendicular to the process layer of the device. In this regard, the vertical portions of the wires (116) in contact with the solder bumps (112) are implemented as vias (118). The use of multiple conductive layers to implement interconnects within the interposer (102) allows for a greater number of signals to be routed and enables more complex routing of signals to be achieved within the interposer (102).

[0041] TVs (122) are vias that form an electrical connection extending vertically across the interposer (102), for example, through a substantial portion, if not all, of the interposer (102). The TVs (122), such as wires and vias, may be formed from any of the various different conductive materials, including, but not limited to, copper, aluminum, gold, nickel, various silicides, and / or other suitable materials. As illustrated, each TV (122) extends from the bottom surface of the interposer (102) to the conductive layer (114) of the interposer (102). The TVs (122) may be additionally coupled to the solder bump (112) through one or more of the conductive layers (114) along with one or more vias (118).

[0042] Solder bumps (120) can be used to mechanically and electrically couple a second planar surface of the interposer (102) to a package substrate (108). In certain exemplary embodiments, the solder bumps (120) are implemented as C4 (controlled collapse chip connection) balls. The package substrate (108) includes conductive paths (124) that couple different solder bumps (120) to one or more nodes under the package substrate (108) and to other circuit structures such as circuit boards. Thus, one or more of the solder bumps (120) couple circuits within the interposer (102) to nodes outside the IC (100) through circuits or wiring within the package substrate (108).

[0043] FIGS. 2a and 2b, taken collectively, illustrate other exemplary embodiments of the IC (100). For the purposes of discussion, FIGS. 2a and 2b may be collectively referred to as “ FIGS. 2”. In the example of FIGS. 2, the IC (100) is implemented as a multi-die IC. The dies (104 and 106) may be implemented as described in relation to FIGS. 1. For example, the die (104) may be an active die comprising one or more DPE array(s) (110). The circuitry of the die (104) may include only the DPE array (110) comprising any circuitry necessary to communicate with nodes located outside the die (104). In another example, the die (104) may include the DPE array (110) and additional circuitry. The die (106) may be passive or active. The die (106) may also include one or more DPE arrays.

[0044] FIG. 2a illustrates a topographical view of an IC (100). In the example of FIG. 2a, the dies (104 and 106) are communicably linked by a bridge die (202). The bridge die (202) may be embedded within a package substrate (108). An example of the bridge die (202) is the Embedded Multi-Die Interconnect Bridge (EMIB) available from Intel Corporation, Santa Clara, California. It should be understood that the exemplary bridge dies provided in this disclosure are for illustrative purposes only and are not for limitation.

[0045] A package substrate (108) including a bridge die (202) provides a common mounting surface and electrical coupling for each of the dies (104 and 106). The bridge die (202) implements an interconnect circuit portion, such as one or more patterned metal layers, capable of communicably linking the dies (104) to the die (106). In one embodiment, the bridge die (202) is a passive die. In another embodiment, the bridge die (202) is an active die. The dies (104 and 106) are located side by side on a planar surface formed by the package substrate (108) and the bridge die (202). The number of dies shown in FIG. 2a is for illustrative purposes only and is not for limitation. In other exemplary embodiments, more than two dies may be mounted on the package substrate (108) and may be communicably linked by additional bridge dies (202).

[0046] In the example of FIG. 2a, the die (104) may be implemented as an active die comprising one or more DPE arrays (110). The die (106) may be implemented as a passive die or an active die. The die (106) may be configured to implement any of the different subsystems described in this disclosure, comprising one or more additional DPE arrays. The examples provided in this disclosure are for illustrative purposes only and are not intended to be limiting. For example, the IC (100) of FIG. 2 may include more than two dies in which the dies are of different types and / or functions.

[0047] FIG. 2b is a side cross-sectional view of the IC (100) of FIG. 2a. FIG. 2b illustrates a drawing of the IC (100) taken along the 2B-2B cross-section from FIG. 2a. Each of the dies (104 and 106) is electrically and mechanically coupled to the first planar surface of the package substrate (108) and the first surface of the bridge circuit (202) via solder bumps (204 and 206). In one example, the solder bumps (204 and / or 206) are implemented as micro-bumps. In one embodiment, the solder bumps used to connect the dies (104) and dies (106) to the package substrate (108) may be larger in size and / or have a larger spacing than those used to connect the dies (104) and dies (106) to the bridge die (202). For example, the solder bumps (206) may be spaced closer together than the solder bumps (204).

[0048] The bridge die (202) implements a circuit portion that links the die (104) to the die (106) so that they can communicate. Thus, signals exchanged between the dies (104 and 106) are transmitted through the bridge die (202). In this regard, the inter-die wires (116) of the example in FIG. 2b are implemented within the bridge die (202). In one exemplary embodiment, the bridge die (202) includes short interconnect wires for linking the die (104) to the die (106) so that they can communicate. The bridge die (202) does not include any TVs that enable communication between the die (104) and the solder bumps (208) or between the die (106) and the solder bumps (208). In other words, the bridge die (202) is reserved and used only for communication between the dies (104 and 106) and does not provide any access by the die (104) or die (106) to nodes outside the IC (100).

[0049] In the example of FIG. 2b, the dies (104 and 106) communicate with circuitry outside the package by package traces (210), for example, through solder bumps (208). In one example where the bridge die (202) is implemented as an active die, the bridge die may be coupled to one or more of the solder bumps (208) by one or more additional package traces (210) not shown in FIG. 2b.

[0050] In an exemplary embodiment, the IC (100) may be implemented such that the dies (104 and 106) are in the same power domain, as described in relation to FIG. 1 and / or FIG. 2. In another exemplary embodiment, the dies (104 and 106) of FIG. 1 and / or FIG. 2 may be implemented in different power domains and may be powered on and off independently of each other. Furthermore, as discussed, the dies (104 and 106) may operate at different voltage levels when implemented in different power domains. When operating at different voltage levels, the dies (104 and 106), the interposer (102), and / or the bridge die (202) may include suitable interface circuitry that allows signals to pass between different power domains.

[0051] In another exemplary embodiment, the IC (100) may be implemented such that the dies (104 and 106) operate as part of the same clock domain, as described in relation to FIG. 1 and / or FIG. 2. Accordingly, the dies (104 and 106) of FIG. 1 and / or FIG. 2 may be implemented in different clock domains and thus may be clocked at different frequencies.

[0052] In an exemplary embodiment, the IC (100) may be implemented such that the dies (104, 106), interposer (102), and / or bridge die (202) are implemented using different process technologies (e.g., with different feature sizes), as described in relation to FIG. 1 and / or FIG. 2. In one example, the die (104) containing the DPE array (110) may be implemented using a 3 nm process technology, while the die (106) is implemented using a 16 nm technology.

[0053] FIG. 3 illustrates another example of an IC (100). In the example of FIG. 3, only dies (104 and 106) are illustrated. In one embodiment, the dies (104 and 106) may be coupled by inter-die wires (116) using an interposer as described in relation to FIG. 1. In another embodiment, the dies (104 and 106) may be coupled by inter-die wires (116) using a bridge die embedded in a package substrate as described in relation to FIG. 2.

[0054] The die (104) includes a DPE array (110). The DPE array (110) includes a DPE interface (302) having a logical interface (304) and a physical interface (306). The die (106) includes a die interface (308) having a logical interface (310) and a physical interface (312). The die-to-die wires (116) may connect the physical interface (306) to the physical interface (312). The die-to-die wires (116) may be implemented in an interposer or in a bridge die as previously discussed.

[0055] In the example of FIG. 3, the physical interface (306) may be implemented using one or more different technologies as described in more detail in the present disclosure. In an exemplary embodiment, the physical interface (306) is implemented as a parallel interface having one or more channels. In some cases, the channels may operate independently of each other and may use separate clocking. Examples of parallel interfaces may include, but are not limited to, an implementation using one or more Laguna sites (as available from Xilinx, Inc., San Jose, California) and an implementation using one or more High Bandwidth Memory (HBM) interfaces. In another exemplary embodiment, the physical interface (306) may be implemented using one or more high-speed serial transceivers. These transceivers can transmit and receive serialized data at gigabit-range speeds.

[0056] FIG. 4 illustrates an exemplary embodiment of a DPE array (110). In the example of FIG. 4, the DPE array (110) is implemented as a plurality of interconnected and programmable DPEs (402). The DPEs (402) may be arranged in an array or hardwired. Each DPE (402) may include one or more cores (404) and a memory module (abbreviated as “MM” in FIG. 4) (406). In one embodiment, each core (404) may execute program code (e.g., computer-readable or executable instructions) stored in a core-specific program memory contained within each core (not shown). Each core (404) can directly access memory modules (406) within the same DPE (402) and memory modules (406) of any other DPE (402) adjacent to the core (404) of the DPE (402) in the up, down, left, and right directions. For example, the core (404-5) can directly read and / or write memory modules (406-5, 406-8, 406-6, and 406-2) (e.g., through individual memory interfaces not shown). The core (404-5) views each of the memory modules (406-5, 406-8, 406-6, and 406-2) as an integrated region of addressable memory (e.g., as part of local memory accessible to the core (404-5)). This facilitates data sharing among different DPEs (402) of the DPE array (110). In other examples, the core (404-5) may be directly connected to the memory modules (406) of other DPEs.

[0057] The DPEs (402) are interconnected by programmable DPE interconnects. The programmable DPE interconnects are taken collectively to form one or more different and independent networks. For example, the programmable DPE interconnects may collectively form a DPE interconnect network having a streaming network formed by streaming connections (shaded arrows) and a memory mapping network formed by memory mapping connections (hatched arrows).

[0058] Loading configuration data into the control registers of the DPEs (402) via memory-mapped connections allows each DPE (402) and component of the present disclosure to be controlled independently. The DPEs (402) may be enabled / disabled on a per-DPE basis. Each core (404) may be configured to access only the memory modules (406) or a subset thereof as described to achieve isolation of the core (404) operating as a cluster or of multiple cores (404). Each streaming connection may be configured to establish logical connections only between selected DPEs (402) to achieve isolation of the DPE (402) operating as a cluster or of multiple DPEs (402). Since program code specific to the corresponding core (404) may be loaded into each core (404), each DPE (402) may implement one or more different kernels of the present disclosure within it.

[0059] In other embodiments, the programmable DPE interconnects within the DPE array (110) may include additional independent networks, such as a debug network and an event broadcast network, each of which is independent of the streaming connections and memory-mapped connections (e.g., distinct and separate). In some embodiments, the debug network is formed by memory-mapped connections and / or is part of a memory-mapped network.

[0060] Cores (404) may be directly connected to one or more adjacent cores (404) via cascade connections. In one embodiment, the cascade connections are unidirectional and direct connections between the cores (404). Generally, the cascade connections are direct core-to-core connections that allow one core (404) to directly share data with another core (404). For example, through a cascade connection, content stored in the internal register of core (404-2) may be provided directly to core (404-3) or to core (404-5). Similarly, through a cascade connection, core (404-5) may directly receive content from the internal register of core (404-6) or directly receive content from the internal register of core (404-2).

[0061] In an exemplary embodiment, the core (404) transmitting the content (e.g., source core) may transmit the content directly from an internal register via a cascade connection. Similarly, the content may be received directly from an internal register of a receiving core (e.g., target core). In an exemplary embodiment, the internal register may be the accumulator register of the cores or other internal registers that may be connected to and / or fed to the accumulator register (e.g., directly). Each of the cascade connections may be enabled or disabled independently, e.g., separately, by loading configuration data into the control registers of each DPE (402).

[0062] In an exemplary embodiment, the DPEs (402) do not include cache memories. By omitting the cache memories, the DPE array (110) can achieve predictable, for example, deterministic performance. Furthermore, since it is not necessary to maintain coherency among the cache memories located in different DPEs (402), significant processing overhead is avoided. In an additional example, the cores (404) do not have input interrupts. Therefore, the cores (404) can operate without being interrupted. Omitting input interrupts for the cores (404) also allows the DPE array (110) to achieve predictable, for example, deterministic performance.

[0063] The DPE interface block (302) operates as an interface connecting DPEs (402) to other circuit sections. In the example of FIG. 4, the other circuit sections include circuit blocks located on a die different from the die containing the DPE array (110). In the example of FIG. 4, the logical interface (304) of the DPE interface block (302) includes a plurality of interconnected tiles (408) organized in rows. In certain examples, different architectures may be used to implement tiles (408) within the DPE interface block (302) in which each different tile architecture supports communication with different resources of the IC (100). The tiles (408) are connected so that data may be propagated bidirectionally from one tile to another. Each tile (408) may operate as an interface to the column of the DPEs (402) immediately above it.

[0064] The tiles (408) are connected to adjacent tiles, to the DPEs (402) immediately above, and to the circuit section below, e.g., the physical interface (306), using streaming connections and memory-mapped connections as described. The tiles (408) may also include a debug network connected to a debug network implemented in the DPE array (110). The tiles (408) can transmit data from the DPEs (402) to other circuit blocks of the IC (100) via the physical interface (306). The physical interface (306) can communicate with these other circuit blocks of the IC (100) via die-to-die wires (116) as described. Examples of other circuit blocks of the die (106) that may be included in the IC (100) may include, but are not limited to, one or more processors or processor systems, programmable logic, one or more hardwired circuit blocks, and / or a programmable Network-on-Chip (NoC).

[0065] Tiles (408) can transmit data from other circuit blocks to DPEs (402). Tile (408-1) can transmit data addressed to DPEs (402) in other columns to other tiles (408, e.g., 408-2 or 408-3) while providing those parts of the data addressed to DPEs (402) in the above columns, for example, whether for an application or a configuration, to these DPEs (402), so that these tiles (408) can accordingly route the data addressed to DPEs (402) in their respective columns.

[0066] It should be understood that in one or more other exemplary embodiments, one or more or all tiles (408) may also include connections to circuit sections and / or circuit blocks located on the die (104). For example, one or more of the tiles (408) may use memory mapping connections and / or streaming connections to couple to circuit blocks located on the die (104). In another example, the DPE array (110) may include some columns of DPEs (402) communicating with tiles (408) that couple to circuit sections located on the same die as the DPE array (110) (e.g., die (104)), and other columns of DPEs (402) communicating with tiles that couple to circuit sections located on a die different from the die containing the DPE array (110) (e.g., circuit sections within the die (106)).

[0067] As discussed, examples of other types of circuits include, but are not limited to, programmable logic, processor systems, NoCs, Platform Management Controllers, and / or hardwired circuit blocks, such as Application Specific Integrated Circuits (ASICs). Programmable logic refers to a circuit that may be programmed to perform specific functions. As an example, programmable logic may be implemented as a field programmable gate array type of circuit. Programmable logic may include an array of programmable circuit blocks. As defined in this disclosure, the term “programmable logic” refers to a circuit used to construct reconfigurable digital circuits. Programmable logic is formed by many programmable circuit blocks that provide basic functions. Unlike hardwired circuits, the topology of programmable logic is highly configurable. Each programmable circuit block of programmable logic typically includes a programmable functional element and a programmable interconnect. The programmable interconnects provide a highly configurable topology of programmable logic. Programmable interconnects may be configured per wire basis to provide connectivity between programmable functional elements of programmable circuit blocks of programmable logic, and may be configured per bit basis (e.g., when each wire carries a single bit of information), unlike connectivity between DPEs (402) that can communicate via packetized data through stream switches.

[0068] Prior to use, programmable logic must be programmed or “configured” by loading data referred to as a configuration bitstream into its internal configuration memory cells. The configuration memory cells define how the programmable logic is configured (e.g., topology) and how it operates (e.g., specific functions to be performed) once the configuration bitstream is loaded. In this disclosure, the “configuration bitstream” is not equivalent to program code executable by a processor or computer.

[0069] A processor system is referred to as a hardwired circuitry manufactured as part of a die. A processor system may be implemented as, or may include, one or more processors capable of executing program code. The processors may include different types of processors (e.g., application processors, real-time processors, etc.). In one example, the processor system is implemented as a single processor capable of executing program code, e.g., a single core. In another example, the processor system is implemented as a multi-core processor. In yet another example, the processor system includes one or more processors, with or without including one or more cores, modules, co-processors, I / O interfaces, and / or other resources. The processor system may be implemented using any of the various different types of architectures. Exemplary architectures that may be used to implement a processor system may include, but are not limited to, ARM processor architecture, x86 processor architecture, graphics processing unit (GPU) architecture, mobile processor architecture, DSP architecture, combinations of the aforementioned architectures, or other suitable architectures capable of executing computer-readable instructions or program code (e.g., user applications).

[0070] NoC refers to a programmable interconnect network for sharing data between endpoint circuits in an IC (100). Endpoint circuits may be placed in a DPE array (110) or any of the circuit blocks and / or resources of various types of the IC (100) described in this disclosure (e.g., programmable logic, processor systems, and / or hardwired circuit blocks). NoC may include high-speed data paths with dedicated switching. In one example, NoC includes one or more horizontal paths, one or more vertical paths, or both horizontal and vertical path(s).

[0071] Within the NoC, the nets to be routed through the NoC are unknown until the user circuit design is created for implementation within the IC (100). The NoC may be programmed by loading configuration data into internal configuration registers that define how elements within the NoC, such as switches and interfaces, are configured and operate to transfer data from switch to switch and between NoC interfaces to connect endpoint circuits. The NoC may be manufactured as part of the IC (100) (e.g., hardwired), and thus, although physically immutable, the NoC may be programmed to establish connectivity between different master circuits and different slave circuits of the user circuit design. In some cases, the NoC does not implement any data paths or routes within it upon power-on. However, once configured, the NoC implements data paths or routes between endpoint circuits.

[0072] Another example of a circuit block is a Platform Management Controller (PMC). The PMC is a circuit block that may be responsible for managing the IC (100). For example, the PMC may be implemented as a subsystem within the IC (100) capable of managing other circuit resources throughout the IC (100). The PMC may maintain a safe and secure environment during normal operations, boot the IC (100), and manage the IC (100). For example, the PMC may provide integrated and programmable control over power-up, boot / configuration, security, power management, safety monitoring, debugging, and / or error handling for different circuit resources of the IC (100) (e.g., DPE array (110), programmable logic, NoC, and / or hardwired circuit blocks). The PMC may also operate as a dedicated platform manager that decouples the processor system from the programmable logic. In this way, the processor system and programmable logic may be managed, configured, and / or powered on and / or turned off independently of each other.

[0073] The PMC may be implemented as a processor with dedicated resources. The PMC may include multiple redundant processors. The processors of the PMC may execute firmware. The use of firmware supports the configurability and segmentation of global features of the IC (100), such as reset, clocking, and protection, to provide flexibility in creating individual processing domains (distinguished from "power domains" which may be die and / or subsystem specific). Processing domains may involve a mix or combination of one or more different programmable circuit resources of the IC (100) (e.g., processing domains or partitions may include different combinations of devices from the DPE array (110), processor systems, programmable logic, NoC, and / or hardwired circuit blocks).

[0074] Hardwired circuit blocks refer to special-purpose circuit blocks manufactured as part of the IC (100). Although hardwired, hardwired circuit blocks may be configured by loading configuration data into control registers to implement one or more different modes of operation. Examples of hardwired circuit blocks may include input / output (I / O) blocks, transceivers for transmitting and receiving signals to and from circuits and / or systems outside the IC (100), memory controllers, etc. Examples of different I / O blocks may include single-ended and pseudo-differential I / Os. Examples of transceivers may include high-speed differentially clocked transceivers. Other examples of hardwired circuit blocks include, but are not limited to, encryption engines, digital-to-analog converters (DACs), analog-to-digital converters (ADCs), etc. Generally, hardwired circuit blocks are application-specific circuit blocks.

[0075] The DPE array (110) may be coupled to any circuit among various other types of circuits other than those described, as implemented in the die (104). For example, the die (104) may be coupled to a die that includes or implements RAM, other specialized circuits (e.g., ASIC), a modem, a transceiver, etc.

[0076] FIGS. 5a and 5b illustrate an exemplary architecture for a DPE (402) of a DPE array (110). For the sake of discussion, FIGS. 5a and 5b may be collectively referred to as “ FIGS. 5”.

[0077] Referring to FIG. 5a, the DPE (402) includes a core (404) and a memory module (406). The DPE (402) further includes DPE interconnects including a stream switch (502) and a memory mapping switch (504).

[0078] The core (404) provides the data processing capabilities of the DPE (402). The core (404) may be implemented as any of the various different processing circuits. In the example of FIG. 5, the core (404) includes an alternative program memory (506). In one or more exemplary embodiments, the core (404) is implemented as a processor capable of executing program code, e.g., computer-readable instructions. The program memory (506) may store instructions executed by the core (404). For example, the core (404) may be implemented as a CPU, GPU, DSP, vector processor, or other type of processor capable of executing instructions. The core may be implemented using any of the various CPU and / or processor architectures described in this disclosure. In another example, the core (404) is implemented as a very long instruction word (VLIW) vector processor or DSP.

[0079] In certain exemplary embodiments, the program memory (506) is implemented as a private, dedicated program memory for the core (404). The program memory (506) may be used only by the core of the same DPE (402). Thus, the program memory (506) may be accessed only by the core (404) and is not shared with any other DPE (402) of the DPE array (110) or components of other DPEs (402). The program memory (506) may include a single port for read and write operations and may be addressable using the memory mapping network portion of the DPE array (110) via the memory mapping switch (504). For example, via the memory mapping switch (504), program code may be loaded into the program memory (506) by a master circuit outside the DPE array (110). The program code loaded into the program memory (506) may be executed by the core (404).

[0080] In one or more exemplary embodiments, the core (404) may have a custom architecture to support an application-specific set of commands. For example, the core (404) may be customized for wireless applications and configured to execute wireless-specific commands. In another example, the core (404) may be customized for machine learning and configured to execute machine learning-specific commands.

[0081] In one or more other exemplary embodiments, the core (404) is implemented as a hardwired circuit, such as an enhanced Intellectual Property (IP) core, dedicated to performing specific operations or operations. In that case, the core (404) may not execute program code. In embodiments where the core (404) does not execute program code, the program memory (506) may be omitted. As an exemplary and non-limiting example, the core (404) may be implemented as an enhanced forward error correction (FEC) engine or other circuit block.

[0082] In some exemplary embodiments, different DPEs (402) of the DPE array (110) may include different types of cores (404). For example, one or more cores (404) may be implemented to execute program code, while the cores (404) of other DPEs (402) may not be able to execute program code. In either case, each core (404) may be configured to perform computation, whether through the execution of program code / instructions or not, and may include an internal register or registers (526) that may be used with the cascade connection described in this disclosure.

[0083] The core (404) may include control registers (508). Configuration data may be loaded into the control registers (508) to control the operation of the DPE (402). For example, configuration data loaded into the control registers (508) may configure and / or control the operation of the core (404), memory module (406), stream switch (502), and cascade interfaces (522, 524) of the DPE (402), which will be described in more detail in this disclosure. In one or more exemplary embodiments, the DPE (402) may be enabled and / or disabled based on the configuration data loaded into the control registers (508), for example, in whole. Similarly, the core (404) may be enabled and / or disabled based on the configuration data loaded into the control registers (508). The core (404) may be enabled and / or disabled independently of the memory module (406) so that the memory module (406) may be accessed by one or more other cores. In the example of FIG. 5a, the control registers (508) are addressable through a memory mapping network via a memory mapping switch (504) (e.g., they may be read and / or written). Deactivation refers to placing the circuit block in a low-power mode or disconnecting power (e.g., supply voltage) from the circuit block.

[0084] In one or more exemplary embodiments, the memory module (406) may store data used and / or generated by the core (404) (or another core of another DPE (402)) referred to as application data in this disclosure. The memory module (406) may include a read / write memory such as a random-access memory. Thus, the memory module (406) may store data that may be read and consumed by the core (404). The memory module (406) may also store data (e.g., results) that is written by the core (404).

[0085] In one or more other exemplary embodiments, the memory module (406) may store data, such as application data, that may be used and / or generated by one or more other cores (404) of other DPEs (402) within the DPE array (110). One or more other cores (404) of the DPEs (402) may also read from and / or write to the memory module (406). In certain exemplary embodiments, the other cores (404) that may read from and / or write to the memory module (406) may be cores (404) of one or more neighboring DPEs (402). Another DPE (e.g., an adjacent DPE) that shares an edge or boundary with the memory module (406) of the DPE (402) of FIG. 5a is referred to as a "neighbor" DPE to the DPE (402) of FIG. 5a. By allowing one or more other cores (404) from the core (404) of FIG. 5a and neighboring DPEs (e.g., DPEs above, below, and to the right of the target DPE (402) of FIG. 5a) to read and / or write to the memory module (406), the memory module (406) implements a shared memory that supports communication between different DPEs (402) and / or cores (404) that can access the memory module (406).

[0086] In one or more exemplary embodiments, the DPE interconnect circuitry for the DPE array (110) comprises two different networks. The first network can exchange data with the DPE array (110) of the IC (100) and / or other DPEs (402) of other systems. For example, the first network can exchange application data. The second network can exchange data such as configuration, control, and / or debugging data for the DPE(s) (402).

[0087] In the example of FIG. 5, the first network of the DPE interconnect circuit is formed by a stream switch (502) and one or more stream switches of other DPEs (402). As depicted, the stream switch (502) is coupled to the stream switches of the DPEs (402) to the left, right, and below the DPE (402) of FIG. 5a. When the DPE (402) of FIG. 5a is in the bottom row, the stream switch (502) is coupled to a tile (408) of the DPE interface (302).

[0088] The stream switch (502) is coupled to the core (404) and can communicate with the core (404). For example, the core (404) includes a stream interface connected to the stream switch (502) to allow the core (404) to communicate directly with other DPEs (402) through the DPE interconnect circuitry. For example, the core (404) may include commands or hardwired circuitry that enable the core (404) to directly transmit and / or receive application data through the stream switch (502).

[0089] The stream switch (502) is coupled to the memory module (406) and can communicate with the memory module (406). For example, the memory module (406) includes a stream interface connected to the stream switch (502) and allows other DPEs (402) to communicate with the memory module (406) of FIG. 5 through the DPE interconnect circuit. The stream switch (502) may allow non-neighboring DPEs and / or DPEs not coupled to the memory interface of the memory module (406) of FIG. 5a to communicate with the core (404) and / or the memory module (406) through the DPE interconnect circuit, which includes the stream switches of each DPE (402) of the DPE array (110). In this way, the core (404) of FIG. 5 and / or the memory module (406) of FIG. 5 can also communicate with any of the DPEs (402) in the DPE array (110) through the DPE interconnect circuit of the DPEs (402).

[0090] The stream switch (502) may also be used to communicate with other subsystems, such as programmable logic, NoCs, or other circuit blocks. Generally, the stream switch (502) may be programmed to operate as a circuit-switching stream interconnect or a packet-switched stream interconnect. A circuit-switched stream interconnect can implement point-to-point dedicated streams suitable for high-bandwidth communication between DPEs (402). A packet-switched stream interconnect allows streams to be shared to time-multiplex multiple logical streams onto a single physical stream for medium-bandwidth communication.

[0091] The stream switch (502) may be configured via control registers (508). For example, configuration data loaded into the control registers (508) indicates whether the DPE (402) of FIG. 5a will communicate with other DPEs (402) and / or systems of IC (100) and whether these communications will be established as circuit-switched point-to-point connections or packet-switched connections.

[0092] The second network of the DPE interconnect circuit is formed by a memory mapping switch (504) such as one that is connected to other memory mapping switches of the DPE array (110). Each component of the DPE (402) of FIG. 5, which may be read and / or written, such as control registers (508), program memory (506), and memory module (406), may be read or written using the mapping switch (504). The memory mapping switch (504) may also be used to exchange configuration, control, and debugging data for the DPE (402). In the example of FIG. 5, the memory mapping switch (504) may receive configuration data used to configure the DPE (402). The memory mapping switch (504) may receive configuration data from the memory mapping switch of the DPE (402) located below the DPE (402) of FIG. 5 (e.g., when the DPE (402) of FIG. 5 is located in the bottom row of the DPE array (110)) and / or from the DPE interface (302). The memory mapping switch (504) may forward the received configuration data to one or more other DPEs (402) above the DPE (402) of FIG. 5, to the core (404) of FIG. 5 (e.g., to the program memory (506) and / or control registers (508)), and / or to the memory module (406) of FIG. 5 (e.g., to the memory within the memory module (406). Accordingly, the memory mapping switch (504) of FIG. 5 communicates with the tile (408) of the lower DPE interface (302) or the memory mapping switch of the DPE (402) and / or the memory mapping switch of the upper DPE (402).

[0093] Collectively, the DPE interconnects of the various DPEs (402) of the DPE array (110) form a DPE interconnect network (which may include a stream network and / or a memory-mapped network). The control registers (508) of each DPE (402) may be programmed by loading configuration data through individual memory-mapped switches (504). Through configuration, the stream switches (502) and / or stream interfaces are programmed to establish connections, whether packet-switched or circuit-switched, with other endpoints, whether they are located in one or more other DPEs (402) and / or DPE interfaces (302).

[0094] For example, the DPE array (110) may be mapped to the address space of a processor (e.g., a processor or PMC of a processor system). Accordingly, any control registers and / or memories within the DPE (402) of the DPE array (110) may be accessed through a memory mapping interface. For example, the memory of the memory module (406), the program memory (506), and / or control registers (508) may be read and / or written through the memory mapping switches (504) of the individual DPEs (402).

[0095] The memory mapping switch (504) of FIG. 5, combined with the memory mapping switches (504) of other DPEs (402), implements a shared, transaction-switched network in which transactions propagate from memory mapping switch to memory mapping switch. For example, each of the memory mapping switches (504) can dynamically route transactions based on addresses. The memory mapping switch (504) allows other subsystems of the IC (100) to access the resources (e.g., components) of the DPE (402).

[0096] In the example of FIG. 5, the memory module (406) includes a plurality of memory interfaces (510-1, 510-2, 510-3, and 510-4). In FIG. 5, the memory interfaces (510-1 and 510-2) are abbreviated as "MI". The memory module (406) further includes a plurality of memory banks (512-1 to 512-N). In certain exemplary embodiments, the memory module (406) includes eight memory banks. In other exemplary embodiments, the memory module (406) may include fewer or more memory banks (512). In the example of FIG. 5, each of the memory banks (512-1 to 512-N) has an individual arbiter (514-1 to 514-N). Each arbiter (514) may include arbitration logic. In addition, each arbiter (514) may include a crossbar. Thus, any master can write to any one or more specific memory banks (512).

[0097] The memory module (406) may include a memory mapping interface (not shown) that communicates with a memory mapping switch (504). The memory mapping interface of the memory module (406) may be connected to communication lines of the memory module (406) that are coupled to a direct memory access (DMA) engine (516), memory interfaces (510), and arbitrators (514) to write to and / or read from a memory bank (512).

[0098] The DMA engine (516) may include two or more interfaces. For example, one or more interfaces may receive input data streams from stream switches (502) of other DPEs (402) that write received data to memory banks (512). One or more other interfaces may read data from memory banks (512) and transmit the data to other DPEs (402) through the stream interface of the DMA engine (516).

[0099] The memory module (406) may operate as a shared memory that may be accessed by a plurality of different DPEs (402). In the example of FIG. 5a, the memory interface (510-1) is coupled to the core (404) through a core interface (518-1) included in the core (404). The memory interface (510-1) provides the core (404) with access (e.g., read and write capabilities) to memory banks (512) through arbitrators (514). The memory interface (510-2) is coupled to the core interface of the DPE (402) of the DPE array (110) on the DPE (402) of FIG. 5. The memory interface (510-2) provides access to the memory banks (512) to the core (404) of the DPE (402) on the DPE (402) of FIG. 5. The memory interface (510-3) is coupled to the core interface of the DPE (402) of the DPE array (110) to the right of the DPE (402) in FIG. 5. The memory interface (510-3) provides access to the memory banks (512) to the core (404) of the DPE (402) to the right of the DPE (402) in FIG. 5. The memory interface (510-4) is coupled to the core interface of the DPE (402) of the DPE array (110) below the DPE (402) in FIG. 5. The memory interface (510-4) provides access to the memory banks (512) to the core (404) of the DPE (402) below the DPE (402) in FIG. 5.

[0100] The core (404) can access the memory modules of other neighboring DPEs through the core interfaces (518-2, 518-3, and 518-4). In the example of FIG. 5, the core interface (518-2) is coupled to the memory interface of the DPE (402) below the DPE (402) of FIG. 5. Thus, the core (404) can access the memory module (406) of the DPE (402) below the DPE (402) of FIG. 5. The core interface (518-3) is coupled to the memory interface of the DPE (402) to the left of the DPE (402) of FIG. 5. Thus, the core (404) can access the memory module (406) of the DPE (402) to the right of the DPE (402) of FIG. 5. The core interface (518-4) is coupled to the memory interface of the DPE (402) on the DPE (402) of FIG. 5. Thus, the core (404) can access the memory module (406) of the DPE (402) on the DPE (402) of FIG. 5.

[0101] As mentioned, the core (404) can map read and / or write operations in the correct direction through core interfaces (518-1, 518-2, 518-3, and / or 518-4) based on the addresses of these operations. When the core (404) generates an address for memory access, the core (404) can decode the address to determine the direction (e.g., a specific DPE (402) to be accessed) and forward the memory operation in the determined direction to the correct core interface.

[0102] The memory module (406) may include a hardware synchronization circuitry (HSC) (520). Generally, the HSC (520) can synchronize the operation of different cores (404) (e.g., cores (404) of neighboring DPEs (402)), the core (404) of FIG. 5, the DMA engine (516), and other external masters (e.g., processors) that may communicate with a DPE such as the DPE (402) of FIG. 5a through the DPE interconnect circuitry. As an exemplary and non-limiting example, the HSC (520) can synchronize two different cores (404) in different DPEs (402) accessing the same, for example, shared buffer in the memory module (406) of FIG. 5a. The HSC (520) may be accessed by the core (404) and / or the cores of neighboring DPEs (e.g., the cores (404) of other DPEs (402) connected to the memory interfaces (510)) and / or by the memory mapping switches (504) of other DPEs (402).

[0103] In addition to communicating with neighboring DPEs (402) through shared memory modules (406) and with neighboring and / or non-neighboring DPEs (402) through DPE interconnect circuitry, the core (404) may include one or more cascade interfaces (522, 524), such as a cascade input (described as "CI" (522)) and a cascade output (described as "CI" (524)). The cascade interfaces (522 and 524) may provide direct communication with other cores (404) of adjacent DPEs (402). As illustrated, the cascade interface (522) of the core (405) may directly receive an input data stream from the core (404) of an adjacent DPE (402) (e.g., left, top, or bottom DPE (402)). The data stream received through the cascade interface (522) may be provided to the data processing circuitry within the core (404). The cascade interface (524) of the core (404) may directly transmit the output data stream to the core (404) of an adjacent DPE (402) (e.g., right, top, or bottom DPE (402)).

[0104] In the example of FIG. 5, each of the cascade interfaces (522) and (524) may include a first-in-first-out (FIFO) interface (not shown) for buffering. In an exemplary embodiment, the cascade interfaces (522 and 524) may transmit data streams that may be hundreds of bits wide. The specific bit width of the cascade interfaces (522 and 524) is not intended as a limitation. In the example of FIG. 5, the cascade interface (522) is coupled to an internal register (or registers) (526) within the core (404). The internal register (526) may store data generated and / or processed by the data processing circuitry within the core (404).

[0105] In one embodiment, the internal register (526) may be an accumulator register. The accumulator register of the core (404) is an internal register in which intermediate results of operations performed by the core (404) may be stored. The accumulator register allows the core (404) to store these intermediate calculation results without writing these contents / data to other memory located outside the core (404). In another embodiment, the internal register (526) may be another register that may be connected to the accumulator register. For example, the internal register (526) may be a register that is coupled to the accumulator register and is specifically accessible to receive data through the cascade interface (522), write the data to the accumulator register, and / or output data from the accumulator register through the cascade interface (524). The cascade interface (524) may output the contents of the internal register (526) and may do so for each clock cycle.

[0106] In the example of FIG. 5, the cascade interfaces (522 and 524) may be programmed based on configuration data loaded into control registers (508). For example, based on the control registers (508), the cascade interface (522) may be enabled or disabled. Similarly, based on the control registers (508), the cascade interface (524) may be enabled or disabled. The cascade interface (522) may be enabled and / or disabled independently of the cascade interface (524).

[0107] In an exemplary embodiment, the cascade interfaces (522 and 524) are controlled by the core (404). For example, the core (404) may include commands for reading / writing to the cascade interfaces (522 and / or 524). In another example, the core (404) may include a hardwired circuit capable of reading and / or writing to the cascade interfaces (522 and / or 524). In certain exemplary embodiments, the cascade interfaces (522 and 524) may be controlled by an entity outside the core (404).

[0108] In one or more exemplary embodiments, the DPE array (110) may be functionally separated into multiple groups of one or more DPEs (402), e.g., clusters. For example, specific core interfaces (518) and / or memory interfaces (510) may be enabled and / or disabled via configuration data to create one or more clusters of DPEs (402), each cluster comprising one or more (e.g., a subset) of the DPEs (402) of the DPE array (110), memory modules (406) of the selected DPEs (402), cores (404) of the selected DPEs (402), or different combinations thereof. Additionally or alternatively, stream interfaces may be configured independently per cluster to communicate with other cores (404) and / or memory modules (406) of DPEs (402) in the same cluster (e.g., only with them) and / or with a specified input source and / or output destination. Additionally or alternatively, cascade interfaces (522, 524) may be configured so that only cores (404) of the same cluster can communicate with the cascade interfaces (522, 524). This effectively isolates the clusters of DPEs (402), allowing different clusters to run different applications independently and in isolation.

[0109] It should be understood that DPEs (402) may be organized into clusters, and that a specific DPE(s) (402) or all DPE(s) (402) of a cluster may be connected to DPEs (402) of the same cluster through any combination of stream switches (502), shared memory (e.g., core interfaces (518) and / or memory interfaces (510)), and / or cascade interfaces (522, 524). Additionally, a specific DPE(s) (402) of one cluster may be separated from the DPE(s) (402) of another cluster in that they cannot communicate across the cluster using one or more of the stream switches (502), shared memory, and / or cascade interfaces (522, 524), but are allowed to communicate across the cluster using a subset of the stream switches (502), shared memory, and / or cascade interfaces (522, 524).

[0110] As discussed, in one or more exemplary embodiments, the DPE array (110) may be formed of homogeneous DPEs (402). In one or more other exemplary embodiments, the DPE array (110) may be formed of different types of DPEs (402). For example, the DPEs (402) may include different types of cores (404), such as cores (404) that execute program code, hardwired cores that do not execute program code, special purpose cores, or any combination thereof. In another exemplary embodiment, the DPE array (110) may include one or more DPEs, for example, dummy DPEs rather than functional DPEs. Each different DPE array may include a different number of DPEs and / or different types of DPEs, whether implemented on the same die or on different dies.

[0111] FIG. 5b illustrates an example of an event processing circuit within a DPE (402). DPEs may include event processing circuits that are interconnected to the event processing circuits of other DPEs. In the example of FIG. 5b, the event processing circuit is implemented in the core (404) and within the memory module (406). The core (404) may include an event broadcast circuit (552) and event logic (554). The memory module (406) may include a separate event processing circuit including an event broadcast circuit (562) and event logic (564).

[0112] The event broadcast circuit section (552) may be connected to the event broadcast circuit section within each of the cores of neighboring DPEs above and below the DPE (402) of FIG. 5. The event broadcast circuit section (552) may also be connected to the event broadcast circuit section within the memory module of the neighboring DPE to the left of the DPE (402) of FIG. 5. As illustrated, the event broadcast circuit section (552) is connected to the event broadcast circuit section (562). The event broadcast circuit section (562) may be connected to the event broadcast circuit section within each of the memory modules of neighboring DPEs above and below the DPE (402) illustrated in FIG. 5. The event broadcast circuit section (562) may also be connected to the event broadcast circuit section within the core of the neighboring DPE to the right of the DPE (402) of FIG. 5.

[0113] In this way, the event processing circuitry of the DPEs may form an independent event broadcast network within the DPE array (110). The event broadcast network within the DPE array (110) may exist independently of the other networks described in this disclosure. Furthermore, the event broadcast network may be individually configured by loading suitable configuration data into control registers (508).

[0114] In the example of FIG. 5, the control registers (508) each program event logic (554 and 564) to detect specific types of events occurring within the core (404) and the memory module (406). For example, data loaded into the control registers (508) determines which of several different types of predetermined events are detected by the event logic (552 and 562). Examples of events that may be detected by the event broadcast circuit (552) are events occurring within the core (404). These events may include, but are not limited to, the start and / or end of read operations by the core (404), the start and / or end of write operations by the core (404), stalls, and the occurrence of other operations performed by the core (404). Examples of events that may be detected by the event broadcast circuit (562) are events occurring within the memory module (406). These events may include, but are not limited to, the start and / or end of read operations by the DMA engine (516), the start and / or end of write operations by the DMA engine (516), stalls, and the occurrence of other operations performed by the memory module (406). For example, data loaded into the control registers (508) determines which of several different types of predetermined events is detected by the event logic (554 and / or 564). It should be understood that the event logic (554) and / or event logic (564) can detect events originating from and / or related to the DMA engine (516), the memory mapping switch (504), the stream switch (502), the memory interfaces (510), the core interfaces (518), the cascade interfaces (522, 524), and / or other components located in the DPEs.

[0115] For example, configuration data loaded into control registers (508) may determine which of the events received from other event broadcast circuits by the event broadcast circuit (552 and / or 562) are propagated to other event broadcast circuits or other circuits. The configuration data may also specify the events internally generated by the event logic (554 and / or 564) that are propagated to other event broadcast circuits and / or other circuits.

[0116] Accordingly, events generated by the event logic (554 and 564) may be provided to the event broadcast circuit (552 and 562), respectively, and may be broadcast to other DPEs. In the example of FIG. 5b, the event broadcast circuit (552 and / or 562) may broadcast events to the DPE above, the DPE to the left, and the DPE below or the logical interface (304), whether they are generated internally or received from other DPEs. The event broadcast circuit (552) may also broadcast events to the event broadcast circuit (562) within the memory module (406).

[0117] In the example of FIG. 5a, the event broadcast circuits located in the cores communicate vertically with the event broadcast circuits located in the cores of neighboring DPEs above and / or below. If the DPE is immediately above (or adjacent to) the logical interface (304), the event broadcast circuit of the core of that DPE can communicate with the logical interface (304). Similarly, the event broadcast circuits located in the memory modules communicate vertically with the event broadcast circuits located in the memory modules of neighboring DPEs above and / or below. If the DPE is immediately above (e.g., adjacent to) the logical interface (304), the event broadcast circuit of the memory module of that DPE can communicate with the logical interface (304). The event broadcast circuit can additionally communicate with the event broadcast circuit immediately to the left and / or to the right, regardless of whether such event broadcast circuits are located in another DPE and / or within a core or memory module.

[0118] Once the control registers (508) are written, the event logic (554) and the event logic (564) can operate in the background. In one or more exemplary embodiments, the event logic (554) generates events in response only to detecting specific conditions within the core (404); and the event logic (562) generates events in response only to detecting specific conditions within the memory module (406).

[0119] FIGS. 6a, 6b, and 6c illustrate exemplary architectures for implementing tiles of a logical interface (304). FIG. 6a illustrates an exemplary implementation of a tile (408). The architecture illustrated in FIG. 6a may also be used to implement any tile among the other tiles included in the logical interface (304).

[0120] The tile (408) includes a memory mapping switch (602). The memory mapping switch (602) may include multiple memory mapping interfaces for communicating in each of the multiple different directions. As an exemplary and non-limiting example, the memory mapping switch (602) may include one or more memory mapping interfaces, wherein the memory mapping interface has a master connected vertically to the memory mapping interface of the DPE (402) immediately above. In this way, the memory mapping switch (602) may operate as a master for the memory mapping interfaces of one or more of the DPEs (402). In a particular example, the memory mapping switch (602) may operate as a master for a subset of the DPEs (402). For example, the memory mapping switch (602) may operate as a master for a column of DPEs (402) above the tile (408). It should be understood that the memory mapping switch (602) may include additional memory mapping interfaces for connecting to different multiple circuits (e.g., DPEs) within the DPE array (110). The memory mapping interfaces of the memory mapping switch (602) may also include one or more slaves capable of communicating with circuits (e.g., one or more DPE(s)) located on the tile (408).

[0121] In the example of FIG. 6a, the memory mapping switch (602) may include one or more memory mapping interfaces that facilitate horizontal communication between the memory mapping switches and neighboring tiles of the logical interface (304). For illustrative purposes, the memory mapping switch (602) may be connected to neighboring tiles horizontally through memory mapping interfaces, wherein each of these memory mapping interfaces includes one or more masters and / or one or more slaves. Thus, the memory mapping switch (602) may move data (e.g., configuration, control, and / or debug data) from one tile to another to send the data to the target DPEs, whether the DPEs are in a column on tile (408) or in a different subset where another tile of the logical interface (304) acts as an interface. For example, when memory mapping transactions are received from the physical interface (306), the memory mapping switch (602) can distribute the transaction(s) horizontally to other tiles, for example, within the logical interface (304).

[0122] The memory mapping switch (602) may also include a memory mapping interface having one or more masters and / or slaves coupled to control registers (636) within the tile (408). Through the memory mapping switch (602), configuration data may be loaded into the control registers (636) to control various functions and operations performed by components within the tile (408). FIGS. 6a, 6b, and 6c illustrate connections between the control registers (636) and one or more elements of the tile (408). However, it should be understood that the control registers (636) may control other elements of the tile (408) and thus have connections to these other elements, but such connections are not illustrated in FIGS. 6a, 6b, and / or 6c.

[0123] The memory mapping switch (602) may include a memory mapping interface coupled to a physical interface (306) via a bridge (618). The memory mapping interface may include one or more masters and / or slaves. The bridge (618) may convert memory mapping data transmissions (e.g., configuration, control, and / or debug data) from the physical interface (306) into memory mapping data that may be received by the memory mapping switch (602).

[0124] The tile (408) may also include an event processing circuit. For example, the tile (408) includes event logic (632). The event logic (632) may be configured by control registers (636). In the example of FIG. 6a, the event logic (632) is coupled to the Control, debug, and trace (CDT) circuit (620). Configuration data loaded into the control registers (636) defines specific events that may be locally detected within the tile (408). The event logic (632) can detect various different events originating from and / or related to the DMA engine (612), memory mapping switch (602), stream switch (606), FIFO memories located within the bitwise interface (610), and / or stream interface (614), for each control register (636). Examples of events may include, but are not limited to, DMA finished transfer, unlock, lock acquisition, bitwise transfer termination, or other events related to the start or end of a data flow through the tile (408). The event logic (632) may provide these events to the event broadcast circuit (604) and / or the CDT circuit (620). In another exemplary embodiment, the event logic (632) may not have a direct connection to the CDT circuit (620), but rather may be connected to the CDT circuit (620) through the event broadcast circuit (604).

[0125] A tile (408) includes an event broadcast circuit (604) and an event broadcast circuit (630). Each of the event broadcast circuit (604) and the event broadcast circuit (630) provides an interface between the event broadcast network of the DPE array (110) and other tiles of the logical interface (304). The event broadcast circuit (604) is coupled to the event broadcast circuit of an adjacent or neighboring tile of the logical interface (304) and to the event broadcast circuit (630). The event broadcast circuit (630) is coupled to the event broadcast circuit of an adjacent or neighboring tile of the logical interface (304). In one or more other exemplary embodiments, where the tiles of the logical interface (304) are arranged in a grid or array, the event broadcast circuit (604) and / or the event broadcast circuit (630) may be connected to event broadcast circuits located on other tiles above and / or below the tile (408).

[0126] In the example of FIG. 6a, the event broadcast circuit (604) is coupled to the event broadcast circuit in the core of the DPE (402) immediately adjacent to the tile (408) (e.g., above). The event broadcast circuit (604) is also coupled to the bit-unit interface (610). The event broadcast circuit (630) is coupled to the event broadcast circuit in the memory module of the DPE (402) immediately adjacent to the tile (408) (e.g., above). Although not illustrated, in other exemplary embodiments, the event broadcast circuit (630) may also be coupled to the bit-unit interface (610).

[0127] The event broadcast circuit (604) and the event broadcast circuit (630) can transmit events internally generated by the event logic (632), events received from other tiles (408) of the logical interface (304), and / or events received from DPEs (402) onto other tiles. The event broadcast circuit (604) can additionally transmit these events to other dies via the bit interface (610). In another example, events may be transmitted from the event broadcast circuit (604) to other blocks of the IC (100) and / or systems, such as ASIC and / or PL circuit blocks located outside the DPE array (110), using the bit interface (610) (not shown). Furthermore, the bit interface (610) may receive events from other dies and provide these events to the event broadcast switch (604) and / or stream switch (606). In one embodiment, the event broadcast circuit (604) can transmit any events received from other dies of the IC (100) via the bit unit interface (610) to other tiles (408) of the logical interface (304) and / or to DPEs (402) of the DPE array (110). Since events may be broadcast between the tiles (408) in the logical interface (304), events may reach any DPE (402) in the DPE array (110) by traversing the tiles (408) in the logical interface (304) and the event broadcast circuit to the target (e.g., intended) DPEs (402). For example, the event broadcast circuitry in the tile (408) of the logical interface (304) under a column (or subset) of DPEs (402) managed by the tile (408), including one or more target DPE(s), may propagate events to the target DPEs.

[0128] In the example of FIG. 6a, the event broadcast circuit (604) and event logic (632) are coupled to the CDT circuit (620). The event broadcast circuit (604) and event logic (632) can transmit events to the CDT circuit (620). The CDT circuit (620) can packetize the received events and transmit the events from the event broadcast circuit (604) and / or event logic (632) to the stream switch (606). In certain exemplary embodiments, the event broadcast circuit (630) may also be connected to the stream switch (606) and / or the CDT circuit (620).

[0129] In one or more exemplary embodiments, the event broadcast circuit (604) and the event broadcast circuit (630) may collect broadcast events from one or more or all directions as illustrated in FIG. 6a (e.g., through any of the connections shown in FIG. 6a). In some cases, the event broadcast circuit (604) and / or the event broadcast circuit (630) may perform a logical “OR” of signals and forward the results to one or more or all directions (e.g., including the CDT circuit (620)). Each output from the event broadcast circuit (604) and the event broadcast circuit (630) may include a bitmask configurable by configuration data loaded into control registers (636). The bitmask determines which events are broadcast individually in each direction. These bitmasks may, for example, eliminate unwanted or redundant propagation of events.

[0130] The interrupt handler (634) is coupled to the event broadcast circuit (604) and can receive events broadcast from the event broadcast circuit (604). In one or more exemplary embodiments, the interrupt handler (634) may be configured by configuration data loaded into control registers (636) to generate interrupts for the physical interface (306) in response to combinations of selected events and / or events (e.g., DPE generated events and / or events generated within the tile (408)) from the event broadcast circuit (604). The interrupt handler (634) can generate interrupts for circuits located on other dies of the IC (100) based on the configuration data. For example, the interrupt handler (634) can notify other device-level management blocks, such as a processor or processor system, of events occurring in the DPE array (110) and / or events occurring in the tiles (408) of the logical interface (304) based on the interrupt(s) generated by the interrupt handler (634).

[0131] The bit interface (610) is coupled to the physical interface (306). In one or more exemplary embodiments, the bit interface (610) provides an asynchronous clock domain that intersects between the DPE array (110) and another clock domain. The bit interface (610) may also provide level shifters and / or isolation cells for integration with power rails. In certain exemplary embodiments, the bit interface (610) may be configured to provide FIFO support for handling back-pressure to 32-bit, 64-bit, and / or 128-bit interfaces. The specific width of the bit interface (610) may be controlled by configuration data loaded into control registers (636).

[0132] In one or more other exemplary embodiments, the bit interface (610) is coupled to different types of circuit blocks and / or systems on different dies via a physical interface (306). For example, the bit interface (610) may be coupled to an ASIC, an analog / mixed-signal circuit, and / or other systems. In this way, the bit interface (610) can transmit data between the tile (408) and these other systems and / or circuit blocks.

[0133] In the example of FIG. 6a, the tile (408) includes a stream switch (606). The stream switch (606) is coupled to a stream switch in an adjacent or neighboring tile (408) via one or more stream interfaces. Each stream interface may include one or more masters and / or one or more slaves. In certain exemplary embodiments, each pair of neighboring stream switches may exchange data through one or more streams in each direction. The stream switch (606) is also coupled to a stream switch in the DPE immediately above the tile (408) by one or more stream interfaces. The stream switch (606) is also coupled to a bit-unit interface (610), a DMA engine (612), and / or a stream interface (614) via a stream multiplexer / demultiplexer (608) (abbreviated as stream mux / demux in FIG. 6a). The stream switch (606) may include one or more stream interfaces used to communicate with each of the bit interface (610), DMA engine (612), and / or stream interface (614) through, for example, a stream multiplexer / demultiplexer (608).

[0134] The stream switch (606) may be configurable by configuration data loaded into control registers (636). The stream switch (606) may be configured, for example, to support packet-switched and / or circuit-switched operation based on the configuration data. Additionally, the configuration data defines specific DPE(s) (402) that the stream switch (606) communicates with. In one or more exemplary embodiments, the configuration data defines specific DPE(s) (402) and / or a subset of DPE(s) (402) in a column of DPE(s) (402) immediately above the tile (408) that the stream switch (606) communicates with.

[0135] The stream multiplexer / demultiplexer (608) can send data received from the bit interface (610), the DMA engine (612), and / or the stream interface (614) to the stream switch (606). Similarly, the stream multiplexer / demultiplexer (608) can send data received from the stream switch (606) to the bit interface (610), the DMA engine (612), and / or the stream interface (614). For example, the stream multiplexer / demultiplexer (608) may be programmed by configuration data stored in control registers (636) to route selected data to a bit-unit interface (610), route selected data—such data is transmitted as memory-mapped transactions to a physical interface (306)—to a DMA engine (612), and / or route selected data—such data is transmitted as a data stream or streams through the physical interface (306)—to a stream interface (614).

[0136] The DMA engine (612) may operate as a master that advances data to the physical interface (306) through the selector block (616). The DMA engine (612) may receive data from the DPEs (402) and provide this data to the physical interface (306) as memory-mapped data transactions. In one or more exemplary embodiments, the DMA engine (612) includes a hardware synchronization circuit that may be used to synchronize a plurality of channels included in the DMA engine (612) and / or channels within the DMA engine (612) with a master that polls and drives lock requests. For example, the master may be a processor and / or processor system on another die of the IC (100). The master may also receive interrupts generated by the hardware synchronization circuit within the DMA engine (612).

[0137] In one or more exemplary embodiments, the DMA engine (612) may access memory implemented in external memory (e.g., memory outside the IC (100)) and / or another die (e.g., a die containing only the RAM of the IC (100)). For example, the DMA engine (612) may receive data streams from DPEs (402) and transfer the data streams to memory via the physical interface (306). Similarly, the DMA engine (612) may receive data from external memory, where the data may be distributed to other tile(s) (408) of the logical interface (304) and / or to target DPEs (402).

[0138] In one or more exemplary embodiments, the DMA engine (612) includes security bits that may be set using DPE global control settings (GCS) registers (638). Memory may be divided into different regions or partitions where the DPE array (110) is allowed to access only specific regions of memory. The security bits within the DMA engine (612) may be set so that the DPE array (110) is allowed by the DMA engine (612) to access only specific regions of memory(s) allowed for each security bit. For example, an application implemented by the DPE array (110) may be restricted to accessing only specific regions of memory, restricted to reading only from specific regions of memory, and / or restricted from writing entirely to memory using this mechanism.

[0139] The security bits within the DMA engine (612) controlling access to memory may be implemented to fully control the DPE array (110) or may be implemented in a more granular manner, wherein access to memory may be specific and / or controlled for each group of cores configured to operate on a DPE basis, for example, per core, or in a coordinated manner to implement, for example, the kernel and / or other applications.

[0140] The stream interface (614) can receive data from the physical interface (306) and forward the data as a stream to the multiplexer / demultiplexer (608). The stream interface (614) can additionally receive data from the stream multiplexer / demultiplexer (608) and forward the data to the physical interface (306). The selector block (616) can be configured to transfer data from the DMA engine (612) or from the stream interface (614) onto the physical interface (306).

[0141] The CDT circuit (620) can perform control, debug, and trace operations within the tile (408). Regarding debugging, each register located in the tile (408) is mapped onto a memory map accessible via a memory mapping switch (602). The CDT circuit (620) may include circuit components such as, for example, trace hardware, trace buffers, performance counters, and / or stall logic. The trace hardware of the CDT circuit (620) can collect trace data. The trace buffers of the CDT circuit (620) can buffer trace data. The CDT circuit (620) can additionally output trace data to a stream switch (606).

[0142] In one or more exemplary embodiments, the CDT circuit (620) may collect data, e.g., trace and / or debug data, packetize such data, and then output the packetized data through the stream switch (606). For example, the CDT circuit (620) may output the packetized data and provide such data to the stream switch (606). Additionally, control registers (636) or others may be read or written during debugging through memory mapping transactions via the memory mapping switch (602) of each tile. Similarly, performance counters within the CDT circuit (620) may be read or written during profiling through memory mapping transactions via the memory mapping switch (602) of each tile.

[0143] In one or more exemplary embodiments, the CDT circuit (620) may receive any events propagated by the event broadcast circuit unit (604) (or event broadcast circuit unit (630)) or events selected per bitmask used by the interface of the event broadcast circuit unit (604) coupled to the CDT circuit (620). The CDT circuit (620) may additionally receive events generated by the event logic (632). For example, the CDT circuit (620) may receive broadcast events from DPEs (402), tiles (408) (e.g., event logic (632) and / or event broadcast switch (604)), and / or other tiles of the logical interface (304). The CDT circuit (620) may pack a plurality of these events together into a packet, e.g., packetize, and associate the packetized events with timestamp(s). The CDT circuit (620) can additionally transmit packetized events to destinations outside the tile (408) via the stream switch (606). The events may also be transmitted to the physical interface (306) via the bit interface (610), DMA engine (612), and / or stream interface (614) by the stream switch (606) and the stream multiplexer / demultiplexer (608).

[0144] The DPE GCS registers (638) may store DPE global control settings / bits (also referred to as “security bits” in this disclosure) used to enable or disable secure access to and / or from the DPE array (110). The DPE GCS registers (638) may be programmed via an SoC security / initialization interface, which will be described in more detail below in relation to FIG. 6c. Security bit(s) received from the SoC security / initialization interface may be propagated from one tile to the next of the logical interface (304) via a bus as exemplified in FIG. 6a.

[0145] In one or more exemplary embodiments, external memory-mapped data transfers into the DPE array (110) may not be secure or trusted. Any entity in the IC (100) capable of communicating via memory-mapped data transfers may communicate with the DPE array (110) without setting security bits in the DPE GCS registers (638). By setting security bits in the DPE GCS registers (638), specific entities allowed to communicate with the DPE array (110) may be defined such that only specific entities capable of generating secure traffic may communicate with the DPE array (110).

[0146] In one or more exemplary embodiments, memory-mapped data transfers may include additional sideband signals, e.g., bits, that specify whether a transaction is safe. When security bits in the DPE GCS registers (638) are set, memory-mapped transactions entering into the logical interface (304), e.g., a tile (408), must have a set of sideband signals to indicate that the memory-mapped transaction arriving at the logical interface (304) is safe. If the memory-mapped transaction arriving at the logical interface (304) does not have a set of sideband bits and security bits are set in the DPE GCS registers (638), the logical interface (304) does not allow the transaction to enter or pass through the DPEs (402).

[0147] In one or more exemplary embodiments, the IC (100) includes a security agent (e.g., circuit) that acts as a source of trust. For example, a PMC may be the security agent. The security agent may configure different entities (e.g., circuits within the IC (100)) with permissions necessary to set sideband bits within memory-mapped transactions to access the DPE array (110) when the security bits of the DPE GCS registers (638) are set. The security agent provides the ability to issue security transactions to the DPE array (110) to different masters, which may be implemented in this disclosure, by granting permissions to these masters at the time the IC (100) is configured.

[0148] FIG. 6b illustrates another exemplary implementation of a tile (408). The exemplary architecture illustrated in FIG. 6b may also be used to implement any of the other tiles included in the logical interface (304). The example in FIG. 6b illustrates a simplified version of the architecture illustrated in FIG. 6a. The tile architecture of FIG. 6b provides connectivity between the DPEs (402) and other systems and / or dies within the IC (100). For example, the tile (408) in FIG. 6b may provide an interface between the DPEs (402) and analog / mixed-signal circuit blocks, ASICs, or other systems as described herein. In the example of FIG. 6b, the DMA engine (612), stream interface (614), selector block (616), bridge (618), and stream multiplexer / demultiplexer (608) are omitted. In this way, the tile (408) of FIG. 6b may be implemented using a small area of ​​the IC (100). Furthermore, as illustrated, the stream switch (606) is directly coupled to the bit-unit interface (610).

[0149] The exemplary architecture of FIG. 6b cannot receive memory mapping data, such as configuration data, for the purpose of configuring DPEs (402). Such configuration data may be received from neighboring tiles via memory mapping switches (602) or sent to a subset of DPEs managed by tile (408) (e.g., up to the column of DPEs (402) on tile (408) of FIG. 6b).

[0150] FIG. 6c illustrates another exemplary implementation of a tile (408). In certain exemplary implementations, the architecture illustrated in FIG. 6c may be used to implement only one tile within a logical interface (304). The architecture illustrated in FIG. 6c is similar to the architecture illustrated in FIG. 6b. In FIG. 6c, additional components such as a security / initialization interface (640), a clock signal generator (642), and a global timer (644) are included.

[0151] In the example of FIG. 6c, the security / initialization interface (640) may provide access to global reset registers and DPE GCS registers (638) for a DPE array (110) (not shown). The DPE GCS registers (638) may include control registers for a clock signal generator (642). As illustrated, the security / initialization interface (640) may provide security bits to the DPE GCS registers (638) and propagate security bits to other DPE GCS registers (638) in other tiles of the logical interface (304). The security / initialization interface (640) may implement a single slave endpoint for the logical interface (304).

[0152] In the example of FIG. 6c, the clock signal generator (642) may generate one or more clock signal(s) (646) and / or one or more reset signals (650). The clock signal(s) (646) and / or reset signals (650) may be distributed to each of the DPEs (402) and / or to other tiles of the logical interface (304) of the DPE array (110). For example, the clock signal generator (642) may include one or more phase lock loop (PLL) circuits. As illustrated, the clock signal generator (642) may receive a reference clock signal generated by another circuit outside the DPE array (110) that may be located on the same die as the DPE array (110). In another example, the reference clock may be received from the physical interface (306). The clock signal generator (642) can generate clock signal(s) (646) based on the received reference clock signal.

[0153] In the example of FIG. 6c, the clock signal generator (642) is configured via the security / initialization interface (640). For example, the clock signal generator (642) may be configured by loading data into the DPE GCS registers (638). Thus, the generation of the clock frequency or clock frequencies and reset signals (650) of the DPE array (110) may be set by writing appropriate configuration data into the DPE GCS registers (638) via the security / initialization interface (640). For testing purposes, the clock signal(s) (646) and / or reset signals (650) may also be routed directly to the physical interface (306).

[0154] The security / initialization interface (640) may be coupled to a control / debug (circuit) block (e.g., a control and / or debug system of an IC (100) not shown). In one or more exemplary embodiments, the security / initialization interface (640) may provide status signals to the control / debug block. As an exemplary and non-limiting example, the security / initialization interface (640) may provide a "PLL lock" signal generated internally by a clock signal generator (642) to the control / debug block. The PLL lock signal may indicate when the PLL acquires a lock on the reference clock signal.

[0155] The security / initialization interface (640) may receive commands and / or data through the physical interface (306). The data may include security bits, clock signal generator configuration data, and / or other data that may be written to the DPE GCS registers (638) as described in this disclosure.

[0156] The global timer (644) can interface with the CDT circuit (620). For example, the global timer (644) may be coupled to the CDT circuit (620). The global timer (644) may provide a signal used by the CDT circuit (620) to time-stamp events used for tracing. In one or more exemplary embodiments, the global timer (644) may be coupled to the CDT circuit (620) within other tiles of the logical interface (304). For example, the global timer (644) may be coupled to the CDT circuit (620) in the exemplary tiles of FIG. 6a, 6b, and / or 6c. The global timer (644) may also be coupled to a control / debug block.

[0157] Referring collectively to the architectures of FIGS. 6a, 6b, and 6c, the tile (408) can communicate with the DPEs (402) using various different data paths. In one example, the tile (408) can communicate with the DPEs (402) using a DMA engine (612). For example, the tile (408) can communicate with the DMA engines of one or more DPEs (402) of the DPE array (110) using the DMA engine (612). Communication may flow from the DPE (402) to the tile (408) of the logical interface (304) or from the tile (408) of the logical interface (304) to the DPE (402). In another example, the DMA engine (612) can communicate with one or more cores (404) of one or more DPEs (402) of the DPE array (110) by stream switches within the individual DPEs. Communication may flow from one or more cores (404) to a tile (408) of a logical interface (304) and / or from a tile (408) of a logical interface (304) to one or more cores (404) of one or more DPEs (402) of a DPE array (110).

[0158] In one or more exemplary embodiments, each of the bit interface (610), the DMA engine (612), and the stream interface (614) may optionally be turned on and connected to the physical interface (306) or turned off and disconnected from the physical interface (306). Thus, any one or more or any combination of the bit interface (610), the DMA engine (612), and the stream interface (614) may be connected to or disconnected from the physical interface (306) based on configuration data for the tile (408). In one embodiment, such configuration data may be loaded into control registers (636). In another embodiment, such configuration data may be provided by the configuration pins of the IC (100).

[0159] The specific interface(s) connected to or disconnected from the physical interface (306) may vary from one tile (408) to another. For example, at the first tile (408), a specific combination of one or more interfaces may be connected to the physical interface (306), while a different combination of one or more interfaces may be connected to the physical interface (306) at the second and different tiles (408). Furthermore, the specific interfaces and / or interfaces connected to and / or disconnected from the physical interface (306) may vary based on the specific types of interfaces included in each tile (408).

[0160] In one exemplary embodiment, configuration data for a tile (408) enables a stream interface (614) and connects to the physical interface (306) while the bit interface (610) and / or DMA engine (612) are disconnected from the physical interface (306). For illustrative purposes, the stream interface (614) may be connected to the physical interface (306) to facilitate or access enhanced functions of other dies of the IC (100) with low latency.

[0161] In another exemplary embodiment, configuration data for a tile (408) enables a DMA engine (612) (e.g., a memory-mapping interface) and connects to the physical interface (306) while the bit interface (610) and / or stream interface (614) are disconnected from the physical interface (306). For illustrative purposes, the DMA engine (612) may be connected to the physical interface (306) to access external memory by referencing memory located outside the chip or outside the IC (100), or to access memory implemented on the IC (100) of a different die. Examples of memories include, but are not limited to, RAM (e.g., DDR) and / or high-bandwidth memory (HBM), whether or not implemented on other dies of the IC (100) and / or outside the IC (100).

[0162] In another exemplary embodiment, configuration data for the tile (408) enables the bit interface (610) and connects to the physical interface (306) while the DMA engine (612) and / or stream interface (614) are disconnected from the physical interface (306). For illustrative purposes, the bit interface (610) may also be connected to the physical interface (306) to provide error notifications and / or interrupts to other dies of the IC (100).

[0163] FIG. 7 illustrates an exemplary implementation of a bit-unit interface (610). In the example of FIG. 7, the bit-unit interface (610) includes a plurality of channels that couple a physical interface (306) to a stream switch (606) and / or a stream multiplexer / demultiplexer (608), depending on the specific tile architecture used. The specific number of channels in FIG. 7 within the bit-unit interface (610) is for illustrative purposes only and is not a limitation. In other embodiments, the bit-unit interface (610) may include fewer or more channels than those shown in FIG. 7. Furthermore, while the bit-unit interface (610) is connected to the physical interface (306), in one or more other exemplary embodiments, the bit-unit interface (610) may be coupled to one or more other systems and / or circuit blocks of the IC (100).

[0164] In one or more exemplary embodiments, the physical interface (306) and / or other dies coupled thereto operate at a different reference voltage and a different clock speed than the DPEs (402). Thus, in the example of FIG. 7, the bit-unit interface (610) includes a plurality of shift and isolation circuits (702) and a plurality of asynchronous FIFO memories (704). Each of the channels includes a shift isolation circuit (702) and an asynchronous FIFO memory (704). A first channel subset transmits data from the physical interface (306) (and / or other circuitry) to a stream switch (606) and / or a stream multiplexer / demultiplexer (608). A second channel subset transmits data from the stream switch (606) and / or the stream multiplexer / demultiplexer (608) to the physical interface (306) and / or other circuitry.

[0165] The shift and isolation circuits (702) can interface between domains of different voltages. In this case, the shift and isolation circuits (702) can provide an interface that transitions between the operating voltage of the physical interface (306) and / or other circuit section and the operating voltage of the DPEs (402). The asynchronous FIFO memories (704) can interface between two different clock domains. In this case, the asynchronous FIFO memories (704) can provide an interface that transitions between the clock rate of the physical interface (306) or other circuit section and / or other circuit section coupled thereto and the clock rate of the DPEs (402).

[0166] In one or more exemplary embodiments, the asynchronous FIFO memories (704) have 32-bit interfaces to the DPE array (110). The connections between the asynchronous FIFO memories (704) and the shift and isolation circuits (702), and the connections between the shift and isolation circuits (702) and the physical interface (306) may have programmable (e.g., configurable) widths. For example, the connections between the asynchronous FIFO memories (704) and the shift and isolation circuits (702), and the connections between the shift and isolation circuits (702) and the physical interface (306) may be configured to have widths of 32-bit, 64-bit, or 128-bit. As discussed, the bit-width interface (610) is configurable by a memory mapping switch (602) that writes configuration data to control registers (636) to achieve the described bit widths. By using a memory mapping switch (602), the side of the asynchronous FIFO memories (704) on the physical interface (306) side may be configured using any one of 32-bit, 64-bit, or 128-bit. The bit widths provided in this disclosure are for illustrative purposes only. In other embodiments, other bit widths may be used. In any case, the widths described for the various components may vary based on configuration data loaded into the control registers (636).

[0167] FIG. 8 illustrates an exemplary implementation of a stream interface (614). In one embodiment, DPEs (402) may access the DMA engine (612) using a stream switch (606). The DMA engine (612) may convert memory mapping transactions from the physical interface (306) into data streams for transmission to the DPEs and convert data streams from the DPEs into memory mapping transactions for transmission through the physical interface (306). In another embodiment, data streams may be sent to the stream interface (614).

[0168] In the example of FIG. 8, the stream interface (614) includes a plurality of channels that couple the physical interface (306) to a stream switch (606) and / or a stream multiplexer / demultiplexer (608). Each channel may include either a FIFO memory and an upsize circuit or a downsize circuit. A first channel subset transmits data from the physical interface (306) to the stream switch (606) and / or the stream multiplexer / demultiplexer (608). A second channel subset transmits data from the stream switch (606) and / or the stream multiplexer / demultiplexer (608) to the physical interface (306). The specific number of channels in FIG. 8 within the NoC stream interface (614) is for illustrative purposes only and is not a limitation. In other exemplary embodiments, the stream interface (614) may include fewer or more channels than those shown in FIG. 8.

[0169] In one or more exemplary embodiments, each upsize circuit (808) (abbreviated as “US circuit” in FIG. 8) can receive a data stream and increase the width of the received data stream. For example, each upsize circuit (808) may receive a 32-bit data stream and output a 128-bit data stream to the corresponding FIFO memory (810). Each FIFO memory (810) is coupled to an arbitration and multiplexer circuit (812). The arbitration and multiplexer circuit (812) may arbitrate between the received data streams using a specific arbitration scheme or priority (e.g., round-robin or other style) to provide the resulting output data stream to the physical interface (306). The arbitration and multiplexer circuit (812) may process and accept a new request every clock cycle. Clock domain crossing between DPEs (402) and the physical interface (306) may be processed within the tile (408) using, for example, FIFO memories (804).

[0170] The demultiplexer (802) can receive a data stream from the physical interface (306). For illustrative purposes, the data streams may be 128-bit wide. Clock domain crossing between the DPEs (402) and the physical interface (306) may be handled within the bitwise interface (610) as previously described. The demultiplexer (802) can forward the received data stream to one of the FIFO memories (804). The specific FIFO memory (804) to which the demultiplexer (802) provides the data stream may be encoded within the data stream itself. The FIFO memories (804) are coupled to downsize circuits (806) (abbreviated as "DS circuits" in FIG. 8). The downsize circuits (806) can buffer the received streams using time-division multiplexing and then downsize them to a smaller width. For example, downsizing circuits (806) can downsize the stream from 128 bits wide to 32-bit wide.

[0171] As illustrated, downsize circuits (806) and upsize circuits (808) are coupled to a stream switch (606) or a stream multiplexer / demultiplexer (608) depending on the specific architecture of the tile of the logical interface (304) used. FIG. 8 is provided for illustrative purposes only and is not intended as a limitation. The order and / or connectivity of components (e.g., upsize / downsize circuits and FIFO memory) in the channels may vary.

[0172] In one or more other exemplary embodiments, the bit-unit interface (610) may include upsize circuits and / or downsize circuits as described in relation to FIG. 8, as described in relation to FIG. 7. For example, downsize circuits may be included in each channel that transmits data from the physical interface (308) (or other circuit part) to the stream switch (606) and / or the stream multiplexer / demultiplexer (608). Upsize circuits may be included in each channel that transmits data from the stream switch (606) and / or the stream multiplexer / demultiplexer (608) to the physical interface (306) (or other circuit part).

[0173] In one or more other exemplary embodiments, although illustrated as independent elements, each downsize circuit (806) may be combined with the corresponding FIFO memory (804), for example, as a single block or circuit. Similarly, each upsize circuit (808) may be combined with the corresponding FIFO memory (810), for example, as a single block or circuit.

[0174] FIG. 9 illustrates an exemplary implementation of a DMA engine (612). In the example of FIG. 9, the DMA engine (612) includes a DMA controller (902). The DMA controller (902) may be divided into two separate modules or interfaces. Each module may operate independently of the other module. The DMA controller (902) may include a memory mapping to stream interface (interface) (904) and a stream to memory mapping interface (interface) (906). Each of the interface (904) and the interface (906) may include two or more separate channels. Thus, the DMA engine (612) can receive two or more incoming streams from the stream switch (606) through the interface (906) and send two or more outgoing streams to the stream switch (606) through the interface (904). The DMA controller (902) may further include a master memory mapping interface (914). The master memory mapping interface (914) couples the physical interface (306) to the interface (904) and the interface (906).

[0175] The DMA engine (612) may also include a hardware synchronization circuit (910) and a buffer descriptor register file (908). The hardware synchronization circuit (910) and the buffer descriptor register file (908) may be accessed through a multiplexer (912). As such, both the hardware synchronization circuit (910) and the buffer descriptor register file (908) may be accessed externally through control interfaces. Examples of such control interfaces include, but are not limited to, memory mapping interfaces or control stream interfaces of the DPEs (402). An example of a control stream interface of a DPE is a streaming interface output from the core of the DPE.

[0176] The hardware synchronization circuit (910) may be used to synchronize multiple channels included in the DMA engine (612) and / or channels within the DMA engine (612) with a master that polls and drives lock requests. For example, the master may be another system coupled to the DMA engine (612) via a physical interface (306). In another example, the master may also receive an interrupt generated by the hardware synchronization circuit (910) within the DMA engine (612) when a lock is available.

[0177] DMA transfers may be defined by buffer descriptors stored in a buffer descriptor register file (908). The interface (906) may request read transfers from the physical interface (306) based on information in the buffer descriptors. Fetching a stream from the interface (904) to the stream switch (606) may be configured as packet-switched or circuit-switched based on configuration registers for the stream switches.

[0178] FIG. 10 illustrates an exemplary embodiment of physical interfaces (306 and 312). A physical interface (306) may include a plurality of circuit blocks (1002) (e.g., illustrated as 1002-1 to 1002-N in FIG. 10). In the example of FIG. 10, the physical interface (306) is implemented as a multi-channel interface in which each of the circuit blocks (1002) corresponds to a channel. A physical interface (312) of the die (106) also includes a plurality of circuit blocks (1006) (e.g., illustrated as 1006-1 to 1006-N). The physical interface (312) is implemented as a multi-channel interface in which each of the blocks (1006) corresponds to a channel. In the example of FIG. 10, the channel is formed by a pair of circuit blocks, for example, circuit block (1002-1) and circuit block (1006-1), also referred to as “corresponding circuit blocks” forming a single channel. In an exemplary embodiment, each of the blocks (1002 and 1004) may be implemented as a Laguna site (as is available from Xilinx, Inc., San Jose, California).

[0179] Circuit block (1002-1) includes a plurality of flip-flops (1004) (labeled "FF" in FIG. 10). In the example of FIG. 10, six flip-flops (1004) (e.g., FF 1004-1 to FF 1004-6) form a channel. Each flip-flop (1004) is provided with a clock signal (TX-CLK), a clock-enable signal (CE), and a set-reset (SR) signal. Similarly, circuit block (1006-1) includes a plurality of flip-flops (1008) (labeled "FF" in FIG. 10). In the example of FIG. 10, six flip-flops (1008) (e.g., FF 1008-1 to FF 1008-6) form a channel. Each flip-flop (1008) is provided with a clock signal (RX-CLK), a clock-enable signal (CE), and a set-reset (SR) signal. Each pair of transmit flip-flops and receive flip-flops (e.g., FF 1004-6 and FF 1008-6) forms a cell. Thus, the exemplary channel illustrated in FIG. 10 includes six cells.

[0180] In the example of FIG. 10, the die-to-die wires (116) connect the flip-flops (1004) of circuit block (1002-1) to the flip-flops (1008) of circuit block (1006-1). In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in an interposer as described in relation to FIG. 1. In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in a bridge die as described in relation to FIG. 2.

[0181] In one exemplary embodiment, each circuit block (1002) may use the same or common clock signal. In other exemplary embodiments, each circuit block (1002) may use a clock signal independent of other circuit blocks (1002). The independent clock signals may not be derivatives of each other, or they may be clock signals that differ in one or more characteristics, such as phase, frequency, duty cycle, etc. In yet another exemplary embodiment, different groupings of one or more circuit blocks (1002) may use the same or common clock signal independent of each other for clock signals from one grouping to another. The clock signals provided to the circuit blocks (1006) may correspond to or be matched with the clock signals of the corresponding circuit blocks (1002). In this regard, different channels do not need to be synchronous with each other.

[0182] In another exemplary embodiment, the flip-flops within each circuit block (1002) may be configured to be either transmitting or receiving flip-flops. The corresponding flip-flops in the corresponding circuit block (1006) are configured in reverse. In the example of FIG. 10, each flip-flop (1004) in circuit block (1002-1) is configured as a transmitting flip-flop, and each flip-flop (1008) in the corresponding circuit block (1006-1) is configured as a receiving flip-flop. In another example, each flip-flop (1004) in circuit block (1002-1) may be configured as a receiving flip-flop, and each flip-flop (1008) in the corresponding circuit block (1006-1) may be configured as a transmitting flip-flop. Each circuit block (1002) may be configured independently of the corresponding circuit block (1006) configured in reverse.

[0183] In another example, one or more of the flip-flops (1004) of the circuit block (1002-1) may be configured as transmitting flip-flops (e.g., FFs (1004-1 and 1004-2)), while one or more of the other flip-flops (1004) (e.g., FFs (1004-3, 1004-4, 1004-5, and 1004-6)) may be configured as receiving flip-flops. The corresponding circuit block (1006-1) may be configured in reverse such that one or more of the flip-flops (1008) are configured as receiving flip-flops (e.g., FFs (1008-1 and 1008-2)), while one or more of the other flip-flops (1008) (e.g., FFs (1008-3, 1008-4, 1008-5, and 1008-6)) are configured as transmitting flip-flops. In this way, each circuit block (1002) may be configured with any number of transmitting and receiving flip-flops, while each corresponding circuit block (1006) is configured in reverse.

[0184] In one exemplary embodiment, any data streams received from the interface of the tile (408) (e.g., bit-for-bit interface (610), DMA engine (612), and / or stream interface (614)) may be provided to different circuit blocks (1002) in a bit-for-bit (e.g., wire-to-wire) correspondence. For example, a 32-bit data stream from the interface of the tile (408) may be provided to the physical interface (306) and may utilize six circuit blocks (1002). A 128-bit stream provided from the interface of the tile (408) may be mapped to 22 circuit blocks (1002). However, it should be understood that the number of signal lines (e.g., flip-flops) included in each circuit block (1002 and / or 1006) is for illustrative purposes only. In other exemplary embodiments, the number of signal lines may be less than 6, while in other cases it may be greater than 6.

[0185] FIG. 11 illustrates another exemplary embodiment of physical interfaces (306 and 312). The physical interfaces (306 and 312) are implemented as multi-channel interfaces. In the example of FIG. 11, circuit blocks (1002 and 1006) are implemented as high-bandwidth memory (HBM) physical interfaces (PHYs). In exemplary embodiments, the physical interfaces (306 and 312) may be implemented to comply with the 2013 high-bandwidth memory (HBM) DRAM memory standard (JESD235) or the 2020 HBM DRAM memory standard (JESD235A).

[0186] Circuit block (1002-1) includes a data channel circuit (1102), a command address circuit (1104), and a clock and power manager (1106). The corresponding circuit block (1006-1) includes a data channel circuit (1108), a command address circuit (1110), and a clock and power manager circuit (1112). Each of the data channel blocks (1102 and 1108) provides eight channels having four 32-bit words per channel. An example of FIG. 11 illustrates that each pair of circuit blocks (e.g., 1002-1 and 1006-1) includes eight channels, and thus, 1028 bits of parallel data can be exchanged.

[0187] In an exemplary embodiment, each of the eight channels may have independent clocking and power management, such as as supported by clock and power managers (1106 and 1112). In this regard, the different channels do not need to be synchronous with each other. Furthermore, each of the eight channels supports bidirectional communication. In the example of FIG. 11, the die-to-die wires (116) connect circuit block (1002-1) to circuit block (1006-1). In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in an interposer as described in relation to FIG. 1. In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in a bridge die as described in relation to FIG. 2.

[0188] In one exemplary embodiment, any data streams received from the interface of the tile (408) (e.g., bit-by-bit interface (610), DMA engine (612), and / or stream interface (614)) may be provided to different circuit blocks (1002) in a bit-to-bit (e.g., wire-to-wire) correspondence. For example, a 32-bit data stream output from the interface of the tile (408) may be provided to the physical interface (306) and may utilize one 32-bit word of a channel in the circuit block (1002-1). A 128-bit data stream may also be mapped to one entire channel of the circuit block (1002-1).

[0189] FIG. 12 illustrates another exemplary embodiment of physical interfaces (306 and 312). A physical interface (306) comprises one or more circuit blocks (1002), while a physical interface (312) comprises one or more circuit blocks (1006). In the example of FIG. 12, each circuit block (1002 and 1006) implements a transceiver. The transceiver may be implemented as a high-speed transceiver capable of transmitting and receiving data at high data rates, for example, in the range of gigabits per second, wherein each pair of circuit blocks (1002, 1006) (e.g., 1002-1 and 1006-1) implements a channel. Each channel includes a serialized transmission path and a serialized reception path.

[0190] Referring to the physical interface (306), the circuit blocks (1002) may include a SERDES (serializer / de-serializer) (1202) and a transceiver (1204). The SERDES (1202) may receive a data stream (e.g., parallel data) from an interface of the tile (408) (e.g., bit unit interface (610), DMA engine (612), and / or stream interface (614)) and convert the data stream into serialized data to be output to the transceiver (1204). The data stream received from the interface of the tile (408) may be any bit width among various different bit widths. Exemplary bit widths include, but are not limited to, 32, 64, 128, and 256 bits.

[0191] SERDES (1202) can additionally receive serialized data from the transceiver (1204) and convert the received serialized data into a data stream containing parallel data. The resulting data stream generated by SERDES (1202) may be any bit width among the various bit widths previously described. SERDES (1202) may output the resulting data stream to the interface of the tile (408).

[0192] The transceiver (1204) may include a transmitting PCS (Physical Coding Sublayer) circuit (1206), a receiving PCS circuit (1208), a transmitting PMA (Physical Medium Attachment) circuit (1210), and a receiving PMA (1212). The transmitting PCS circuit (1206) may receive serialized data from SERDES (1202). The transmitting PCS circuit (1206) may perform operations such as, for example, data encoding, scrambling, alignment marker insertion, block and symbol redistribution, and lane block synchronization and de-skew. The transmitting PMA (1210) may receive data from the transmitting PCS (1206) and perform operations such as, for example, PMA framing, octet synchronization / detection, and additional scrambling. The transmitting PMA (1210) can transmit serialized data to the physical interface (312) via the die-to-die wire (116).

[0193] The receiving PMA (1212) can receive data from the physical interface (312) via the die-to-die wire (116). The receiving PMA (1212) can perform operations such as, for example, PMA framing, octet synchronization / detection, and descramming. The receiving PMA (1212) outputs the data to the receiving PCS (1208). The receiving PCS (1208) can perform operations on the received data such as, for example, data decoding, descramming, alignment marker removal, block and symbol redistribution, and lane block synchronization and skew removal. The receiving PCS (1208) transmits the processed data to the SERDES (1202) for conversion into a data stream to be provided to the interface of the tile (408).

[0194] The circuit blocks (1006) may include a transceiver (1214). The transceiver (1214) may include a receiving PCS (1216), a receiving PMA (1220), a transmitting PMA (1222), and a transmitting PCS (1218). The circuit blocks (1006) may or may not include SERDES depending on the specific types of circuit blocks implemented on the die (106) that are for transmitting data to the DPE array (110) and / or receiving data from the DPE array (110).

[0195] In an exemplary embodiment, the transceiver (1204) and the transceiver (1214) may each be implemented as a Gigabit Transceiver (GT) as available from Xilinx, Inc., San Jose, California. In the example of FIG. 12, the die-to-die wires (116) connect the transceiver (1204) to the transceiver (1214) as illustrated. In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in an interposer as described in relation to FIG. 1. In one or more exemplary embodiments, the die-to-die wires (116) may be implemented in a bridge die as described in relation to FIG. 2.

[0196] The exemplary embodiments described in connection with FIGS. 10, 11, and 12 describe several different types of physical interfaces that may be used to link the die (104) to the die (106) in a communicable manner. In other exemplary embodiments, the physical interface (306) may include several different types of circuit blocks (1002). For example, the physical interface (306) may include one or more of the circuit blocks (1002) of FIG. 10, one or more of the circuit blocks (1002) of FIG. 11, one or more of the circuit blocks (1002) of FIG. 12, or any combination thereof.

[0197] In one embodiment, in this heterogeneous embodiment of the physical interface (306), similar types of circuit blocks may be used to connect to one die (e.g., die (106)), while other types of circuit blocks (e.g., where "type" in this context refers to a specific embodiment such as FIG. 10, FIG. 11, or FIG. 12) are used to communicate with different dies (e.g., additional dies other than the bridge die).

[0198] In another embodiment, in a heterogeneous embodiment of the physical interface (306), circuit blocks of different types may be included in and connected to the die (106). For example, the physical interface may include one or more of the circuit blocks (1002) of FIG. 10, one or more of the circuit blocks (1002) of FIG. 11, one or more of the circuit blocks (1002) of FIG. 12, or any combination thereof, which are those communicating with the corresponding embodiment of the physical interface (312) of the die (106).

[0199] FIG. 13 illustrates an exemplary embodiment including a plurality of DPE interfaces. In the example of FIG. 13, dies (104 and 106) of an IC (100) are shown. Wires between the dies may be implemented as described in relation to FIG. 1 or FIG. 2. As illustrated, the die (104) includes two DPE arrays (110-1 and 110-2). The DPE array (110-1) is connected to a DPE interface (302-1). The DPE interface (302-1) includes a logical interface (304-1) and a physical interface (306-1). The DPE array (110-2) is connected to a DPE interface (302-2). The DPE interface (302-2) includes a logical interface (304-2) and a physical interface (306-2).

[0200] The die (106) includes a physical interface (312-1) and a physical interface (312-2). The physical interface (312-1) is connected to the physical interface (306-1). The physical interface (312-2) is connected to the physical interface (306-2). In one or more exemplary embodiments, the physical interfaces (306-1, 312-1, 306-2, and 312-2) are implemented as the same interfaces (e.g., matched and as illustrated in FIG. 10, FIG. 11, or FIG. 12). In one or more other exemplary embodiments, the physical interfaces (306-1 and 312-1) are interfaces of the same type (e.g., matched and illustrated in FIG. 10, FIG. 11, or FIG. 12), whereas the physical interfaces (306-2 and 312-2) are interfaces of the same type (e.g., matched) but are different from the type of the physical interfaces (306-1 and 312-1).

[0201] In the example of FIG. 13, including an additional DPE interface increases the bandwidth in and out of the dies (104). In that example, the DPE array (110-1) and the DPE array (110-2), which are implemented as separate DPE arrays, are not linked to each other so as to be communicable, thereby preventing the DPE array (110-1) from communicating with the DPE array (110-2). In other words, the DPEs (402) of the DPE array (110-1) cannot communicate with the DPEs (402) of the DPE array (110-2) without communicating through the die-to-die wires (116) (e.g., through the die (106)).

[0202] FIG. 14 illustrates another exemplary embodiment including a plurality of DPE interfaces. In the example of FIG. 14, dies (104 and 106) of an IC (100) are shown. Wires between the dies may be implemented as described in relation to FIG. 1 or FIG. 2. As illustrated, the die (104) includes a single DPE array (110). The DPE array (110) is connected to a DPE interface (302-1) and a DPE interface (302-2). The DPE interface (302-1) includes a logical interface (304-1) and a physical interface (306-1). The DPE interface (302-2) includes a logical interface (304-2) and a physical interface (306-2).

[0203] The die (106) includes a physical interface (312-1) and a physical interface (312-2). The physical interface (312-1) is connected to the physical interface (306-1). The physical interface (312-2) is connected to the physical interface (306-2). In one or more exemplary embodiments, the physical interfaces (306-1, 312-1, 306-2, and 312-2) are implemented as the same interfaces (e.g., matched and as illustrated in FIG. 10, FIG. 11, or FIG. 12). In one or more other exemplary embodiments, the physical interfaces (306-1 and 312-1) are interfaces of the same type (e.g., matched and illustrated in FIG. 10, FIG. 11, or FIG. 12), whereas the physical interfaces (306-2 and 312-2) are interfaces of the same type (e.g., matched) but are different from the type of the physical interfaces (306-1 and 312-1).

[0204] In the example of FIG. 14, including additional DPE interfaces increases the bandwidth in and out of the die (104). In this example, since the DPE array (110) is implemented as a single DPE array, each DPE (402) can communicate with other DPEs (402). Communications between the DPEs (402) and the logical interfaces (304-1 and 304-2) occur through the DPEs (402) located directly above the tile (408). The example of FIG. 14 allows DPEs (402) located on the logical interface (304-1) to communicate with DPEs (402) located on the logical interface (304-2), and vice versa. In these embodiments, clusters of DPEs (402) may be formed without restriction on which of the logical interfaces (304-1 or 304-2) may be used or connected to the cluster. In other words, a cluster of DPEs (402) may include one or more DPEs (402) or a column of DPEs (402) on a logical interface (304-1) and one or more DPEs (402) or a column of DPEs (402) on a logical interface (304-2).

[0205] FIG. 15 illustrates another exemplary embodiment including multiple DPE interfaces. The example of FIG. 15 is similar to the example of FIG. 13 except that three dies are included in the IC (100). The IC (100) includes dies (104, 106-1, and 106-2). A physical interface (312-1) is implemented on die (106-1). A physical interface (312-2) is implemented on die (106-2). Thus, the DPE array (110-1) can communicate only with die (106-1), whereas the DPE array (110-2) can communicate only with die (106-2). Still, the additional DPE interface increases the bandwidth in and out of die (104).

[0206] FIG. 16 illustrates another exemplary embodiment including multiple DPE interfaces. The example of FIG. 16 is similar to the example of FIG. 14 except that three dies are included in the IC (100). The IC (100) includes dies (104, 106-1, and 106-2). A physical interface (312-1) is implemented on die (106-1). A physical interface (312-2) is implemented on die (106-2). In the example of FIG. 16, any one or more of the DPEs (402) can communicate with die (106-1), die (106-2), or both. Additional DPE interfaces increase the bandwidth in and out of die (104).

[0207] FIG. 17 illustrates another exemplary embodiment including a plurality of DPE interfaces. In the example of FIG. 17, two dies (104), illustrated as die (104-1) and die (104-2), are illustrated as including different DPE arrays. The dies (104-1 and 104-2) are connected to die (106) of the IC (100). Wires between the dies may be implemented as described in relation to FIG. 1 or FIG. 2. As illustrated, die (104-1) includes a DPE array (110-1). Die (104-2) includes a DPE array (110-2). The DPE array (110-1) is connected to a DPE interface (302-1). The DPE array (110-2) is connected to a DPE interface (302-2). The DPE interface (302-1) includes a logical interface (304-1) and a physical interface (306-1). The DPE interface (302-2) includes a logical interface (304-2) and a physical interface (306-2).

[0208] The die (106) includes a physical interface (312-1) and a physical interface (312-2). The physical interface (312-1) is connected to the physical interface (306-1). The physical interface (312-2) is connected to the physical interface (306-2). In one or more exemplary embodiments, the physical interfaces (306-1, 312-1, 306-2, and 312-2) are implemented as the same interfaces (e.g., matched and as illustrated in FIG. 10, FIG. 11, or FIG. 12). In one or more other exemplary embodiments, the physical interfaces (306-1 and 312-1) are interfaces of the same type (e.g., matched and illustrated in FIG. 10, FIG. 11, or FIG. 12), whereas the physical interfaces (306-2 and 312-2) are interfaces of the same type (e.g., matched) but are different from the type of the physical interfaces (306-1 and 312-1).

[0209] In the example of FIG. 17, including additional DPE interfaces increases bandwidth within and outside each DPE array (110-1 and 110-2). Furthermore, the example of FIG. 17 allows each DPE array (110) to operate isolated from other DPE arrays. This allows, for example, each DPE array to be physically separated from one another, so that one application or user uses DPE array (110-1) while a different application and / or user uses DPE array (110-2).

[0210] The examples provided in connection with FIGS. 13 through 17 illustrate various multi-die IC embodiments comprising one or more DPE arrays. It should be understood that in one or more of the examples described in this disclosure, a die comprising a DPE array may comprise only circuitry for the DPE array and the DPE interface contained therein, or circuitry corresponding to the DPE array and the DPE interface contained therein. In other words, these dies may be dedicated or special-purpose DPE array dies. In other examples, dies comprising a DPE array and a DPE interface may comprise additional circuitry that operates in a coordinated manner with the DPE array and / or the DPE interface. Furthermore, the number of dies illustrated in the examples of FIGS. 13 through 17 is for illustrative purposes only. Additional DPE array dies and / or other dies may be included, each of which can communicate with one or more other dies through suitable interfaces as described in this disclosure.

[0211] For the purpose of explanation, specific nomenclature is mentioned to provide a thorough understanding of the various inventive concepts disclosed herein. However, the technical terms used in this disclosure are intended only to describe specific aspects of the arrangements of the invention and are not intended to be limiting.

[0212] As defined in this disclosure, singular forms are intended to include plural forms unless the context clearly indicates otherwise.

[0213] As defined in the present disclosure, the terms “at least one,” “one or more,” and “and / or” are open expressions that are both conjunctive and disjunctive in operation unless explicitly stated otherwise. For example, the expressions “at least one of A, B, and C,” “at least one of A, B, or C,” “one or more of A, B, and C,” “one or more of A, B, or C,” and “A, B, and / or C” each mean A alone, B alone, C alone, A and B together, A and C together, B and C together, or A, B, and C together.

[0214] As defined in this disclosure, the term “automatically” means the absence of human intervention. As defined in this disclosure, the term “user” means a human.

[0215] As defined in the present disclosure, the term “if” means, depending on the context, “when,” “upon,” “in response to,” or “responsive to.” Accordingly, phrases such as “if it is determined” or “if [a stated condition or event] is detected” may be interpreted, depending on the context, to mean “upon determining,” “in response to determining,” “upon detecting [the stated condition or event],” “in response to detecting [the stated condition or event],” or “responsive to detecting [the stated condition or event].”

[0216] As defined in this disclosure, the term “responding to” and similar linguistic expressions as described above, such as “(if) if,” “when,” or “at the time,” mean to readily respond to or react to an action or event. The response or reaction is performed automatically. Thus, when a second action is performed “in response to” a first action, there is a causal relationship between the occurrence of the first action and the occurrence of the second action. The term “responding to” indicates a causal relationship.

[0217] As defined in this disclosure, the term “processor” means at least one circuit capable of executing instructions included in program code. The circuit may be an integrated circuit or may be embedded in an insertable integrated circuit.

[0218] As defined in this disclosure, the term “substantially” means that while the mentioned characteristic, parameter, or value does not necessarily have to be achieved exactly, deviations or variations, including, for example, tolerances, measurement errors, measurement accuracy limits, and other factors known to a person skilled in the art, may occur in amounts that do not exclude the effect intended to be provided by the characteristic.

[0219] Terms such as first, second, etc. may be used in this disclosure to describe various elements. These elements should not be limited by these terms, because, unless otherwise stated or the context clearly indicates otherwise, these terms are used only to distinguish one element from another.

[0220] All means or steps plus corresponding structures, materials, acts, and equivalents of functional elements that may be found in the claims below are intended to include any structure, material, or act for performing a function in combination with other claimed elements as specifically claimed.

[0221] In one or more exemplary embodiments, the multi-die IC includes an interposer and a first die coupled to the interposer. The first die includes a DPE array, and the DPE array includes a plurality of DPEs and a DPE interface coupled to the plurality of DPEs. The DPE interface has a logical interface and a physical interface. The multi-die IC may also include a second die coupled to the interposer and having a die interface. The DPE interface and the die interface are configured to communicate through the interposer.

[0222] The foregoing and other embodiments optionally include one or more of the following features, each alone or in combination. Some exemplary embodiments include all of the following features in combination.

[0223] In another embodiment, the logical interface of the DPE interface includes a plurality of tiles, each tile being configured to communicate with a subset of a plurality of DPEs in the DPE array.

[0224] In another embodiment, the physical interface includes a plurality of circuit blocks coupled to a plurality of tiles of the logical interface.

[0225] In another embodiment, a plurality of circuit blocks of a physical interface include at least one first circuit block implementing one or more parallel multi-bit channels and a second circuit block implementing a transceiver configured for serial operation.

[0226] In another embodiment, at least one of the plurality of circuit blocks of the physical interface implements a parallel multi-bit channel.

[0227] In another embodiment, each of the circuit blocks of the physical interface is configured to operate independently.

[0228] In another embodiment, at least one of the plurality of circuit blocks of the physical interface implements a high-bandwidth memory interface.

[0229] In another embodiment, at least one of the plurality of circuit blocks of the physical interface includes a transceiver configured for serial operation.

[0230] In another embodiment, at least one of the circuit blocks of the physical interface includes a serializer / deserializer circuit coupled to a transceiver. The serializer / deserializer circuit is configured to generate first serialized data from a first data stream received from a selected tile of the logical interface and to provide the first serialized data to the transceiver. The serializer / deserializer circuit is also configured to generate a second data stream from second serialized data received from the transceiver and to provide the second data stream to a selected tile of the logical interface.

[0231] In another embodiment, the multi-die IC includes a package substrate coupled to an interposer.

[0232] In another embodiment, the first die and the second die are in different clock domains.

[0233] In one or more other exemplary embodiments, a multi-die IC comprises a package substrate, a first die coupled to the package substrate—the first die is configured as an interconnect bridge—and a second die coupled to the package substrate and the first die. The second die comprises a DPE array, the DPE array comprises a plurality of DPEs and a DPE interface coupled to the plurality of DPEs. The DPE interface has a logical interface and a physical interface. The multi-die IC may also comprise a third die coupled to the package substrate and the first die, and the third die comprises a die interface. The DPE interface and the die interface are configured to communicate through the first die.

[0234] The foregoing and other embodiments optionally include one or more of the following features, each alone or in combination. Some exemplary embodiments include all of the following features in combination.

[0235] In another embodiment, the logical interface of the DPE interface includes a plurality of tiles, each tile being configured to communicate with a subset of a plurality of DPEs in the DPE array.

[0236] In another embodiment, the physical interface includes a plurality of circuit blocks coupled to a plurality of tiles of the logical interface.

[0237] In another embodiment, at least one of the plurality of circuit blocks of the physical interface implements a parallel multi-bit channel.

[0238] In another embodiment, each of the circuit blocks of the physical interface is configured to operate independently.

[0239] In another embodiment, at least one of the plurality of circuit blocks of the physical interface implements a high-bandwidth memory interface.

[0240] In another embodiment, at least one of the plurality of circuit blocks of the physical interface includes a transceiver configured for serial operation.

[0241] In another embodiment, at least one of the circuit blocks of the physical interface includes a serialization / deserialization circuit coupled to a transceiver. The serialization / deserialization circuit is configured to generate first serialized data from a first data stream received from a selected tile of the logical interface and to provide the first serialized data to the transceiver. The serialization / deserialization circuit may also be configured to generate a second data stream from second serialized data received from the transceiver and to provide the second data stream to a selected tile of the logical interface.

[0242] In another embodiment, the first die and the third die are in different clock domains.

[0243] The description of the arrangements of the invention provided in this disclosure is for illustrative purposes only and is not intended to encompass or limit the disclosed forms and examples. Technical terms used in this disclosure have been chosen to describe the principles of the arrangements of the invention, actual applications or technical improvements to technologies found in the market, and / or to enable those skilled in the art to understand the arrangements of the invention disclosed in this disclosure. Modifications and variations may be apparent to those skilled in the art without departing from the scope and spirit of the arrangements of the invention described. Accordingly, the following claims, rather than the foregoing disclosure, should be referenced as defining the scope of such features and embodiments.

Claims

Claim 1 A multi-die integrated circuit comprising: one or more first dies including a plurality of data processing engine (DPE) arrays; and one or more second dies coupled to the one or more first dies, wherein the plurality of DPE arrays are: A first DPE array having a first plurality of DPEs and a first DPE interface coupled to the first plurality of DPEs; and A second array of DPEs having a second plurality of DPEs and a second DPE interface coupled to the second plurality of DPEs, wherein the one or more second dies: A first die interface coupled to the first DPE interface of the first DPE array and configured to communicate with the first DPE interface; and A multi-die integrated circuit comprising a second die interface coupled to the second DPE interface of the second DPE array and configured to communicate with the second DPE interface. Claim 2 A multi-die integrated circuit according to claim 1, wherein one or more first dies are coupled to one or more second dies through an interposer. Claim 3 A multi-die integrated circuit according to claim 1, wherein the one or more first dies are coupled to the one or more second dies through one or more interconnect bridge dies. Claim 4 In paragraph 1, the first DPE interface is: A first logical interface having a plurality of tiles — each tile comprises a stream switch configured to communicate with a subset of the first plurality of DPEs and stream switches of adjacent tiles of the first DPE interface —; and A multi-die integrated circuit comprising: a first physical interface having a plurality of circuit blocks coupled to the plurality of tiles of the first logical interface—each circuit block of the plurality of circuit blocks of the first physical interface is coupled to the first die interface disposed on the one or more second dies. Claim 5 In paragraph 4, the second DPE interface is: A second logical interface having a plurality of tiles — each tile comprising a stream switch configured to communicate with a subset of the second plurality of DPEs and stream switches of adjacent tiles of the second DPE interface —; and A multi-die integrated circuit comprising: a second physical interface having a plurality of circuit blocks coupled to the plurality of tiles of the second logical interface—each circuit block of the plurality of circuit blocks of the second physical interface is coupled to the second die interface disposed on the one or more second dies. Claim 6 In claim 4 or 5, the one or more first dies comprise a single first die; and the first DPE array and the second DPE array are disposed on the single first die, a multi-die integrated circuit. Claim 7 In claim 6, the first DPE array and the second DPE array are isolated from each other, a multi-die integrated circuit. Claim 8 In claim 6, a subset of DPEs among the first plurality of DPEs is coupled to a subset of DPEs among the second plurality of DPEs; and the first DPE interface is isolated from the second DPE interface, a multi-die integrated circuit. Claim 9 In claim 4 or 5, the one or more first dies comprise a plurality of first dies; and the first DPE array and the second DPE array are disposed on different dies among the plurality of first dies, a multi-die integrated circuit. Claim 10 A multi-die integrated circuit according to claim 4 or 5, wherein the one or more second dies comprise a single second die, and the first die interface and the second die interface are disposed on the single second die. Claim 11 A multi-die integrated circuit according to claim 4 or 5, wherein the one or more second dies comprise a plurality of second dies, and the first die interface and the second die interface are disposed on different dies among the plurality of second dies. Claim 12 In paragraph 4, at least one of the plurality of circuit blocks of the first physical interface is a multi-die integrated circuit implementing a parallel multi-bit channel. Claim 13 In paragraph 4, at least one of the plurality of circuit blocks of the first physical interface is a multi-die integrated circuit that implements a high bandwidth memory interface. Claim 14 In paragraph 4, at least one of the plurality of circuit blocks of the first physical interface implements a multi-die integrated circuit configured for serial operation. Claim 15 In claim 4, the plurality of circuit blocks of the first physical interface comprises at least one first circuit block implementing one or more parallel multi-bit channels and a second circuit block implementing a transceiver configured for serial operation, a multi-die integrated circuit.