Abstract:
Methods and apparatus are disclosed for efficient TLB (translation look-aside buffer) shoot-downs for heterogeneous devices sharing virtual memory in a multi-core system. Embodiments of an apparatus for efficient TLB shoot-downs may include a TLB to store virtual address translation entries, and a memory management unit, coupled with the TLB, to maintain PASID (process address space identifier) state entries corresponding to the virtual address translation entries. The PASID state entries may include an active reference state and a lazy-invalidation state. The memory management unit may perform atomic modification of PASID state entries responsive to receiving PASID state update requests from devices in the multi-core system and read the lazy-invalidation state of the PASID state entries. The memory management unit may send PASID state update responses to the devices to synchronize TLB entries prior to activation responsive to the respective lazy-invalidation state.
Abstract:
A method and system to facilitate a user level application executing in a first processing unit to enqueue work or task(s) safely for a second processing unit without performing any ring transition. For example, in one embodiment of the invention, the first processing unit executes one or more user level applications, where each user level application has a task to be offloaded to a second processing unit. The first processing unit signals the second processing unit to handle the task from each user level application without performing any ring transition in one embodiment of the invention.
Abstract:
A technique to enable information sharing among agents within different cache coherency domains. In one embodiment, a graphics device may use one or more caches used by one or more processing cores to store or read information, which may be accessed by one or more processing cores in a manner that does not affect programming and coherency rules pertaining to the graphics device.
Abstract:
In on embodiment, a hybrid fabric interconnects multiple graphics processor cores within a processor. The hybrid fabric interconnect includes multiple data channels, including programmable virtual data channels. The virtual data channels carry multiple traffic classes of packet-based messages. The virtual data channels and multiple traffic classes may be assigned one of multiple priorities. The virtual data channels may be arbitrated independently. The hybrid fabric is scalable and can support multiple topologies, including multiple stacked integrated circuit topologies.
Abstract:
In an embodiment, a system includes a graphics processing unit (GPU) that includes one or more GPU engines, and a microcontroller. The microcontroller is to assign a respective schedule slot for each of a plurality of virtual machines (VMs). When a particular VM is scheduled to access a first GPU engine, the particular VM has exclusive access to the first GPU engine. Other embodiments are described and claimed.
Abstract:
In accordance with some embodiments, a scatter/gather memory approach may be enabled that is exposed or backed by system memory and uses conventional tags and addresses. Thus, such a technique may be more amenable to conventional software developers and their conventional techniques.
Abstract:
Transitions to ring 0, each time an application wants to use an adjunct processor, are avoided, saving central processor operating cycles and improving efficiency. Instead, initially each application is registered and setup to use adjunct processor resources in ring 3.
Abstract:
System zum Implementieren einer Graphik-Cache-Hierarchie, wobei das System Folgendes umfasst:eine Anzeige zum Darstellen von visuellem Inhalt;einen System-Cache (12), der mit einem oder mit mehreren Host-Prozessoren (14) und mit einem Systemspeicher (18) gekoppelt ist;eine Graphikschnittstelle (22), die mit dem System-Cache (12) gekoppelt ist; undeinen Graphikprozessor (20), der mit der Graphikschnittstelle (22) gekoppelt ist, wobei der Graphikprozessor (20) Folgendes enthält:einen physikalisch verteilten Satz von Rechen-Slices (24), um mehrere Arbeitseinheiten auszuführen, die dem visuellen Inhalt zugeordnet sind, wobei jeder Rechen-Slice (24) mehrere Ausführungsblöcke (28) mit jeweils mehreren Ausführungseinheiten (34) aufweist, undeine Cache-Fabric, um eine Kohärenz einer oder mehrerer Speicherzeilen, die den mehreren Arbeitseinheiten zugeordnet sind, über den Graphikprozessor (20), den Systemspeicher (18) und den einen oder die mehreren Host-Prozessoren (14) aufrechtzuerhalten, wobei die Cache-Fabric Folgendes enthält:mehrere Caches der ersten Ebene, L1-Caches, wobei jeder L1-Cache für einen Ausführungsblock eines Rechen-Slice (24) vorgesehen ist,eine physikalisch verteilte gemeinsam genutzte Cache-Struktur (30), wobei die Kohärenz der einen oder der mehreren Speicherzeilen über die mehreren L1-Caches und die gemeinsam genutzte Cache-Struktur (30) über den physisch verteilten Satz von Rechen-Slices (24) aufrechterhalten werden soll, wobei die gemeinsam genutzte Cache-Struktur (30) einen Level-Zwei-, L2,-Cache mit einer Vielzahl von Bänken aufweist, und wobei die gemeinsam genutzte Cache-Struktur (30) dazu eingerichtet ist, mindestens eine der einen oder mehreren Speicherzeilen über die Vielzahl von Bänken zu hashen, undmehrere Kreuzschienenknoten (32) zum Verfolgen der einen oder der mehreren Speicherzeilen, wobei jeder Kreuzschienenknoten (32) für ein Rechen-Slice (24) vorgesehen ist und jeder Kreuzschienenknoten (32) der Vielzahl von Kreuzschienenknoten (32) mit dem L1-Cache jedes der Vielzahl von Ausführungsblöcken (28) des Rechen-Slice (24) verbunden ist, dem der Kreuzschienenknoten (32) zugeordnet ist, wobei die mehreren Kreuzschienenknoten (32) ferner dazu dienen, eine oder mehrere Snoop-Anforderungen, die von dem System-Cache (12) ausgehen, über die Graphikschnittstelle (22) an die gemeinsam genutzte Cache-Struktur (30) und an die mehreren L1-Caches zu verteilen, eines oder mehrere Snoop-Ergebnisse von der gemeinsam genutzten Cache-Struktur (30) und von den mehreren L1-Caches zu sammeln und das eine oder die mehreren Snoop-Ergebnisse an den System-Cache (12) zu übermitteln.