EP3005107A1 - Accelerateur materiel pour la manipulation d'arbres rouges et noirs - Google Patents

Accelerateur materiel pour la manipulation d'arbres rouges et noirs

Info

Publication number
EP3005107A1
EP3005107A1 EP14725486.6A EP14725486A EP3005107A1 EP 3005107 A1 EP3005107 A1 EP 3005107A1 EP 14725486 A EP14725486 A EP 14725486A EP 3005107 A1 EP3005107 A1 EP 3005107A1
Authority
EP
European Patent Office
Prior art keywords
node
address
data
register
key
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP14725486.6A
Other languages
German (de)
English (en)
Inventor
Alexandre CARBON
Yves LHUILLIER
Henri-Pierre CHARLES
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Commissariat a lEnergie Atomique et aux Energies Alternatives CEA
Original Assignee
Commissariat a lEnergie Atomique et aux Energies Alternatives CEA
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Commissariat a lEnergie Atomique et aux Energies Alternatives CEA filed Critical Commissariat a lEnergie Atomique et aux Energies Alternatives CEA
Publication of EP3005107A1 publication Critical patent/EP3005107A1/fr
Withdrawn legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/22—Indexing; Data structures therefor; Storage structures
    • G06F16/2228—Indexing structures
    • G06F16/2246—Trees, e.g. B+trees
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0842—Multiuser, multiprocessor or multiprocessing cache systems for multiprocessing or multitasking
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0815—Cache consistency protocols
    • G06F12/0831—Cache consistency protocols using a bus scheme, e.g. with bus monitoring or watching means
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/10—Address translation
    • G06F12/1027—Address translation using associative or pseudo-associative address translation means, e.g. translation look-aside buffer [TLB]
    • G06F12/1036—Address translation using associative or pseudo-associative address translation means, e.g. translation look-aside buffer [TLB] for multiple virtual address spaces, e.g. segmentation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2455—Query execution
    • G06F16/24553—Query execution of query operations
    • G06F16/24562—Pointer or reference processing operations
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • G06F9/45516—Runtime code conversion or optimisation

Definitions

  • a hardware accelerator i.e., a dedicated digital circuit cooperating with or integrated with a processor for accelerating certain data processing operations - for manipulating data structures known as "Red and black trees".
  • the invention also relates to a processor incorporating such a hardware accelerator and to a computer system comprising a processor, such a hardware accelerator and a memory.
  • Red and black trees are well-known data structures for storing sorted data according to a reference key. These data structures are binary trees to which is added a coloring property of the nodes in which the manipulated data is contained. This property makes it possible to handle these trees with a complexity lower than that of conventional binary trees, in O (log n), n corresponding to the total number of nodes in the tree, for both insertion operations and deletion. This representation is particularly used in the context of the implementation of associative arrays. Associative arrays, implemented as red and black trees, are a collection of key and value pairs that allow a set of keys to be associated with a corresponding set of values. There are many programming libraries optimized for handling red and black trees, for example as part of the standard GNU C ++ library.
  • the invention aims to accelerate the handling of red and black trees and, as a result, associative arrays implemented by means of such trees.
  • such a goal is achieved through a hardware accelerator, used in conjunction with a slightly modified software representation of red and black trees.
  • An object of the invention is therefore a hardware accelerator for handling red and black trees, each said tree comprising several nodes, each said node comprising data fields of predefined length representing:
  • said hardware accelerator comprising:
  • node registers which can store all the fields of two nodes of a said tree; and logic units configured to receive from a processor at least one input data selected from an address of a node of a said tree and a so-called reference key, and at least one instruction to be executed; to execute said instruction by performing a combination of the following operations:
  • the hardware accelerator may also comprise a register, referred to as a reference register, which can store either a so-called reference key received from said processor, or a said reference key and a color indicator.
  • Said logical units may comprise a processing unit and a control unit, said control unit being configured to: receive a said address of a node of a said tree as input data and transmit it to said memory ; receiving a said reference key as input data and storing it in said reference register; receiving a said instruction to be executed as input data, as well as one or more condition signals from said processing unit; in response to said instruction to be executed and said one or more condition signals, generating control signals from said processing unit; and providing, as output data, a node address received from said processing unit.
  • Said control unit may be a finite state machine.
  • the hardware accelerator may also include a register, called temporary register, which can store an address, called a temporary address, of a node of a said tree.
  • Said processing unit may be configured to execute, in response to a said control signal, at least the following operations:
  • Said processing unit may comprise: a selection and subtraction unit configured to receive at a first input, via a first multiplexer, the contents of said temporary register or said reference register, at a second input, by the intermediate of a second multiplexer, a key or key data field and color indicator from a said node register and a control input, a control signal from said control unit, and for providing at its output, as a function of said control signal, either one of said first and second inputs, or their difference; a reorganization unit configured to receive at a first input, the output of said comparison unit and subtractions, at a second input, a key or key data field and color indicator from a said node register at a third, a fourth and a fifth input, via said second multiplexer, three address data fields from a said node register and a control input, a control signal from said control unit; and to provide: at a first output, a key, key and color indicator or address data field present at one of its inputs, the value of said color indicator being
  • Said processing unit may be configured to generate, in response to an instruction received as input data, a sequence of control signals for execution of a selected one of the following:
  • Said logical units may also include an interface device with said memory configured to: receive from said control unit the address of a location of said memory; and transferring the contents of said memory lease into a said node register, or vice versa.
  • Such an accelerator can comprise exactly three node registers.
  • the color indicator and the key of each said node may be represented by different bits of the same data field, said color indicator being represented by a single bit of said field.
  • each said node may be represented by: a data field of which one bit represents said color indicator and the remaining bits represent said key; and three other data fields representing the addresses of said parent nodes, left child and right child; said data fields all having the same number of bits.
  • Another object of the invention is a processor comprising such a hardware accelerator as a functional unit having access to the first cache level.
  • Yet another object of the invention is a computer system comprising a processor, a memory and such a hardware accelerator interconnected by a system bus, said processor being configured or programmed to communicate with said hardware accelerator through requests from system and to ensure cache coherency.
  • FIGS. 1A and 1B respectively, a data structure used to represent a node of a red and black tree according to the prior art and according to the invention
  • FIG. 1 the architecture of a hardware accelerator according to one embodiment of the invention.
  • FIG. 3 a processor incorporating a hardware accelerator according to one embodiment of the invention
  • a computer system comprising a processor, a hardware accelerator according to another embodiment of the invention and a memory;
  • FIG. 5 a graph illustrating the performance gain obtained thanks to a hardware accelerator according to one embodiment of the invention compared with a purely software and "standard” treatment of red and black trees as well as with respect to software processing. optimized in the LLVM environment.
  • a red and black tree is a binary tree in which each node has a property called "color", which can take two values - conventionally "red” and “black”.
  • color can take two values - conventionally "red” and "black”.
  • each node has a "parent” node (except the root node) and two "child” nodes (except the so-called “leaf” nodes, which terminate the branches of the tree), and more precisely a "left" child and a “right” child.
  • Each node of a red and black tree (but this is also true for a "generic” binary tree) is also characterized by a "key”.
  • the keys of the different nodes are ordered, and the following rule applies: the left child node of each node has a key of value lower than that of the key of its parent, the right child node of each node presents a key of greater value than the key of its parent.
  • a red and black tree must further satisfy the following properties:
  • the root node is black
  • each simple path from a node to any one of its descendants contains the same number of black nodes.
  • a red and black tree is, in the context of a preferred embodiment of the invention as in the context of other software implementations such as that of the standard GNU C ++ library, referenced from a node, said " head node "or simply" header "(" header "in English).
  • This header node has the same structure as the nodes of the tree, but its parent node is the root node of the tree, its left child node is the leftmost leaf node of the tree, the presenting node. the smallest key of all nodes in the tree, its right child node is the rightmost leaf node of the tree, the node with the largest key of all nodes in the tree. Finally, the color field and the key field of the header node are unused.
  • the header node is a point of entry of the tree used to quickly access the node of the red and black tree, during the manipulations of the latter. Another advantage of using a header node is related to the stability of this node during the entire life of the tree, while the root node may have to change during the handling of the tree.
  • a node of a binary tree is represented by a data structure of the type illustrated in FIG. 1 A. This structure comprises:
  • a color field COL for example of "long" type, encoded on 32 bits;
  • a CLE field containing the key of the node, encoded on a variable number of bits.
  • the overall size of the data structure representing a node of a red and black tree is of variable size.
  • each node has a constant and predefined size. Consequently, the key CLE is replaced by a "reduced key" consisting of a predetermined number of bits.
  • the replacement of a key of variable size by a key of fixed size can consequently result in the transition from a total order of the nodes to a partial order in which two nodes having different keys have the same reduced key. It is always possible to ensure that the passage of the key to the reduced key preserves the order of the nodes, at least in the sense of a partial order; thus if the key of the node n is greater than the key of the node m, then the reduced key of the node n is greater than or equal to that of the node m. In the case of equality, a software post-processing can be used to resolve the scheduling ambiguity by returning (outside the hardware accelerator) to a complete representation of the key.
  • the color takes a binary value
  • the 32-bit encoding of the conventional implementation is highly redundant; this is of no serious consequence in the case of purely software processing, but unnecessarily increases the cost and complexity of a hardware accelerator. Therefore, in a data structure optimized for the implementation of the invention the color is coded on a single bit.
  • all the data fields representing a node have the same size, for example 32 bits.
  • a CRCO field containing a reduced key subfield CR (hereinafter referred to simply as a "key"), at 31 bits, and a subfield of color CO, at only 1 bit;
  • the representation of a red and black tree by the data structure of FIG. 1B is not essential, but is preferred.
  • variable X of type "rb_tree_node_t * " (pointer to a node of red and black tree) contains the address of the first field of data of such a node (here, the field CRCO, but this is not essential ).
  • a hardware accelerator according to the invention executes, on behalf of a processor, certain instructions necessary for handling red and black trees, and in particular:
  • the parameter of the function (data supplied as input to the hardware accelerator) is the address of the node whose successor must be found; the output value of the function and the address of said successor node.
  • the parameter of the function is the address of the node whose successor must be found; the output value of the function and the address of said predecessor node.
  • the parameters of the function are the address of an access point to the tree and the address of the node to be deleted; the output value, optional, is the node address of the deleted tree, corresponding to the second parameter of the function.
  • the access point to the tree is usually its head node.
  • the accelerator may also perform other instructions as well. It is also possible to consider other games equivalent instructions, also allowing them to handle red and black trees.
  • the accelerator must have access to a memory shared with the processor, storing the data structures to be manipulated.
  • This memory must be the level 1 cache of the processor, or a memory maintained coherent with said cache by mechanisms known from the prior art.
  • the accelerator receives the instructions and their parameters from the processor, and returns the output value to it.
  • an accelerator comprises at least two (preferably three) registers capable of storing all of the data fields of a node, and logic circuits for executing operations more simple, in which the above instructions can be decomposed. These operations are as follows:
  • the output value, supplied to the processor, is an address field.
  • FIG. 2 schematically illustrates the architecture of such an accelerator, which comprises:
  • a UC control unit modeled by a finite state machine
  • a processing unit UT in turn comprising a SUB / SEL selection and subtraction unit, a RORG reorganization unit, multiplexers MUX1 and MUX2 situated at the inputs of these units, comparators at zero (or, in an equivalent manner, a) CMP1, CMP2, CMP3 and a RDD data distribution network comprising in turn a multiplexer MUX3 and demultiplexers DEMUX1, DEMUX2;
  • nodes RN1, RN2, RN3 three registers of nodes RN1, RN2, RN3 (as mentioned above, two of these registers could be enough, three is the optimal number while a higher number does not bring any particular advantage), to 128 bits in the case of the representation of FIG. 1B, as well as two additional registers capable of storing a single data field (32 bits, in the case of the representation of FIG. 1B): a "temporary" register TEMP for storing a field of address and a REF reference register for storing a key / color field.
  • the control unit can be modeled by a finite state machine. It performs the following operations:
  • an instruction to execute for example one of the instructions A to F described functionally above - as well as its arguments - typically , one or two respective node addresses of a red and black tree stored in a memory MEM, and optionally a reference key value.
  • the address type parameters are communicated to the IM memory interface which retrieves the corresponding data and writes them to one or more node registers via the data distribution network.
  • a possible reference key type parameter is stored in the said register of reference REF.
  • the instruction determines the control sequence executed by the control unit.
  • an internal state and received condition signals send control signals to the various components of the processing unit (such as for the condition signals, the paths of these signals are not represented in full).
  • the first multiplexer MUX1 selects, as a function of a control signal, either the contents A T EMP of the temporary register TEMP, or that (CREF) of the reference register REF.
  • the selected data (32 bits) is transmitted to a first input of the SUB / SEL selection and subtraction unit.
  • the second multiplexer MUX2 selects, according to a control signal, the contents of one of the node registers RN1, RN2, RN3.
  • the different fields of the data (128) bits thus selected are treated differently:
  • the CRCO field (reduced key and color) is supplied to a second input of the SUB / SEL selection and subtraction unit and also supplied as input to the reorganization unit;
  • the SUB / SEL selection and subtraction unit can, depending on a control signal, compare its inputs (subtraction) or select one of them. Its output is input to the RORG reorganization unit.
  • the RORG reorganization unit has three outputs (which are not necessarily active at the same time):
  • a first 32-bit output on which is found one of the data fields present at its inputs; if this field is a key and color field, the indicative bit of the color can be changed; the selection of the input at the first output and the eventual change of the color bit depend on a control signal;
  • a second 32-bit output on which is found one of the address fields present at its inputs and coming from a node register via the second multiplexer; the selection of the address field at the first output depends on a control signal;
  • a third 128-bit output on which a reconstituted node structure is found by selecting and swapping four of the data fields present at the inputs of the unit; the selection and the permutation performed depends on a control signal.
  • said third output comprises a key and color field from the first or second input, with possible modification of the color indicator bit, and three address fields from the third, fourth and fifth inputs (of which order can be changed).
  • the first DEMUX1 demultiplexer makes it possible to supply the data at the first output of the reorganization unit to the input of the temporary register or of the reference register; the data at the second output of the reorganization unit (necessarily an address) is supplied to the memory interface IM;
  • the data at the third output of the reorganization unit is also supplied to the memory interface IM to be stored in the memory MEM at the address specified by the data at the second output; it is also input to the third multiplexer MUX3.
  • This third multiplexer MUX3 also receives, at another input, a node data structure (128 bits) coming from the memory MEM - the contents of the memory cell whose address has been provided either by the control unit or by the second aforementioned output of the reorganization unit.
  • the multiplexer selects one of its inputs, and sends it to the second multiplexer DEMUX2, which transfers it to one of the registers of nodes RN1, RN2, RN3.
  • the data at the first address of the reorganization unit (an address) can be supplied to the control unit, which in turn transmits it to the processor PROC as output data;
  • a reference key received as an instruction parameter may be transmitted from the control unit to the reference register REF for recording there.
  • the processing unit UT can therefore perform, under the control of the control unit UC, the following "elementary" operations:
  • the first step includes the selection of the reorganization unit inputs and the selection and subtraction unit by the multiplexers MUX1 and MUX2, as well as the loading of new data into the registers, the second stage corresponds to the processing carried out by the reorganization unit and the unit of selection and subtraction.
  • the architecture of Figure 2 is optimized to reduce the cost, complexity and consumption of the accelerator by reusing the same components to perform multiple operations where possible.
  • One consequence of this optimization is that useless operations are possible in principle (for example: a comparison between a key / color data and an address in the SUB / SEL unit). This does not matter because control sequences of the control unit make the execution of these operations impossible.
  • a hardware accelerator according to one embodiment can be integrated into the "pipeline" of a processor so as to constitute a functional unit of the latter.
  • the hardware accelerator has direct access to the level 1 cache and its use involves processor-specific instructions.
  • Figure 3 schematically illustrates the structure and operation of such a processor.
  • the pipeline includes a "FETCH” unit responsible for loading an instruction from the memory, a "DECODE” unit for decoding the instruction and storing the decoded instruction in a queue Q, an ISSUE unit that selects an instruction ready (of which all the inputs are available) from the instructions of the queue Q and transmits this instruction to a functional unit chosen from: an INT unit (in charge of the so-called integer operations), a MULT unit (in charge of the multiplication operations) , an L / S unit ("Load / Store”: in charge of read / write from / to memory) and hardware accelerator RBT, the latter two units having direct access to the level 1 cache memory, MC. Each unit transmits the result of the processing it performs to the unit WB.
  • a functional unit chosen from: an INT unit (in charge of the so-called integer operations), a MULT unit (in charge of the multiplication operations) , an L / S unit (“Load / Store”: in charge of read / write
  • the WB (write-back) unit is then in charge of updating the registers of the processor.
  • This embodiment is preferred because it allows to fully benefit from the acceleration of the handling of red and black trees.
  • it is difficult to implement because it requires a modification of the processor and its instruction set.
  • FIG. 4 very schematically illustrates another embodiment, in which the hardware accelerator is implemented in the form of a coprocessor CPR, communicating with a processor PROC and a memory MEM via a BUS system bus.
  • the processor processes the accelerator as a device, and communicates with it by means of system functions. Since the accelerator does not have direct access to the level 1 cache of the processor, these system functions implement cache coherence protocols, known per se (alternatively, other cache coherence mechanisms known to those skilled in the art, other than coherence protocols, may be used).
  • This embodiment is much simpler to implement, but the processor / accelerator communication is slower, which reduces the advantage of accelerating the handling functions of red and black trees.
  • a user gains access to hardware accelerator functionality through convenient function libraries, replacing standard libraries.
  • FIG. 5 illustrates, in the form of a histogram, the relationship between the time spent in the manipulation of associative arrays (implemented by red and black trees) with respect to the total compile time for a plurality of source codes indicated on the abscissa.
  • the total compile time of source code compilation refers to the runtime of the LLC compiler, from the LLVM environment, passed to the compilation of a given source code.
  • the various input source codes of the LLC compiler come from a well-known source code package called "MiBench”. For each compilation of source code by the LLC compiler, this report was measured for the software implementation of the standard C ++ library (bars in light gray), for an optimized software implementation (bars in intermediate gray) and for an implementation using the hardware accelerator according to the invention, in its implementation integrated with the processor (bars in dark gray).

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • Data Mining & Analysis (AREA)
  • Databases & Information Systems (AREA)
  • Computational Linguistics (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
  • Image Generation (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

Accélérateur matériel pour la manipulation d'arbres rouges et noirs, chaque nœud d'un dit arbre comprenant un indicateur binaire de couleur, une clé et les adresses d'un nœud parent et de deux nœuds fils, ledit accélérateur comprenant - au moins deux registres dits registres de nœud (RN1, RN2), pouvant stocker l'ensemble des champs de données de deux nœuds d'un dit arbre; et des unités logiques (UC, UT) configurées pour recevoir d'un processeur (PROC) au moins une donnée d'entrée choisie parmi une adresse d'un nœud d'un dit arbre et une clé dite de référence, ainsi qu'au moins une instruction à exécuter; pour exécuter ladite instruction en combinant des instructions élémentaires sur les données stockées dans lesdits registres de nœuds et pour fournir audit processeur au moins une donnée de sortie comprenant une adresse d'un dit nœud. Processeur et système informatique comprenant un tel accélérateur matériel.

Description

ACCELERATEUR MATERIEL POUR LA MANIPULATION D'ARBRES
ROUGES ET NOIRS
L'invention porte sur un accélérateur matériel - c'est-à-dire un circuit numérique dédié coopérant avec un processeur ou intégré à ce dernier pour accélérer certaines opérations de traitement de données - pour la manipulation de structures de données connues sous le nom de « arbres rouges et noirs ». L'invention porte également sur un processeur intégrant un tel accélérateur matériel et sur un système informatique comprenant un processeur, un tel accélérateur matériel et une mémoire.
Les arbres rouges et noirs, ou arbres colorés, sont des structures de données bien connues, permettant de stocker des données triés en fonction d'une clé de référence. Ces structures de données sont des arbres binaires auxquels est rajoutée une propriété de coloration des nœuds dans lesquels sont contenues les données manipulées. Cette propriété permet d'assurer une manipulation de ces arbres avec une complexité inférieure à celle des arbres binaires classiques, en O(log n), n correspondant au nombre total de nœuds dans l'arbre, aussi bien pour les opérations d'insertion que de suppression. Cette représentation est notamment fortement utilisée dans le cadre de l'implémentation des tableaux associatifs. Les tableaux associatifs, implémentées sous la forme d'arbres rouges et noirs constituent une collection de couples de clefs et de valeurs permettant l'association d'un ensemble de clés à un ensemble correspondant de valeurs. Il existe de nombreuses librairies de programmation optimisées pour la manipulation d'arbres rouges et noirs, par exemple dans le cadre de la libraire standard GNU C++.
Néanmoins, il a été démontré que l'implémentation optimale des tableaux associatifs, au moins pour la réalisation d'allocateurs de mémoire, ne repose pas sur l'utilisation d'arbres rouges et noirs, mais de tables de hachage. Voir à ce propos Emery D. Berger, Benjamin G. Zorn et Kathryn S. McKinley. « Reconsidering custom memory allocation »,
Proceedings of the 17th ACM SIGPLAN conférence on Object-oriented programming, Systems, languages, and applications (OOPSLA Ό2). ACM, New York, NY, USA, 1 -12, 2012.
L'article de Amir Roth, Andréas Moshovos et Gurindar S. Sohi « Dependence based prefetching for linked data structures » SI GO PS Oper. Syst. Rev. 32, 5 (Octobre 1998), 1 15-126, décrit une unité de pré-chargement des structures de données chaînées avec pointeurs. Une telle unité permet d'accélérer le parcours des chaînes de pointeurs, et donc le traitement des arbres rouges et noirs qui, comme bien d'autres structures de données, utilisent de telles chaînes. Une telle unité n'est cependant pas spécifique à la manipulation des arbres rouges et noirs, et ne permet d'obtenir qu'un gain de temps d'exécution limité.
L'invention vise à accélérer la manipulation des arbres rouges et noirs et, de ce fait, des tableaux associatifs implémentés au moyen de tels arbres.
Conformément à l'invention, un tel but est atteint grâce à un accélérateur matériel, utilisé conjointement à une représentation logicielle légèrement modifiée des arbres rouges et noirs.
Un objet de l'invention est donc un accélérateur matériel pour la manipulation d'arbres rouges et noirs, chaque dit arbre comprenant plusieurs nœuds, chaque dit nœud comprenant des champs de données de longueur prédéfinie représentant :
un indicateur de couleur, prenant une valeur binaire ;
une clé ;
une adresse d'un autre nœud du même arbre, dit parent ; - une adresse d'un autre nœud du même arbre, dit enfant de gauche ; et
une adresse d'un autre nœud du même arbre, dit enfant de droite ;
ledit accélérateur matériel comprenant :
- au moins deux registres dits registres de nœud, pouvant stocker l'ensemble des champs de deux nœuds d'un dit arbre ; et des unités logiques configurées pour recevoir d'un processeur au moins une donnée d'entrée choisie parmi une adresse d'un nœud d'un dit arbre et une clé dite de référence, ainsi qu'au moins une instruction à exécuter ; pour exécuter ladite instruction en effectuant une combinaison des opérations suivantes :
• envoyer vers ladite mémoire une adresse, recevoir de ladite mémoire l'ensemble des champs de données du nœud dudit arbre correspondant à ladite adresse et les écrire dans un dit registre en remplacement des champs de données ;
· envoyer vers la mémoire l'ensemble des champs de données d'un nœud dudit arbre ainsi qu'une adresse de ladite mémoire à laquelle lesdits champs de données doivent être enregistrés ;
• changer la valeur d'un indicateur de couleur stocké dans un dit registre de nœud ; et
· échanger entre elles deux adresses stockées dans deux dits registres de nœud ;
et pour fournir audit processeur au moins une donnée de sortie comprenant une adresse stockée dans un dit registre de nœud.
Selon différentes caractéristiques avantageuses de l'invention, prises séparément ou en combinaison :
L'accélérateur matériel peut comprendre également un registre, dit registre de référence, pouvant stocker soit une clé, dite de référence, reçue dudit processeur, soit une dite clé de référence et un indicateur de couleur.
- Lesdites unités logiques peuvent comprendre une unité de traitement et une unité de contrôle, ladite unité de contrôle étant configurée pour : recevoir une dite adresse d'un nœud d'un dit arbre en tant que donnée d'entrée et la transmettre à ladite mémoire ; recevoir une dite clé de référence en tant que donnée d'entrée et la stocker dans ledit registre de référence ; recevoir une dite instruction à exécuter en tant que donnée d'entrée, ainsi qu'un ou plusieurs signaux de condition en provenance de ladite unité de traitement ; en réponse à ladite instruction à exécuter et à ladite ou à des dits signaux de condition, générer des signaux de contrôle de ladite unité de traitement ; et fournir, en tant que donnée de sortie, une adresse de nœud reçue de ladite unité de traitement.
Ladite unité de contrôle peut être un automate à état finis.
L'accélérateur matériel peut comprendre également un registre, dit registre temporaire, pouvant stocker une adresse, dite adresse temporaire, d'un nœud d'un dit arbre.
Ladite unité de traitement peut être configurée pour exécuter, en réponse à un dit signal de contrôle, au moins les opérations suivantes :
a. comparer la clé de référence stockée dans ledit registre de référence avec une clé stockée dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
b. comparer à une valeur prédéterminée une adresse stockée dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
c. comparer à une valeur prédéterminée un indicateur de couleur stocké dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
d. changer la valeur d'un indicateur de couleur stocké dans un champ de données d'un dit registre de nœud ;
e. envoyer à ladite mémoire, pour écriture, l'ensemble des champs de données d'un dit registre de nœud ;
f. recevoir de ladite mémoire l'ensemble des champs de données d'un nœud d'un dit arbre et les stocker dans un dit registre de nœud ;
g. écrire ladite adresse temporaire, stockée dans ledit registre temporaire, dans un champ de données d'un dit registre de nœud, en remplacement d'une adresse stockée dans ledit champ ; et h. écrire une adresse stockée un champ de données d'un dit registre de nœud dans ledit registre temporaire, en remplacement de ladite adresse temporaire.
Ladite unité de traitement peut comprendre : une unité de sélection et soustraction configurée pour recevoir à une première entrée, par l'intermédiaire d'un premier multiplexeur, le contenu dudit registre temporaire ou dudit registre de référence, à une deuxième entrée, par l'intermédiaire d'un deuxième multiplexeur, un champ de données de clé ou de clé et d'indicateur de couleur issu d'un dit registre de nœud et à une entrée de contrôle, un signal de contrôle en provenance de ladite unité de contrôle, et pour fournie à sa sortie, en fonction dudit signal de contrôle, soit l'une desdites première et deuxième entrée, soit leur différence ; une unité de réorganisation configurée pour recevoir à une première entrée, la sortie de ladite unité de comparaison et soustractions, à une deuxième entrée, un champ de données de clé ou de clé et d'indicateur de couleur issu d'un dit registre de nœud, à une troisième, une quatrième et une cinquième entrée, par l'intermédiaire dudit deuxième multiplexeur, trois champs de données d'adresse issus d'un dit registre de nœud et à une entrée de contrôle, un signal de contrôle en provenance de ladite unité de contrôle ; et pour fournir : à une première sortie, un champ de données de clé, de clé et d'indicateur de couleur ou d'adresse présent à l'une de ses entrées, la valeur dudit indicateur de couleur pouvant être modifiée, à une deuxième sortie, un champ de données d'adresse présent à sa deuxième, sa troisième ou sa quatrième adresse ; et/ou à une troisième sortie, l'ensemble des champs de données représentatifs d'un nœud dudit arbre, obtenus par sélection et permutation des champs de données présents à ses entrées, avec modification éventuelle d'un indicateur de couleur ; un ensemble de comparateurs à zéro des champs de données fournis à la troisième, quatrième et cinquième entrée de ladite unité de réorganisation et d'un indicateur de couleur stocké dans ledit registre de référence, les sorties desdits comparateurs étant fournies à ladite unité de contrôle en tant que données de condition ; et un réseau de distribution des données configuré pour : fournir un champ de données issu de la première sortie de l'unité de réorganisation soit audit registre temporaire, soit audit registre de référence, en fonction d'un signal de contrôle en provenance de ladite unité de contrôle, ainsi qu'à ladite unité de contrôle, fournir un champ de données issu de la deuxième sortie de l'unité de réorganisation à ladite mémoire ; fournir des champs de données issus de la troisième sortie de l'unité de réorganisation à ladite mémoire ; fournir des champs de données issus de la troisième sortie de l'unité de réorganisation ou de ladite mémoire à l'un desdits registres de nœud, en fonction d'un signal de contrôle en provenance de ladite unité de contrôle.
- Ladite unité de traitement peut être configurée pour générer, en réponse à une instruction reçue en tant que donnée d'entrée, une séquence de signaux de contrôle permettant l'exécution d'une opération choisie parmi les suivantes :
A. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire, le nœud dit successeur présentant une clé de valeur immédiatement supérieure à celle d'un nœud dont l'adresse est fournie en tant que donnée d'entrée, et fournir, en tant que donnée de sortie, l'adresse dudit nœud successeur ;
B. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire, le nœud dit prédécesseur présentant une clé de valeur immédiatement inférieure à celle d'un nœud dont l'adresse est fournie en tant que donnée d'entrée, et fournir, en tant que donnée de sortie, l'adresse dudit nœud successeur ;
C. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le nœud dont l'adresse est fournie en tant que deuxième donnée d'entrée, le supprimer et modifier la structure de l'arbre rouge et noire en conséquence ;
D. Insérer, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, un nœud dont l'adresse est fournie en tant que deuxième donnée d'entrée et modifier la structure de l'arbre rouge et noire en conséquence ;
E. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud ; et
F. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est strictement supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud.
Lesdites unités logiques peuvent comprendre également un dispositif d'interface avec ladite mémoire configuré pour : recevoir de ladite unité de contrôle l'adresse d'une location de ladite mémoire ; et transférer le contenu de ladite location de mémoire dans un dit registre de nœud, ou inversement.
Un tel accélérateur peut comprendre exactement trois registres de nœud.
L'indicateur de couleur et la clé de chaque dit nœud peuvent être représentés par des bits différents d'un même champ de données, ledit indicateur de couleur étant représenté par un seul bit dudit champ.
- Plus particulièrement, chaque dit nœud peut être représenté par : un champ de données dont un bit représente ledit indicateur de couleur et les bits restants représentent ladite clé ; et trois autres champs de données représentant les adresses desdits nœuds parent, enfant de gauche et enfant de droite ; lesdits champs de données présentant tous un même nombre de bits. Un autre objet de l'invention est un processeur comprenant un tel accélérateur matériel en tant qu'unité fonctionnelle ayant accès au premier niveau de mémoire cache.
Encore un autre objet de l'invention est un système informatique comprenant un processeur, une mémoire et un tel accélérateur matériel reliés entre eux par un bus système, ledit processeur étant configuré ou programmé pour communiquer avec ledit accélérateur matériel par l'intermédiaire de requêtes de système et pour assurer une cohérence de cache.
D'autres caractéristiques, détails et avantages de l'invention ressortiront à la lecture de la description faite en référence aux dessins annexés donnés à titre d'exemple et qui représentent, respectivement :
les figures 1 A et 1 B, respectivement, une structure de données utilisée pour représenter un nœud d'un arbre rouge et noir selon l'art antérieur et selon l'invention ;
la figure 2, l'architecture d'un accélérateur matériel selon un mode de réalisation de l'invention ;
la figure 3, un processeur intégrant un accélérateur matériel selon un mode de réalisation de l'invention ;
- la figure 4, un système informatique comprenant un processeur, un accélérateur matériel selon un autre mode de réalisation de l'invention et une mémoire ; et
la figure 5, un graphique illustrant le gain de performance obtenu grâce à un accélérateur matériel selon un mode de réalisation de l'invention par rapport à un traitement purement logiciel et « standard » des arbres rouges et noirs ainsi que par rapport à un traitement logiciel optimisé réalisé dans l'environnement LLVM.
Un arbre rouge et noir est un arbre binaire dans lequel chaque nœud a une propriété dite « couleur », qui peut prendre deux valeurs - conventionnellement « rouge » et « noir ». Comme dans tout arbre binaire, chaque nœud a un nœud « parent » (sauf le nœud racine) et deux nœuds « enfants » (sauf les nœuds dits « feuilles », qui terminent les branches de l'arbre), et plus précisément un enfant « de gauche » et un enfant « de droite ». Chaque nœud d'un arbre rouge et noir (mais cela est vrai aussi pour un arbre binaire « générique ») est également caractérisé par une « clé ». Les clés des différents nœuds sont ordonnées, et la règle suivante s'applique : le nœud enfant de gauche de chaque nœud présente une clé de valeur inférieure à celle de la clé de son parent, le nœud enfant de droite de chaque nœud présente une clé de valeur supérieure à celle de la clé de son parent. Un arbre rouge et noir doit en outre satisfaire les propriétés suivantes :
le nœud racine est noir ;
- les nœuds feuilles sont noirs ;
les enfants de chaque nœud rouge sont noirs ;
chaque chemin simple allant d'un nœud à l'un quelconque de ses descendants contient un même nombre de nœuds noirs.
Ces propriétés assurent que l'arbre est au moins approximativement équilibré, ce qui n'est pas le cas d'un arbre binaire générique.
Un arbre rouge et noir est, dans le cadre d'un mode de réalisation préféré de l'invention comme dans le cadre d'autres implémentations logicielles telles que celle de la librairie standard GNU C++, référencé à partir d'un nœud, dit « nœud entête » ou plus simplement « entête » (« header » en anglais). Ce nœud entête possède la même structure que les nœuds de l'arbre, mais son nœud parent est le nœud racine de l'arbre, son nœud enfant de gauche est le nœud feuille le plus à gauche de l'arbre, soit le nœud présentant la plus petite clé de tous les nœuds de l'arbre, son nœud enfant de droite est le nœud feuille le plus à droite de l'arbre, soit le nœud présentant la plus grande clé de tous les nœuds de l'arbre. Enfin, le champ de couleur et celui de clé du nœud entête sont inutilisés. Le nœud entête est un point d'entrée de l'arbre utilisé pour accéder rapidement au nœud de l'arbre rouge et noir, lors des manipulations de ce dernier. Un autre avantage de l'utilisation d'un nœud entête est lié à la stabilité de ce nœud durant toute la durée de vie de l'arbre, alors que le nœud racine peut être amené à changer au cours des manipulations de l'arbre. Conventionnellement, un nœud d'un arbre binaire est représenté par une structure de données du type illustré sur la figure 1 A. Cette structure comprend :
un champ de couleur COL, par exemple de type « long », encodé sur 32 bits ;
trois champs contenant des adresses d'autres nœuds de l'arbre (PAR, EG, ED), respectivement le nœud parent, le nœud enfant de gauche et le nœud enfant de droite), par exemple encodés sur 32 bits chacun ; et
- un champ CLE contenant la clé du nœud, encodée sur un nombre variable de bits.
Il s'ensuit que la taille globale de la structure de données représentant un nœud d'un arbre rouge et noir est de taille variable.
Or, pour réaliser un accélérateur matériel il est nécessaire que chaque nœud présente une taille constante et prédéfinie. Par conséquent, la clé CLE est remplacée par une « clé réduite » constituée par un nombre prédéterminé de bits. Le remplacement d'une clé de taille variable par une clé de taille fixe peut avoir par conséquence le passage d'un ordre total des nœuds à un ordre partiel dans lequel deux nœuds ayant des clés différentes ont une même clé réduite. Il est toujours possible d'assurer que le passage de la clé à la clé réduite préserve l'ordre des nœuds, au moins au sens d'un ordre partiel ; ainsi si la clé du nœud n est supérieure à la clé du nœud m, alors la clé réduite du nœud n est supérieure ou égale à celle du nœud m. Dans le cas de l'égalité, on pourra avoir recours à un post-traitement logiciel pour résoudre l'ambiguïté d'ordonnancement en revenant (en dehors de l'accélérateur matériel) à une représentation complète de la clé.
Etant donné que la couleur prend une valeur binaire, l'encodage sur 32 bits de l'implémentation conventionnelle est fortement redondante ; cela est sans conséquence grave dans le cas d'un traitement purement logiciel, mais augmente inutilement le coût et la complexité d'un accélérateur matériel. Par conséquent, dans une structure de donnée optimisée pour la mise en œuvre de l'invention la couleur est codée sur un seul bit.
Enfin, pour la réalisation d'un accélérateur matériel il est préférable que tous les champs de données représentant un nœud aient une même taille, par exemple 32 bits.
On parvient ainsi à la structure de données de la figure 1 B, comprenant 4 champs de 32 bits :
un champ CRCO, contenant un sous-champ de clé réduite CR (dans la suite on parlera simplement de « clé »), à 31 bits, et un sous-champ de couleur CO, à 1 seul bit ;
trois champs d'adresse à 32 bits chacun, comme dans la structure conventionnelle ;
pour un total de 128 bits par nœud. Bien entendu, le nombre de bits de chaque champ de données peut être choisi différent de 32.
La représentation d'un arbre rouge et noir par la structure de données de la figure 1 B (ou une structure équivalente, obtenue en modifiant l'ordre des différents champs) n'est pas essentielle, mais est préférée.
La variable X, de type « rb_tree_node_t* » (pointeur à un nœud d'arbre rouge et noir) contient l'adresse du premier champ de donnée d'un tel nœud (ici, le champ CRCO, mais cela n'est pas essentiel).
Un accélérateur matériel selon l'invention exécute, pour le compte d'un processeur, certaines instructions nécessaires à la manipulation des arbres rouges et noirs, et notamment :
A. Chercher, dans un arbre rouge et noir stocké en mémoire, le nœud « successeur » d'un nœud donné, c'est-à-dire le nœud présentant une clé de valeur immédiatement supérieure. Le paramètre de la fonction (donnée fournie en entrée à l'accélérateur matériel) est l'adresse du nœud dont le successeur doit être trouvé ; la valeur de sortie de la fonction et l'adresse dudit nœud successeur.
B. Chercher, dans un arbre rouge et noir stocké en mémoire, le nœud « prédécesseur » d'un nœud donné, c'est-à-dire le nœud présentant une clé de valeur immédiatement inférieure. Le paramètre de la fonction est l'adresse du nœud dont le successeur doit être trouvé ; la valeur de sortie de la fonction et l'adresse dudit nœud prédécesseur.
C. Chercher, dans un arbre rouge et noir stocké en mémoire, un nœud dont l'adresse est fournie en entrée, le supprimer et modifier la structure de l'arbre rouge et noire en conséquence, de manière à respecter les règles énoncées plus haut. Les paramètres de la fonction sont l'adresse d'un point d'accès à l'arbre et celle du nœud à supprimer ; la valeur de sortie, optionnelle, est l'adresse du nœud de l'arbre supprimé, correspondant au deuxième paramètre de la fonction.
D. Insérer, dans un arbre rouge et noir stocké en mémoire, un nœud dont l'adresse est fournie en entrée, et modifier la structure de l'arbre rouge et noire en conséquence, de manière à respecter les règles énoncées plus haut. Les paramètres de la fonction sont l'adresse de l'entête de l'arbre et celle du nœud à ajouter.
E. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud. Les paramètres de la fonction sont l'adresse d'un point d'accès à l'arbre et la clé de référence ; la valeur de sortie est l'adresse du nœud trouvé.
F. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est strictement supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud. Les paramètres de la fonction sont l'adresse d'un point d'accès à l'arbre et la clé de référence ; la valeur de sortie est l'adresse du nœud trouvé.
Le point d'accès à l'arbre est généralement son nœud entête. L'accélérateur peut éventuellement exécuter également d'autres instructions. Il est également possible d'envisager d'autres jeux d'instructions équivalents, permettant eux aussi de manipuler des arbres rouges et noir.
En tout cas, l'accélérateur doit avoir accès à une mémoire, partagée avec le processeur, stockant les structures de données à manipuler. Cette mémoire doit être la cache de niveau 1 du processeur, ou une mémoire maintenue cohérente avec ladite cache par des mécanismes connus de l'art antérieur.
L'accélérateur reçoit du processeur les instructions et leurs paramètres, et lui restitue la valeur de sortie.
Pour pouvoir exécuter ces instructions, un accélérateur selon un mode de réalisation de l'invention comprend au moins deux (de préférence trois) registres pouvant stocker l'ensemble des champs de données d'un nœud, et des circuits logiques pour exécuter des opérations plus simples, dans lesquelles les instructions ci-dessus peuvent être décomposées. Ces opérations sont les suivantes :
• envoyer vers ladite mémoire un champ d'adresse, recevoir de ladite mémoire l'ensemble des champs de données du nœud dudit arbre correspondant à ladite adresse et les écrire dans un dit registre en remplacement des champs de données stockés dans ledit registre ;
• envoyer vers la mémoire l'ensemble des champs de données d'un nœud dudit arbre ainsi qu'une adresse de ladite mémoire à laquelle lesdits champs de données doivent être enregistrés ;
• changer la valeur d'un indicateur de couleur stocké dans un dit registre de nœud ; et
• échanger entre elles deux adresses stockées dans deux dits registres de nœud.
La valeur de sortie, fournie au processeur, est un champ d'adresse.
Dans un mode de réalisation préféré de l'accélérateur de l'invention, ces opérations se décomposent dans des opérations encore plus simples, dites « élémentaires ». La figure 2 illustre schématiquement l'architecture d'un tel accélérateur, qui comprend :
une unité de contrôle UC, modélisée par un automate à états finis ;
- une unité de traitement UT, comprenant à son tour une unité de sélection et soustraction SUB/SEL, une unité de réorganisation RORG, des multiplexeurs MUX1 et MUX2 situés aux entrées de ces unités, des comparateurs à zéro (ou, de manière équivalente, à un) CMP1 , CMP2, CMP3 et un réseau de distribution des données RDD comprenant à son tour un multiplexeur MUX3 et des démultiplexeurs DEMUX1 , DEMUX2 ;
une interface de mémoire IM ; et
trois registres de nœuds RN1 , RN2, RN3 (comme mentionné plus haut, deux de ces registres pourraient suffire, trois est le nombre optimal tandis qu'un nombre plus élevé n'apporte pas d'avantage particulier), à 128 bits dans le cas de la représentation de la figure 1 B, ainsi que deux registres additionnels pouvant stocker un seul champ de données (32 bits, dans le cas de la représentation de la figure 1 B) : un registre « temporaire » TEMP pour stocker un champ d'adresse et un registre « de référence REF pour stocker un champ de clé/couleur.
L'unité de contrôle peut être modélisée par un automate à états finis. Elle effectue les opérations suivantes :
Recevoir d'un processeur PROC (le cas échéant par l'intermédiaire d'un circuit d'interface, non représenté) une instruction à exécuter - par exemple une des instructions A à F décrites fonctionnellement ci-dessus - ainsi que ses arguments - typiquement, une ou deux adresses de nœuds respectifs d'un arbre rouge et noir stocké dans une mémoire MEM, et le cas échéant une valeur de clé de référence. Les paramètres de type adresse sont communiquées à l'interface de mémoire IM qui récupère les données correspondantes et les écrit dans un ou plusieurs registres de nœud par l'intermédiaire du réseau de distribution des données. Un éventuel paramètre de type clé de référence est enregistré dans ledit registre de référence REF. L'instruction détermine la séquence de contrôle exécutée par l'unité de contrôle.
Recevoir de l'unité de traitement - et plus précisément des comparateurs CMP1 - CMP3 et de l'unité de sélection et soustraction SUB/SEL - des signaux de condition. Les chemins de ces signaux ne sont pas représentés en entier pour ne pas surcharger la figure ; seules sont représentées des flèches sortant des unités générant ces signaux et des flèches entrant dans l'unité de contrôle.
En fonction de la séquence de contrôle sélectionnée (et donc de l'instruction en cours d'exécution), d'un état interne et des signaux de condition reçus, envoyer aux différents composants de l'unité de traitement des signaux de contrôle (comme pour les signaux de condition, les chemins de ces signaux ne sont pas représentés en entier).
Recevoir de l'unité de traitement (ou prélever d'un registre) l'adresse d'un nœud et le transmettre au processeur en tant que résultat de l'instruction.
En ce qui concerne l'unité de traitement UT :
Le premier multiplexeur MUX1 sélectionne, en fonction d'un signal de contrôle, soit le contenu ATEMP du registre temporaire TEMP, soit celui (CREF) du registre de référence REF. La donnée sélectionnée (32 bits) est transmise à une première entrée de l'unité de sélection et soustraction SUB/SEL.
Le deuxième multiplexeur MUX2 sélectionne, en fonction d'un signal de contrôle, le contenu de l'un des registres de nœud RN1 , RN2, RN3. Les différents champs de la donnée (128) bits ainsi sélectionnée sont traités différemment :
le champ CRCO (clé réduite et couleur) est fourni à une deuxième entrée de l'unité de sélection et soustraction SUB/SEL et également fourni en entrée à l'unité de réorganisation;
- les autres champs (PAR, adresse du nœud parent ;
EG, adresse de l'enfant de gauche ; ED, adresse de l'enfant de droite) sont comparés à zéro (ou, de manière équivalente, à un) par les comparateurs CMP1 , CMP2, CMP3 pour générer des signaux de condition respectifs, et également fournis en entrée à l'unité de réorganisation RORG.
Comme son nom l'indique, l'unité de sélection et soustraction SUB/SEL peut, en fonction d'un signal de contrôle, comparer ses entrées (soustraction) ou sélectionner l'une d'entre elles. Sa sortie est fournie en entrée à l'unité de réorganisation RORG.
L'unité de réorganisation RORG a trois sorties (qui ne sont pas nécessairement actives en même temps) :
- une première sortie à 32 bits, sur laquelle se retrouve l'un des champs de données présents à ses entrées ; si ce champs est un champ de clé et couleur, le bit indicatif de la couleur peut être changé ; la sélection de l'entrée qui se retrouve à la première sortie et le changement éventuel du bit de couleur dépendent d'un signal de contrôle ;
- une deuxième sortie à 32 bits, sur laquelle se retrouve l'un des champs d'adresse présents à ses entrées et provenant d'un registre de nœud via le deuxième multiplexeur ; la sélection du champ d'adresse qui se retrouve à la première sortie dépend d'un signal de contrôle ;
une troisième sortie à 128 bits, sur laquelle se retrouve une structure de nœud reconstituée en sélectionnant et permutant quatre des champs de données présents aux entrées de l'unité ; la sélection et la permutation effectuée dépend d'un signal de contrôle. Concrètement, ladite troisième sortie comprend un champ de clé et couleur provenant de la première ou de la deuxième entrée, avec modification éventuelle du bit indicateur de couleur, et trois champs d'adresse provenant de la troisième, quatrième et cinquième entrée (dont l'ordre peut être modifié).
Ces sorties sont prises en charge par le réseau de distribution des données RDD. Plus précisément :
le premier démultiplexeur DEMUX1 permet de fournir la donnée à la première sortie de l'unité de réorganisation à l'entrée du registre temporaire ou du registre de référence ; la donnée à la deuxième sortie de l'unité de réorganisation (nécessairement une adresse) est fournie à l'interface de mémoire IM ;
la donnée à la troisième sortie de l'unité de réorganisation est également fournie à l'interface de mémoire IM pour être enregistrée dans la mémoire MEM, à l'adresse spécifiée par la donné à la deuxième sortie; elle est également fournie en entrée au troisième multiplexeur MUX3.
Ce troisième multiplexeur MUX3 reçoit également, à une autre entrée, une structure de données de nœud (128 bits) en provenance de la mémoire MEM - le contenu de la cellule de mémoire dont l'adresse a été fournie soit par l'unité de contrôle, soit par la deuxième sortie précitée de l'unité de réorganisation. Le multiplexeur sélectionne l'une de ses entrées, et l'envoie au deuxième multiplexeur DEMUX2, qui la transfère à l'un des registres de nœuds RN1 , RN2, RN3.
Tous ces multiplexeurs et démultiplexeurs sont pilotés par des signaux de contrôle respectifs.
En outre, toujours par l'intermédiaire réseau de distribution des données :
la donnée à la première adresse de l'unité de réorganisation (une adresse) peut être fournie à l'unité de contrôle, qui à son tour la transmet au processeur PROC en tant que donnée de sortie ; et
une clé de référence reçue en tant que paramètre d'instruction peut être transmise de l'unité de contrôle vers le registre de référence REF pour y être enregistrée.
L'unité de traitement UT peut donc réaliser, sous le contrôle de l'unité de contrôle UC, les opérations « élémentaires » suivantes :
a. comparer une clé de référence stockée dans le registre de référence REF avec une clé stockée dans un champ de données d'un registre de nœud, et fournir le résultat de cette comparaison à l'unité de contrôle en tant que signal de condition ;
b. comparer à zéro (ou à une autre valeur prédéterminée) une adresse stockée dans un champ de données d'un registre de nœud, et fournir le résultat de cette comparaison à l'unité de contrôle en tant que signal de condition ;
c. comparer à zéro (ou à un) un indicateur de couleur stocké dans un champ de données d'un registre de nœud, et fournir le résultat de cette comparaison à l'unité de contrôle en tant que signal de condition ;
d. changer la valeur d'un indicateur de couleur stocké dans un champ de données d'un registre de nœud ;
e. envoyer à la mémoire MEM pour écriture, via l'interface IM, l'ensemble des champs de données d'un dit registre de nœud ;
f. recevoir de ladite mémoire l'ensemble des champs de données d'un nœud d'un dit arbre et les stocker dans un dit registre de nœud ;
g. écrire l'adresse temporaire, stockée dans le registre temporaire TEMP, dans un champ de données d'un registre de nœud, en remplacement d'une adresse stockée dans ledit champ ; et h. écrire une adresse stockée un champ de données d'un registre de nœud dans ledit registre temporaire, en remplacement de ladite adresse temporaire.
Chacune de ces opérations élémentaires est effectuée en deux étapes, correspondant chacune à un cycle d'horloge. La première étape comprend la sélection des entrées de l'unité de réorganisation et de l'unité de sélection et soustraction par les multiplexeurs MUX1 et MUX2, ainsi que le chargement de nouvelles données dans les registres, la deuxième étape correspond aux traitements effectués par l'unité de réorganisation et l'unité de sélection et soustraction.
L'architecture de la figure 2 est optimisée de façon a réduire le coût, la complexité et la consommation de l'accélérateur en réutilisant les mêmes composants pour effectuer plusieurs opérations lorsque cela est possible. Une conséquence de cette optimisation est que des opérations sans utilité sont possibles en principe (par exemple : une comparaison entre une donnée de clé/couleur et une adresse dans l'unité SUB/SEL). Cela n'a pas d'importance car les séquences de contrôle de l'unité de contrôle rendent l'exécution de ces opérations impossibles.
La décomposition des instructions A - F définies ci-dessus (ou des instructions d'un jeu équivalent) en opérations élémentaires pouvant être réalisées par l'unité de traitement ne pose pas de difficulté particulière. On remarquera qu'une opération aussi importante que l'échange de deux adresses stockées dans deux registres de nœud n'est pas élémentaire, mais s'effectue en trois temps en utilisant le registre temporaire pour un stockage intermédiaire.
Il est également possible, sans sortir du cadre de l'invention, de concevoir une unité de traitement mettant en œuvre un jeu différent d'instructions élémentaires. En tout cas, le passage d'une définition fonctionnelle de l'unité à une réalisation concrète par des composants électroniques ne pose pas de difficulté fondamentale.
Un accélérateur matériel selon un mode de réalisation peut être intégré dans le « pipeline » d'un processeur de manière à constituer une unité fonctionnelle de ce dernier. Dans ce cas, l'accélérateur matériel bénéficie d'un accès direct à la mémoire cache de niveau 1 et son utilisation met en jeu des instructions spécifiques du processeur. La figure 3 illustre schématiquement la structure et le fonctionnement d'un tel processeur. Le pipeline comprend une unité « FETCH » chargée du chargement d'une instruction depuis la mémoire, une unité « DECODE » de décodage de l'instruction et de stockage de l'instruction décodée dans une queue Q, une unité ISSUE qui sélectionne une instructions prête (dont toutes les entrées sont disponibles) parmi les instructions de la queue Q et transmet cette instruction à une unité fonctionnelle choisie parmi : une unité INT (en charge des opérations dites entières), une unité MULT (en charge des opérations de multiplications), une unité L/S (« Load/Store » : en charge des lectures/écritures depuis/vers la mémoire) et l'accélérateur matériel RBT, ces deux dernières unités ayant accès direct à la mémoire cache de niveau 1 , MC. Chaque unité transmet le résultat du traitement qu'elle exécute à l'unité WB. L'unité WB (« write-back ») est alors en charge de la mise à jour des registres du processeur. Ce mode de réalisation est préféré car il permet de bénéficier pleinement de l'accélération de la manipulation des arbres rouges et noirs. Cependant, il est lourd à mettre en œuvre, car il nécessite une modification du processeur et de son jeu d'instruction.
La figure 4 illustre très schématiquement un autre mode de réalisation, dans lequel l'accélérateur matériel est réalisé sous la forme d'un coprocesseur CPR, communiquant avec un processeur PROC et une mémoire MEM par l'intermédiaire d'un bus de système BUS. Le processeur traite l'accélérateur comme un périphérique, et communique avec lui au moyen de fonctions de système. Comme l'accélérateur n'a pas d'accès direct à la cache de niveau 1 du processeur, ces fonctions de système mettent en œuvre des protocoles de cohérence de cache, connus en soi (en variante, d'autres mécanismes de cohérence de cache connus de l'homme du métier, autres que les protocoles de cohérence, peuvent être utilisés). Ce mode de réalisation est beaucoup plus simple à mettre en œuvre, mais la communication processeur/accélérateur est plus lente, ce qui réduit l'avantage procuré par l'accélération des fonctions de manipulation des arbres rouges et noirs.
Quel que soit le mode de réalisation choisi, un utilisateur accède aux fonctionnalités de l'accélérateur matériel par l'intermédiaire de librairies de fonctions opportunes, remplaçant les librairies standard.
Pour évaluer le résultat technique de l'invention, un simulateur a été réalisé en C++ modélisant un processeur ARM Cortex (marque déposée) et un accélérateur matériel du type illustré sur la figure 2. Ce simulateur a été utilisé pour mesurer les gains rendus possibles par l'utilisation d'un tel accélérateur matériel dans le cadre d'une implémentation des tableaux associatifs utilisés par la compilation dynamique dans l'environnement de compilation LLVM. La figure 5 illustre, sous la forme d'un histogramme, le rapport entre le temps passé dans la manipulation des tableaux associatifs (implémentés par des arbres rouges et noirs) par rapport au temps d'exécution total de compilation pour une pluralité de code sources indiqués en abscisses. Le temps d'exécution total de compilation de code source désigne le temps d'exécution du compilateur LLC, de l'environnement LLVM, passé à la compilation d'un code source donné. Les différents codes sources en entrée du compilateur LLC, proviennent d'un bouquet de code source bien connu, nommé « MiBench ». Pour chaque compilation de code source par le compilateur LLC, ce rapport a été mesuré pour l'implémentation logicielle de la librairie standard C++ (barres en gris clair), pour une implémentation logicielle optimisée (barres en gris intermédiaire) et pour une implémentation utilisant l'accélérateur matériel selon l'invention, dans sa réalisation intégrée au processeur (barres en gris foncé).
Il apparaît que ce rapport passe de 41 % pour la version librairie standard C++ à 24 % pour la version optimisée de manière logicielle et à seulement 12 % pour la version utilisant l'accélérateur matériel. En outre, il a été possible de mettre en évidence un gain brute d'environ un facteur 5 dans le temps de gestion des tableaux associatifs entre l'implémentation logicielle conventionnelle et celle utilisant l'accélérateur matériel.

Claims

REVENDICATIONS
1 . Accélérateur matériel pour la manipulation d'arbres rouges et noirs, chaque dit arbre comprenant plusieurs nœuds, chaque dit nœud comprenant des champs de données de longueur prédéfinie représentant :
un indicateur de couleur, prenant une valeur binaire ;
une clé ;
une adresse d'un autre nœud du même arbre, dit parent ; - une adresse d'un autre nœud du même arbre, dit enfant de gauche ; et
une adresse d'un autre nœud du même arbre, dit enfant de droite ;
ledit accélérateur matériel comprenant :
- au moins deux registres dits registres de nœud (RN1 ,
RN2, RN3), pouvant stocker l'ensemble des champs de deux nœuds d'un dit arbre ; et
des unités logiques (UC, UT) configurées pour recevoir d'un processeur (PROC) au moins une donnée d'entrée choisie parmi une adresse d'un nœud d'un dit arbre et une clé dite de référence, ainsi qu'au moins une instruction à exécuter ; pour exécuter ladite instruction en effectuant une combinaison des opérations suivantes :
• envoyer vers une mémoire (MEM) une adresse, recevoir de ladite mémoire l'ensemble des champs de données du nœud dudit arbre correspondant à ladite adresse et les écrire dans un dit registre en remplacement des champs de données ;
• envoyer vers ladite mémoire l'ensemble des champs de données d'un nœud dudit arbre ainsi qu'une adresse de ladite mémoire à laquelle lesdits champs de données doivent être enregistrés ;
• changer la valeur d'un indicateur de couleur stocké dans un dit registre de nœud ; et • échanger entre elles deux adresses stockées dans deux dits registres de nœud ;
et pour fournir audit processeur au moins une donnée de sortie comprenant une adresse stockée dans un dit registre de nœud.
2. Accélérateur matériel selon la revendication 1 comprenant également un registre (REF), dit registre de référence, pouvant stocker soit une clé, dite de référence, reçue dudit processeur, soit une dite clé de référence et un indicateur de couleur.
3. Accélérateur matériel selon la revendication 2, dans lequel lesdites unités logiques comprennent une unité de traitement (UT) et une unité de contrôle (UC), ladite unité de contrôle étant configurée pour :
recevoir une dite adresse d'un nœud d'un dit arbre en tant que donnée d'entrée et la transmettre à ladite mémoire ;
recevoir une dite clé de référence en tant que donnée d'entrée et la stocker dans ledit registre de référence ;
recevoir une dite instruction à exécuter en tant que donnée d'entrée, ainsi qu'un ou plusieurs signaux de condition en provenance de ladite unité de traitement ;
en réponse à ladite instruction à exécuter et à ladite ou à des dits signaux de condition, générer des signaux de contrôle de ladite unité de traitement ; et
fournir, en tant que donnée de sortie, une adresse de nœud reçue de ladite unité de traitement.
4. Accélérateur matériel selon la revendication 3, dans lequel ladite unité de contrôle est un automate à état finis.
5. Accélérateur matériel selon l'une des revendications 3 ou
4 comprenant également un registre (TEMP), dit registre temporaire, pouvant stocker une adresse, dite adresse temporaire, d'un nœud d'un dit arbre.
6. Accélérateur matériel selon la revendication 5 dans lequel ladite unité de traitement est configurée pour exécuter, en réponse à un dit signal de contrôle, au moins les opérations suivantes :
i. comparer la clé de référence stockée dans ledit registre de référence avec une clé stockée dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
j. comparer à une valeur prédéterminée une adresse stockée dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
k. comparer à une valeur prédéterminée un indicateur de couleur stocké dans un champ de données d'un dit registre de nœud, et fournir le résultat de cette comparaison à ladite unité de contrôle en tant que signal de condition ;
I. changer la valeur d'un indicateur de couleur stocké dans un champ de données d'un dit registre de nœud ;
m. envoyer à ladite mémoire, pour écriture, l'ensemble des champs de données d'un dit registre de nœud ;
n. recevoir de ladite mémoire l'ensemble des champs de données d'un nœud d'un dit arbre et les stocker dans un dit registre de nœud ;
o. écrire ladite adresse temporaire, stockée dans ledit registre temporaire, dans un champ de données d'un dit registre de nœud, en remplacement d'une adresse stockée dans ledit champ ; et p. écrire une adresse stockée un champ de données d'un dit registre de nœud dans ledit registre temporaire, en remplacement de ladite adresse temporaire.
7. Accélérateur matériel selon la revendication 6 dans lequel ladite unité de traitement comprend : une unité de sélection et soustraction (SUB/SEL) configurée pour recevoir : à une première entrée, par l'intermédiaire d'un premier multiplexeur (MUX1 ), le contenu (ATEMP) dudit registre temporaire ou dudit registre de référence (CREF) ; à une deuxième entrée, par l'intermédiaire 5 d'un deuxième multiplexeur (M UX2), un champ de données de clé ou de clé et d'indicateur de couleur issu d'un dit registre de nœud ; et à une entrée de contrôle, un signal de contrôle en provenance de ladite unité de contrôle ; et pour fournie à sa sortie, en fonction dudit signal de contrôle, soit l'une desdites première et deuxième entrée, soit leur différence ;
0 - une unité de réorganisation (RORG) configurée pour recevoir : à une première entrée, la sortie de ladite unité de comparaison et soustractions ; à une deuxième entrée, un champ de données de clé ou de clé et d'indicateur de couleur issu d'un dit registre de nœud, à une troisième, une quatrième et une cinquième entrée, par l'intermédiaire dudit deuxième5 multiplexeur, trois champs de données d'adresse issus d'un dit registre de nœud ; et à une entrée de contrôle, un signal de contrôle en provenance de ladite unité de contrôle ; et pour fournir :
o à une première sortie, un champ de données de clé, de clé et d'indicateur de couleur ou d'adresse présent à l'une de ses o entrées, la valeur dudit indicateur de couleur pouvant être modifiée,
o à une deuxième sortie, un champ de données d'adresse présent à sa deuxième, sa troisième ou sa quatrième adresse ; et/ou
o à une troisième sortie, l'ensemble des champs de 5 données représentatifs d'un nœud dudit arbre, obtenus par sélection et permutation des champs de données présents à ses entrées, avec modification éventuelle d'un indicateur de couleur ;
un ensemble de comparateurs à zéro (CMP 1 , CM P2, CMP3) des champs de données fournis à la troisième, quatrième et 0 cinquième entrée de ladite unité de réorganisation et d'un indicateur de couleur stocké dans ledit registre de référence, les sorties desdits comparateurs étant fournies à ladite unité de contrôle en tant que données de condition ; et
un réseau de distribution des données (RDD) configuré pour :
o fournir un champ de données issu de la première sortie de l'unité de réorganisation soit audit registre temporaire, soit audit registre de référence, en fonction d'un signal de contrôle en provenance de ladite unité de contrôle, ainsi qu'à ladite unité de contrôle ;
o fournir un champ de données issu de la deuxième sortie de l'unité de réorganisation à ladite mémoire ;
o fournir des champs de données issus de la troisième sortie de l'unité de réorganisation à ladite mémoire ;
o fournir des champs de données issus de la troisième sortie de l'unité de réorganisation ou de ladite mémoire à l'un desdits registres de nœud, en fonction d'un signal de contrôle en provenance de ladite unité de contrôle.
8. Accélérateur matériel selon l'une des revendications 6 ou 7 dans lequel ladite unité de traitement est configurée pour générer, en réponse à une instruction reçue en tant que donnée d'entrée, une séquence de signaux de contrôle permettant l'exécution d'une opération choisie parmi les suivantes :
G. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire, le nœud dit successeur présentant une clé de valeur immédiatement supérieure à celle d'un nœud dont l'adresse est fournie en tant que donnée d'entrée, et fournir, en tant que donnée de sortie, l'adresse dudit nœud successeur ;
H. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire, le nœud dit prédécesseur présentant une clé de valeur immédiatement inférieure à celle d'un nœud dont l'adresse est fournie en tant que donnée d'entrée, et fournir, en tant que donnée de sortie, l'adresse dudit nœud successeur ; I. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le nœud dont l'adresse est fournie en tant que deuxième donnée d'entrée, le supprimer et modifier la structure de l'arbre rouge et noire en conséquence ;
J. Insérer, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, un nœud dont l'adresse est fournie en tant que deuxième donnée d'entrée et modifier la structure de l'arbre rouge et noire en conséquence ;
K. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud ; et
L. Chercher, dans un arbre rouge et noir stocké dans ladite mémoire et dont l'adresse d'un point d'accès est fournie en tant que première donnée d'entrée, le premier nœud dont la clé est strictement supérieure ou égale à une clé de référence fournie en tant que deuxième donnée d'entrée et fournir, en tant que donnée de sortie, l'adresse de ce nœud.
9. Accélérateur matériel selon l'une des revendications précédentes dans lequel lesdites unités logiques comprennent également un dispositif d'interface (IM) avec ladite mémoire configuré pour :
recevoir de ladite unité de contrôle l'adresse d'une location de ladite mémoire ; et
transférer le contenu de ladite location de mémoire dans un dit registre de nœud, ou inversement.
10. Accélérateur matériel selon l'une des revendications précédentes, comprenant exactement trois registres de nœud.
1 1 . Accélérateur matériel selon l'une des revendications précédentes, dans lequel l'indicateur de couleur et la clé de chaque dit nœud sont représentés par des bits différents d'un même champ de données (CRCO), ledit indicateur de couleur étant représenté par un seul bit dudit champ.
12. Accélérateur matériel selon la revendication 1 1 dans lequel chaque dit nœud est représenté par :
- un champ de données (CRCO) dont un bit représente ledit indicateur de couleur et les bits restants représentent ladite clé ; et
trois autres champs de données (PAR, EG, ED) représentant les adresses desdits nœuds parent, enfant de gauche et enfant de droite ;
lesdits champs de données présentant tous un même nombre de bits.
13. Processeur comprenant un accélérateur matériel selon l'une des revendications précédentes en tant qu'unité fonctionnelle (RBT) ayant accès au premier niveau de mémoire cache (MC).
14. Système informatique comprenant un processeur (PROC), une mémoire (MEM) et un accélérateur matériel (CPR) selon l'une des revendications 1 à 12 reliés entre eux par un bus système (BUS), ledit processeur étant configuré ou programmé pour communiquer avec ledit accélérateur matériel par l'intermédiaire de requêtes de système et pour assurer une cohérence de cache.
EP14725486.6A 2013-06-05 2014-05-22 Accelerateur materiel pour la manipulation d'arbres rouges et noirs Withdrawn EP3005107A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1355181A FR3006786B1 (fr) 2013-06-05 2013-06-05 Accelerateur materiel pour la manipulation d'arbres rouges et noirs
PCT/EP2014/060544 WO2014195141A1 (fr) 2013-06-05 2014-05-22 Accelerateur materiel pour la manipulation d'arbres rouges et noirs

Publications (1)

Publication Number Publication Date
EP3005107A1 true EP3005107A1 (fr) 2016-04-13

Family

ID=49212804

Family Applications (1)

Application Number Title Priority Date Filing Date
EP14725486.6A Withdrawn EP3005107A1 (fr) 2013-06-05 2014-05-22 Accelerateur materiel pour la manipulation d'arbres rouges et noirs

Country Status (4)

Country Link
US (1) US20160098434A1 (fr)
EP (1) EP3005107A1 (fr)
FR (1) FR3006786B1 (fr)
WO (1) WO2014195141A1 (fr)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN114341888A (zh) * 2019-07-03 2022-04-12 华夏芯（北京）通用处理器技术有限公司 用于操作加速器电路的指令
CN112000482B (zh) * 2020-08-25 2024-03-05 北京金山云网络技术有限公司 一种内存管理的方法、装置、电子设备及存储介质

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See references of WO2014195141A1 *

Also Published As

Publication number Publication date
US20160098434A1 (en) 2016-04-07
FR3006786A1 (fr) 2014-12-12
FR3006786B1 (fr) 2016-12-30
WO2014195141A1 (fr) 2014-12-11

Similar Documents

Publication Publication Date Title
US11106437B2 (en) Lookup table optimization for programming languages that target synchronous digital circuits
TWI512625B (zh) 程式化平行機及電腦實施方法、電腦可讀媒體、電腦及將原始程式碼轉換為機器碼以程式化一平行機之系統
TWI515668B (zh) 用於一狀態機中偵測之方法及系統
TWI489779B (zh) 狀態機晶格中之布林邏輯
CN106716361B (zh) 用于运行时例程冗余跟踪的编译器高速缓存
US11093682B2 (en) Language and compiler that generate synchronous digital circuits that maintain thread execution order
CN107844301A (zh) 一种安卓应用渠道合包方法及装置
US10810343B2 (en) Mapping software constructs to synchronous digital circuits that do not deadlock
US20220156050A1 (en) Generating a synchronous digital circuit from a source code construct defining a function call
EP1290554B1 (fr) Systeme informatique modulaire et procede associe
US20200225920A1 (en) Generating synchronous digital circuits from source code constructs that map to circuit implementations
EP3005107A1 (fr) Accelerateur materiel pour la manipulation d'arbres rouges et noirs
Baka Python Data Structures and Algorithms
Sherrington Mastering Julia
EP0018238B1 (fr) Procédé et ensemble de calcul, aléatoirement par excès ou par défaut, pour fournir des résultats de calcul et en déterminer le nombre de chiffres significatifs exacts
EP3814893A1 (fr) Accès mémoire de processeurs
EP1821197A2 (fr) Dispositif de traitement en notation polonaise inversée, et circuit intégré électronique comprenant un tel dispositif de traitement
US20140258589A1 (en) Random number generation
US20240211549A1 (en) Methods and apparatus for private synthetic data generation
Sherwin et al. Median filters on FPGAs for infinite data and large, rectangular windows
CN108809320A (zh) 一种基于lz77的数据压缩方法、设备及终端
FR2896600A1 (fr) Dispositif de traitement en notation polonaise inversee pour la manipulation de tableau, et circuit integre electronique comprenant un tel dispositif de traitement
Adeel Big data virtualization and visualization: On the cloud
EP3828695A1 (fr) Procédé de construction d'une signature caractéristique des accès, par un microprocesseur, à une mémoire
FR3103594A1 (fr) Système et procédé pour la création assistée par ordinateur de code informatique

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE

17P Request for examination filed

Effective date: 20151029

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

AX Request for extension of the european patent

Extension state: BA ME

DAX Request for extension of the european patent (deleted)
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20201201