Patent Application
20240272907
The present disclosure relates to an improved register bank for electronic processor and to an initialization method of the register bank.
Nowadays, electronic applications have an increasingly widespread transition to the digital domain for the execution of required functionalities and operations. The growing demand for digital data processing capability requires ever greater occupation of the processor area for performing these functionalities and operations.
For example, “Micro Processing Units” (MPU) have gained widespread thanks to their performances in terms of control, data processing and debugging capabilities.
Several families of MPUs are known. In particular, an open-source solution space, called RISCV, has been commonly used lately.
The RISCV processors are becoming the main choice for implementing generic control logic in IoT applications. This occurs thanks to their open-source nature, which allows greater flexibility of use and customization by the processor designer. In fact, the designer may write code in a high-level language (e.g., C, python, etc.), may translate this code into machine language using a compiler of known type and may make the processor execute the instruction list in the machine language, all this in an independent and autonomous manner.
For this type of applications there are usually present one or more sensors, an analog chain for processing the signals coming from the sensors, and the RISCV processor for processing the information coming from the sensors and for performing operations on the basis of these information.
However, RISCV processors have a significant area size. In particular, the RISCV processor comprises a register bank (also called “register file”) which is normally alone responsible for about 70% of the overall occupation of the processor area.
As known, a greater area occupation causes higher costs and power consumption of the processor, as well as a greater risk of congestion of the electrical signals through the electrical connections present in the processor.
One cause of this considerable area occupation and difficult scalability of the register bank is the need to be able to initialize the registers of the register bank to default values (e.g., to be able to reset the memory elements of the registers). This is currently done using, for each memory element, a respective reset line which, when necessary, carries a reset signal to the memory element which causes the initialization thereof. This initialization normally occurs in parallel and therefore substantially simultaneously for all the memory elements of the registers of the register bank, providing each of them with the reset signal through the respective reset line. However, as evident, having a reset line for each memory element causes a considerable occupation of the processor area. Nonetheless, this solution is commonly adopted as it allows the registers of the register bank to be initialized whenever the processor needs to execute a sequence of instructions to complete a task. In fact, without this initialization the processor would not be able to process the right information and therefore could not function properly.
According to the present disclosure, there are provided a register bank, an electronic processor comprising the register bank, an initialization method of the register bank, a control method of the electronic processor and a computer program product thereof.
In an embodiment, a register bank includes a plurality of without-reset registers. The register bank has a write input, a write-enable input, and a write-address input coupled to the plurality of without-reset registers. The register bank has a plurality of operating modes, including an initialization mode of operation and a write mode of operation. In the initialization mode of operation, the register bank responds to receipt of a write-enable signal on the write-enable input by storing initialization data received on the write input into a register of the first plurality of without-reset registers based on a write-address signal received on the write-address input.
In an embodiment, an electronic processor includes a register bank, control circuitry and a multiplexer. The register bank includes a first plurality of without-reset registers, a write input coupled to the first plurality of without-reset registers, a write-enable input coupled to the first plurality of without-reset registers, and a write-address input coupled to the first plurality of without-reset registers. The register bank has a plurality of operating modes including an initialization mode of operation and a write mode of operation. In the initialization mode of operation, the register bank responds to receipt of a write-enable signal on the write-enable input by storing initialization data received on the write input into a register of the first plurality of without-reset registers based on a write-address signal received on the write-address input. The control circuitry is coupled to the register bank, and, in operation, the control circuitry generates a control signal, the write-enable signal and the write-address signal. The multiplexer has a plurality of data inputs including: a first data input, which, in operation, receives operating data signals; a second data input, which, in operation, receives initialization data signals; a control input coupled to the control circuitry. In operation, the control input receives the control signal. The multiplexer has an output coupled to the write input of the register bank, and the multiplexer, in operation, couples one of the plurality of data inputs of the multiplexer to the output of the multiplexer based on the control signal.
In an embodiment, a method comprises operating a register bank having a plurality of operational modes in an initialization mode of operation, the plurality of operational modes including the initialization mode of operation and a write mode of operation, and responding to receipt of a write-enable signal by the register bank during the initialization mode of operation by storing initialization data into a register of a plurality of without-reset registers of the register bank based on a write-address received by the register bank.
In an embodiment, a method comprises operating a processor having a register bank in one of a plurality of operational modes, the plurality of operational modes including a reset mode, a write mode, and a read mode, responding to receipt of a write-enable signal by the register bank during the reset mode of operation by storing initialization data into one or more registers of a plurality of without-reset registers of the register bank based on write-addresses received by the register bank, and responding to receipt of a write-enable signal by the register bank during the write mode of operation by storing operating data into one or more registers of the plurality of without-reset registers of the register bank based on write-addresses received by the register bank.
In an embodiment, a non-transitory computer-readable medium's contents cause a processing system to perform a method. The method comprises: operating the processing system in one of a plurality of operational modes, the plurality of operational modes including a reset mode, a write mode, and a read mode; responding to receipt of a write-enable signal by a register bank of the processing system during the reset mode of operation by storing initialization data into one or more registers of a plurality of without-reset registers of the register bank based on write-addresses received by the register bank; and responding to receipt of a write-enable signal by the register bank during the write mode of operation by storing operating data into one or more registers of the plurality of without-reset registers of the register bank based on write-addresses received by the register bank.
For a better understanding of the present disclosure, example embodiments are now described, purely by way of non-limiting example, with reference to the attached drawings, wherein:
In the following description, elements common to the different embodiments have been indicated with the same reference numerals.
In particular, the processor 10 is of RISCV type; nevertheless, other types of processors may be similarly considered. By way of example and further description, greater details regarding the ISA (“Instruction Set Architecture”) on which the RISCV standard is based, may be found in the document “The RISC-V Instruction Set Manual, Volume I: Base User-Level ISA” by Waterman et al., 2011, Technical Report No. UCB/EECS-2011-62 (https://www2.eecs.berkeley.edu/Pubs/TechRpts/2011/EECS-2011-62.pdf).
The processor 10 is operatively couplable to one or more sensors (not shown and of known type), for example, through an interface module not shown and of known type (e.g., comprising an analog-to-digital converter and a digital-to-analog converter, amplifiers, filters, etc.). In use, the processor receives, from one or more sensors, respective information which is indicative of measurements carried out by the sensors and is optionally pre-processed by the interface module.
In particular, the processor 10 may comprise a clock generator (CG) 24 configured to generate a clock signal CLK and coupled to the other components of the processor 10 in such a way as to provide the clock signal CLK to each of them.
The processor 10 may comprise an instruction register 12 and a load-and-store unit (LSU) 14. The instruction register 12 comprises a multiplicity of memory registers (in detail, each comprising memory elements such as flip-flops) and is operatively couplable to an instruction memory 16 (e.g., a random access memory, RAM) external to the processor 10 and configured to store one or more instruction sequences to be executed by the processor 10 so that the latter performs respective tasks. In detail, the instructions stored in the instruction memory 16 are in machine code and represent the translation into machine language of respective instructions of a code written by a programmer in high-level language (e.g., C, Python, Fortran) to perform the respective task and subsequently translated into machine language through a known-type compiler. The instruction register 12 receives instructions from the instruction memory 16 and stores them so that they are available to be executed by the processor 10, when needed. The LSU 14 comprises a multiplicity of memory registers (in detail, each comprising memory elements such as flip-flops) and is operatively couplable to a sensor data memory 18 (e.g., a RAM) external to the processor 10 and configured to store data, for example, data coming from the one or more sensors. Similarly to the instruction register 12, the LSU 14 receives data from the sensor data memory 18 and stores it so that it is available for the execution of the instructions of the processor 10, when needed.
The processor 10 further comprises a control unit (CU) 20 which is configured to receive instructions from the instruction register 12 and to generate a consequent plurality of electrical signals for controlling the components of the processor 10.
The processor 10 may comprise a program counter (PC) 22 controllable by the CU 20 to select addresses of the instruction memory 16 which contain instructions to be passed to the instruction register 12 so that they are executed by the processor 10 in the next steps.
The processor 10 comprises a register bank (RB, also called “register file”) 50, better described hereinbelow. The RB 50 is connected to the instruction register 12 to receive from the latter and store the instructions to be executed by the processor 10. In detail and as better described hereinbelow, the RB 50 is controllable by the CU 20 to store the data corresponding to the instructions coming from the instruction register 12 and to send it, in an orderly manner thanks to the control of the CU 20, to the components of the processor 10 which are to process this data to execute the respective instructions.
The processor 10 may also comprise an immediate generator (IM) 30 connected to the instruction register 12 and configured to decode the constant values to be used during the processing, starting from the instruction which is imported from the instruction memory 16.
By way of example, a first main multiplexer (MUX) 26 and a second main MUX 28 which may be comprised in the processor 10 are also shown (in
The processor 10 may also comprise an arithmetic-logic unit (ALU) 32 which has inputs each connected to the output of a respective main MUX 26, 28 and which is configured to process the received data in a per se known manner (e.g., through logic and/or arithmetic operations defined by the CU 20 having the ALU 32 connected thereto to be controlled). For example, the ALU 32 operates with 32-bit data.
The processor 10 may also comprise an initialization datum generation module 34 (indicated in
The initialization datum generation module 34 has an input connected to a reference node (in detail, a ground node) GND which has a reference electric potential (for example, equal to 0 V).
In particular, the initialization datum generation module 34 is configured to acquire the reference electric potential and to generate, at an output of the initialization datum generation module 34, a corresponding initialization datum (of digital type, hereinafter also indicated, for the sake of simplicity, D_INIT and, for example, having 32 bits).
In particular, D_INIT is of defined type (with a fixed and known value) and is indicative of the reference electric potential.
In the example considered, D_INIT is formed by 32 bits with value 0 which are defined starting from 0 V of the reference node GND.
In detail, the initialization datum generation module 34 is of known type and, for example, comprises a pull-down network (PDN) of known type and therefore pull-down resistors (greater details may be found, for example, at the link https://www.electronics-tutorials.ws/logic/pull-up-resistor.html).
However, other known structures and techniques are usable to generate D_INIT, in a manner per se evident to the person skilled in the art. For example, D_INIT may be stored in the instruction memory 16 and obtained through the instruction register 12.
Furthermore, the processor 10 comprises an input datum MUX 52 (indicated in
In particular, the RB 50 has a write datum input 50a, a write enable input 50b, a write address input 50c, a first read address input 50d, a second read address input 50e, a first read output 50f, a second read output 50g, and a clock input 50h.
The write datum input 50a is connected to the output of the input datum MUX 52 (indicated in
In use, the write datum input 50a receives, from the input datum MUX 52, a write datum (hereinafter also indicated, for the sake of simplicity, D and, for example, having 32 bits), the write enable input 50b receives, from the CU 20, a write enable signal (hereinafter also indicated, for the sake of simplicity, WR_EN and, for example, having 1 bit), the write address input 50c receives, from the CU 20, a write address signal (hereinafter also indicated, for the sake of simplicity, WR_ADDR and, for example, having 5 bits), the first read address input 50d receives, from the CU 20, a first read address signal (hereinafter also indicated, for the sake of simplicity, RD_ADDR_0 and, for example, having 5 bits), the second read address input 50e receives, from the CU 20, a second read address signal (hereinafter also indicated, for the sake of simplicity, RD_ADDR_1 and, for example, having 5 bits), the first read output 50f sends, to the first main MUX 26, a first read output signal (hereinafter also indicated, for the sake of simplicity, Q_0 and, for example, having 32 bits), the second read output 50g sends, to the second main MUX 28, a second read output signal (hereinafter also indicated, for the sake of simplicity, Q_1 and, for example, having 32 bits) and the clock input 50h receives, from the CG 24, the clock signal (hereinafter also indicated, for the sake of simplicity, CLK). In greater detail, the input datum MUX 52 generates D, the CU 20 generates WR_EN, WR_ADDR, RD_ADDR_0, RD_ADDR_1 and the CG 24 generates the CLK.
By way of example, the RB 50 is described herein considering the case in which it is capable of providing two outputs in parallel (e.g., it is capable of simultaneously generating two data at output, each on a respective output channel Q_0 and Q_1); nevertheless, the number of outputs of the RB 50 may vary and, for example, be smaller (e.g., 1 single output) or greater (e.g., N>2 outputs), as better described hereinbelow.
As already described, the input datum MUX 52 has the first input (indicated in
The first input 52a is connected to the LSU 14, the second input 52b is connected to the reference node GND, the third input 52c is connected to the ALU 32, the output 52d is connected to the write datum input 50a of the RB 50 and the control input 52e is connected to a fifth output 20e of the CU 20.
In use, the first input 52a receives, from the LSU 14, a sensor datum (hereinafter also indicated, for the sake of simplicity, D_SENS and, for example, having 32 bits), the second input 52b acquires the initialization datum (D_INIT), the third input 52c receives, from the ALU 32, an ALU datum (hereinafter also indicated, for the sake of simplicity, D_ALU and, for example, having 32 bits), the output 52d sends the RB 50 the write datum (D) and the control input 52e receives, from the CU 20, a control signal (hereinafter also indicated, for the sake of simplicity, SEL and, for example, having 2 bits). In greater detail, the LSU 14 generates D_SENS, the reference node GND defines D_INIT, the ALU 32 generates D_ALU, the CU 20 generates SEL and the RB 50 receives D.
For example, D_SENS is indicative of the measurements carried out by the one or more sensors couplable to the processor 10.
Furthermore, SEL is a signal which allows to select which signal at the input of the input datum MUX 52 is to be transmitted at output to the latter. For example, SEL may assume a first value (e.g., ‘00’), a second value (e.g., ‘01’) or a third value (e.g., ‘10’); when SEL=‘00’ the first input 52a is selected and therefore D=D_SENS, when SEL=‘01’ the second input 52b is selected and therefore D=D_INIT, when SEL=‘10’ the third input 52c is selected and therefore D=D_ALU.
In particular and as better described below with reference to
The RB 50 may operate selectively, at each instant, in an initialization (or reset) mode or in a write mode. Furthermore, at each instant the RB 50 may also operate in read mode, simultaneously or not with the write/initialization mode.
In particular, in the initialization mode each of these memory elements of the registers may be initialized to a defined and default value (a reset value, e.g., ‘0’) controlling the input datum MUX 52 in such a way that D=D_INIT (where D_INIT is a K2-bit datum, wherein each of these bits is stored in a respective memory element of the register and is equal to the reset value, e.g., ‘0’) and simultaneously selecting the initialization mode of the RB 50 (this occurs when WR_EN assumes a first value, e.g., ‘1’) and providing a register address which identifies, from among the registers present in the RB 50, the specific register to be initialized (this occurs when WR_ADDR assumes a value corresponding to the address in the RB 50 of the register to be initialized).
In write mode (optional), each register may be overwritten (e.g., the bit of each memory element of the register may pass from ‘0’ to ‘1’ and vice versa) controlling the input datum MUX 52 in such a way that D=D_SENS or D=D_ALU (depending on whether it is desired to write in the register the datum coming from the LSU 14 or, respectively, from the ALU 32) and simultaneously selecting the write mode of the RB 50 (this occurs when WR_EN assumes the first value, e.g., ‘1’) and providing a register address which identifies, from among the registers present in the RB 50, the specific register to be overwritten (this occurs when WR_ADDR assumes a value corresponding to the address in the RB 50 of the register to be overwritten).
In the read mode (optional), each register may be read (the bits saved in the memory elements may be provided at output to the RB 50) providing the register addresses which identify, from among the registers present in the RB 50, the specific registers to be read in the read outputs 50f and 50g (this occurs when RD_ADDR_0 and RD_ADDR_1 each assume a value corresponding to the address in the RB 50 of the registers to be read, in such a way as to provide at output as first and, respectively, second read output signal Q_0 and Q_1 the data saved in the respective registers identified by RD_ADDR_0 and RD_ADDR_1).
As evident, the initialization mode and the write mode are similar and differ only for the datum to be written in the register (the sequence of reset values for the initialization mode and the datum D_SENS or D_ALU for the write mode). In other words, both the initialization mode and the write mode may be considered as comprised in an update mode of the RB 50, identified by WR_EN=‘1’ (common to both the initialization mode and the write mode and identifying the enabling of the update of the RB 50). Consequently, the without-reset memory elements of the RB 50 may be initialized in a manner similar to that commonly used to write therein. This facilitates the correct functioning of the RB 50 and therefore of the processor 10 without the need to have a reset line for each memory element of the RB 50 (an additional input for each memory element, configured to receive a reset signal when the memory elements are to be initialized). The update mode of the RB 50 is instead disabled when WR_EN assumes a second value (e.g., WR_EN=‘0’ identifying the disabling of the update of the RB 50); in this case, the RB 50 can neither be initialized nor overwritten.
As already mentioned, the RB 50 comprises K1 registers, here indicated as a whole with the reference 60. In the embodiment of
In detail, each register 60i (with 1≤i≤4) comprises a respective write datum input 60a, a respective write enable input 60b, a respective clock input 60c and a respective output 60d.
The RB 50 further comprises a decoder (with abbreviation DEC in
The RB 50 also comprises K1 main AND logic gates, indicated as a whole with the reference 64 and with the abbreviation A. In other words, there are present a first to a fourth main AND logic gate 64i (with 1≤i≤4), one for each register 60.
Each main AND logic gate 64i is of AND type and has a first input 64a, a second input 64b and an output 64c, respectively. In each main AND logic gate 64i the first input 64a is connected to the i-th output 62bi, of the decoder 62, the second input 64b coincides with the write enable input 50b of the RB 50 and therefore is connected to the CU 20 to receive WR_EN and the output 64c is connected to the write enable input 60b of the i-th register 60,i.
In each register 60i (abbreviation REG in
The RB 50 further comprises an output MUX for each output of the RB 50. In other words, in the embodiment of
Each output MUX 66 is of Ki:1 type, comprises respectively K1 inputs (one for each register 60, indicated in
In particular, each register 60 comprises K2 memory elements, one for each bit of the datum to be stored in the register 60. The memory elements are indicated as a whole with the reference 70. By way of example and not to excessively obscure the understanding,
In detail, the memory elements 70 are of without-reset type (they do not have an initialization input for receiving a reset signal) and may each store a 1-bit information. In fact, the registers 60 of the without-reset type are defined as registers comprising memory elements 70 of without-reset type.
In detail, the memory elements 70 are flip-flops of without-reset type (so-called without-reset flip-flops), for example, known without-reset D flip-flops. For illustrative and non-limiting purposes, the book “CMOS VLSI Design: A Circuits and System Perspective” describes, in section 10.3.2, a possible example of without-reset flip-flop (e.g.,
In greater detail, each memory element 70k (with 1≤k≤4) has a write datum input 70a, an enable input 70b, a clock input 70c and a read output 70d.
In particular, the write datum inputs 70a form the write datum input 60a of the register 60i, and are therefore configured to receive D. In greater detail, in use each memory element 70k receives an elementary datum Dk of D (the bit Dk of D) in such a way that the succession of K2 bits of D is stored simultaneously, bit by bit, in the K2 memory elements 70k, in a per se known manner. Furthermore, the enable inputs 70b form the write enable input 60b of the register 60i and are therefore connected to the main AND logic gate 64i. The clock inputs 70c form the clock input 60c of the register 60i and are therefore connected to the CG 24. The read outputs 70d form the output of the register 60i and are configured to transmit the information saved in the memory elements 70k. This information output from the register 60i is called hereinbelow output signal (hereinafter also indicated, for the sake of simplicity, OUTi). OUTi has K2 bits, one for each memory element 70k. In detail, the read output 70d of each memory element 70k generates at output an elementary datum OUTi,k of OUTi (the bit OUTi,k of OUTi) in such a way that the succession of K2 bits of OUTi is provided at output from the register 60i simultaneously, bit by bit, by the K2 memory elements 70k, in a per se known manner.
In use, the CU 20, the input datum MUX 52 and the RB 50 function as now described.
At each clock pulse of CLK, the CU 20 generates SEL, WR_EN, WR_ADDR, RD_ADDR_0, RD_ADDR_1, Q_0 and Q_1 on the basis of the finite-state machine (FSM) shown in
At each clock pulse of CLK, the input datum MUX 52 selects D from among D_SENS, D_INIT and D_ALU on the basis of SEL. For example, if SEL=‘00’ D=D_SENS, if SEL=‘01’ D=D_INIT and if SEL=‘10’ D=D_ALU.
At each clock pulse of CLK, the decoder 62 receives WR_ADDR at input and decodes it, in a per se known manner, to generate at output K1 address signals ADDRi (a first to a fourth address signal ADDR1-ADDR4), one for each register 60i. For example, ADDRi has 1 bit like WR_EN. ADDRi assumes a first value (e.g., ‘0’) when WR_ADDR is not indicative of the initialization of the i-th register 60i, and assumes a second value (e.g., ‘1’) when WR_ADDR is indicative of the initialization of the i-th register 60i.
For example, when WR_ADDR is indicative of the initialization of the third register 603, ADDRi=‘0’, ADDR2=‘0’, ADDR3=‘1’, ADDR4=‘0’.
Each main AND logic gate 64i receives at input ADDRi and WR_EN and generates at output an enable signal ENi which assumes a first value (e.g., ‘0’) if ADDRi=‘0’ and/or WR_EN=‘0’ and assumes a second value (e.g., ‘1’) if ADDRi=‘1’ and WR_EN=‘1’. In other words, ENi=‘1’ only if the method is in write/initialization mode (WR_EN=‘1’) and if the i-th register 60i has been selected for writing/initialization.
Each register 60i receives at input ENi, D and CLK and generates at output OUTi. In detail, each memory element 70k receives at input ENi, Dk and CLK and generates at output OUTi,k. In particular, if ENi‘1’ the register 60i is to be updated at the current clock pulse, therefore each memory element 70k of the register 60i stores Dk; if instead ENi=‘0’ the register 60i is not to be updated at the current clock pulse, therefore each memory element 70k of the register 60i keeps in memory the value Dk previously stored and does not update it on the basis of the last D received. Furthermore, each memory element 70k of the register 60i generates at output the stored value OUTi,k so that OUTi is generated at output by the register 60i.
Each output MUX 66j receives at input RD_ADDR_j and the OUTis of all the registers 60i and generates at output Q_j. In particular, Q_j is equal to the OUTi of the register 60i selected through RD_ADDR_j. For example, if RD_ADDR_j identifies the second register 602 and RD_ADDR_j identifies the third register 603, Q_0=OUT2 and Q_1=OUT3.
Initially (passing condition 102), the CU 20 activates upon receiving a processor activation signal (EN_P). For example, EN_P is a fetch enable signal which is absent when the processor 10 is off and may be provided from the outside, for example, may be provided manually by an operator who turns on an electronic apparatus which comprises the processor 10.
Upon receiving EN_P, the processor 10 passes to an unknown state 104, by default, and remains there until the CU 20 receives (passing condition 106) a reset signal (RST) in addition to EN_P. RST is provided to the CU 20 when the initialization of the processor 10 and therefore the reset of the RB 50 is requested, so that the processor 10 is ready to operate correctly. Consequently, RST is indicative of an initialization request of the registers 60.
When the CU 20 receives RST, the processor 10 passes to an initialization state 108 wherein the RB 50 is initialized. This state coincides with the initialization mode of the RB 50 and defines the initialization method of the RB 50.
In the initialization state 108, the CU 20 controls the sequential initialization of all registers 60. In other words, the CU 20 generates WR_EN=‘1’ and SEL=‘10’ for K1 clock pulses (initialization period) and, at each clock pulse, generates the WR_ADDR corresponding to a respective register 60i. In this manner, at each clock pulse a respective register 60i is initialized to D_INIT and, at the end of the K1 clock pulses, all registers 60 of RB 50 are initialized.
After the initialization of all registers 60 is completed, the CU generates (passing condition 110) an initialization completed signal (DONE) indicative of the completion of the initialization of the registers 60 of the RB 50.
As long as DONE is not generated, the processor 10 remains in the initialization state 108. Upon generating DONE, the processor 10 passes to an idle state 112 wherein the processor 10 is ready to operate.
The processor 10 remains in the idle state 112 as long as (passing condition 114) the CU 20 receives an operation start signal (START) in addition to EN_P. START is indicative of a start of execution of the operations of the processor 10, of execution of the instructions present in the instruction register 12.
When the CU 20 receives START, the processor 10 fetches (step 116) an instruction present in the instruction memory 16 and saves it in the instruction register 12, checks (passing condition 118) that EN_P is always present, decodes (step 120) the fetched instruction, processes (step 122) the instruction (executes it, for example, the ALU 32 performs the requested operation established by the instruction), acquires (step 124) the address of the successive instruction to be fetched from the instruction memory 16 and repeats steps 116-124 with the new instruction to be executed. Examples of these instructions to be executed are reading and overwriting one or more registers 60 of the RB 50.
Steps 114-124 are performed in a per se known manner and therefore are not described herein in detail. In general, steps 114-124 define an operation execution state of the processor 10.
The repetition of steps 116-124 allows the instructions present in the instruction register 12 to be executed and therefore allows the task required to the processor 10, previously initialized at step 108, to be completed.
For example, RST, DONE and START are flags that are generated upon reaching the respective conditions. Otherwise, they are signals that assume a first value (e.g., ‘0’) by default and pass to a second value (e.g., ‘1’) upon reaching the respective conditions.
In particular,
From
Up to t2 (at the first clock pulse immediately successive to t1, for example, considered on the rising edge of CLK), WR_EN=‘0’ and the FSM is in the unknown state 104.
At t2 and for the successive K1 clock pulses, WR_EN passes to ‘1’ (initialization mode), SEL passes from any value to ‘10’ (D=D_INIT) and WR_ADDR assumes, at each clock pulse, a value indicative of a respective address of the register 60 of the RB 50 to be initialized. In detail, at t2 WR_ADDR is indicative of the first register 601, at t3 WR_ADDR is indicative of the second register 602, at t4 WR_ADDR is indicative of the third register 603, at t5 WR_ADDR is indicative of the fourth register 604. Consequently, in the K1 clock pulses successive to t2 (in t2≤t≤t6) the registers 60 are initialized to D_INIT. At t6 WR_EN returns to ‘0’ and DONE is generated. Consequently, in t2≤t≤t2 the FSM is in the initialization state 108.
In particular, referring to the exemplary case of the second register 602, ADDR2 passes from ‘0’ to ‘1’ at t3 (at the second clock pulse after t2) to return then to ‘0’ at t4, and similar behavior may be seen in EN2. At t3 therefore, D_INIT is stored in the second register 602 and OUT2 passes from an undefined value (e.g., XXXX considering a 4-bit register 60) to D_INIT (e.g., 0000 considering a 4-bit register 60).
At t7 START is received, therefore in t6≤t≤t8 (where t8 is the first clock pulse immediately successive to t7, for example, considered on the rising edge of CLK) the FSM is in the idle state 112.
At t8 the FSM passes in states 116-124 (one state for each clock pulse successive to t8). Consequently, the execution of the first instruction lasts from t8 to t12 and states 116-124 are repeated every 4 clock pulses until the end of the instructions saved in the instruction register 12.
In particular, at t8 RD_ADD_0 and RD_ADD_1 pass from respective undefined values to values indicating the addresses of the respective registers 60 whose value in Q_0 and Q_1 is desired to be read (which is done at t8, as may be seen). Furthermore, SEL is generated by the CU 20 at each clock pulse as a function of the current instruction to be executed and, consequently, D varies accordingly.
Consequently, the procedure for initializing the registers 60 performed in t2≤t≤t6 generates a latency equal to K1 clock pulses but allows the registers 60 to be initialized without the need to send the reset signal to each memory element. This allows the correct and normal use of the processor 10 at t≥t8.
From an examination of the characteristics of the disclosure made according to the present disclosure, the advantages that it facilitates are evident.
In particular, the register bank 50 allows a significant reduction in terms of silicon area necessary for the processor 10, without compromising the performances of the latter. For example, considering a RISCV processor with single-stage ISA RV32I and with H9A-type tech node, with the same performances, the area savings of the present register bank 50 and of the processor 10 thereof are about 10% relative to the case of a known-type register bank, with a decrease of logic gates equal to about 1 Kgate. This entails a substantial saving in terms of area occupation of the register bank 50, overall cost and power consumption of the processor 10. Furthermore, this entails a better reliability of the processor 10 since the risk of congestion of the electrical signals generated by the processor 10 decreases.
These advantages are made possible thanks to the use of memory elements 70 of the registers 60 (in particular, flip-flops) of without-reset type. In fact, considering that normally a with-reset flip-flop comprises 24 transistors while a without-reset one comprises 20 transistors, using without-reset flip-flops allows the area occupation to be reduced by about 16.67% for each flip-flop. Considering then that the register bank 50 generally comprises 32×32 flip-flops, it is understood how the overall reduction of the area occupied by the present register bank 50 relative to a known-type one is significant.
Although the memory elements 70 are without reset, they maintain the possibility of being initialized by the previously described initialization mode, in synchronous logic, unchanged. In other words, the initialization mode allows the registers 60 internal to the register bank to be initialized so that they function correctly when the processor 10 executes the instructions whereto it is appointed.
The initialization procedure is repeated whenever RST is applied to the entire processor 10. Since this rarely occurs during use of the processor 10, the initial latency due to the initialization of the registers 60 is completely negligible with respect to the period in which the processor 10 may operate following the initialization of the registers 60. For example, considering a register bank 50 with 32 registers and a CLK frequency equal to about 10 MHz, the latency for the initialization of the registers 60 is approximately equal to 3.5 μs and the average duration of execution of a program by the processor 10 is about 2 seconds; consequently, the impact of the initialization latency on the average duration of execution of the program is about 10−3, substantially null.
Furthermore, the possibility of initializing the registers 60 in write mode (already provided in common register banks) allows the number of structural and design modifications to be applied to the register bank 50 to be limited, allowing an already present functionality to be used in a new manner.
Finally, it is clear that modifications and variations may be made to the disclosure described and illustrated herein without thereby departing from the scope of the present disclosure. For example, the different embodiments described may be combined with each other so as to provide further solutions.
Furthermore, the input datum MUX 52 may, more generally, choose between D_INIT and at least one further input operating datum (e.g., D_SENS or D_ALU). In other words, the input datum MUX 52 may have two or more inputs (among which the input for D_INIT is present) and may be configured to transmit D_INIT or a further datum at output. For example, the input datum MUX 52 may have M>3 inputs and SEL may assume M values in such a way that the output 52d may generate D_INIT or a different datum chosen from among the M−1 remaining data received at the input of the input datum MUX 52.
The RB 50 may have a different number of outputs, and therefore generate a single read output signal (e.g., Q_0) or more than two read output signals, through a respective number of output MUXs 66.
Furthermore, K1 and K2 may be different with respect to what has been previously described and, for example, equal to 32. This may be accomplished through obvious modifications on the basis of what has been previously described. For example, the RB 50 comprises in this case 32 outputs of the decoder 62, 32 main AND logic gates 64, 32 registers 60 (each comprising 32 without-reset flip-flops).
A register bank (50) for an electronic processor (10) may be summarized as including a first plurality of registers (60), wherein the register bank (50) has a write datum input (50a), a write enable input (50b) and a write address input (50c), wherein the write datum input (50a) is configured to receive an initialization datum (D_INIT) of predefined type, the write enable input (50b) is configured to receive a write enable signal (WR_EN) and the write address input (50c) is configured to receive a write address signal (WR_ADDR), wherein the register bank (50) is selectively controllable in an initialization mode and in a write mode of at least one register (60) of the first plurality of registers (60), wherein the register bank (50) is configured to, in the initialization mode of the at least one register (60) of the first plurality of registers (60): receive, in the initialization mode, the initialization datum (D_INIT); receive, in the initialization mode, the write enable signal (WR_EN) identifying the enabling of the update of the at least one register (60) to be initialized; receive, in the initialization mode, the write address signal (WR_ADDR) identifying an address of the at least one register (60) to be initialized; and in response to receiving the write enable signal (WR_EN), store the initialization datum (D_INIT) in the at least one register (60) to be initialized.
The registers (60) may be of without-reset type.
The write datum input (50a) may be further configured to receive an operating datum (D_SENS; D_ALU), wherein the register bank (50) is configured to, in a write mode of at least one register (60) of the first plurality of registers (60): receive, in the write mode, the operating datum (D_SENS; D_ALU); receive, in the write mode, the write enable signal (WR_EN) identifying the enabling of the update of the at least one register (60) to be overwritten; receive, in the write mode, the write address signal (WR_ADDR) identifying the address of the at least one register (60) to be overwritten; and in response to receiving the write enable signal (WR_EN), store the operating datum (D_SENS; D_ALU) in the at least one register (60) to be overwritten.
The register bank (50) may further have at least one first read address input (50d) and at least one first read output (50f), wherein the first read address input (50d) is configured to receive a first read address signal (RD_ADDR_0) and the first read output (50f) is configured to generate a first read output signal (Q_0), wherein the register bank (50) is configured to, in a read mode of at least one register (60) of the first plurality of registers (60): receive, in the read mode, the first read address signal (RD_ADDR_0) identifying the address of the at least one register (60) to be read; and generate, in the read mode, the first read output signal (Q_0) which corresponds to the datum stored in the at least one register (60) to be read.
In the initialization mode, the register bank (50) may be configured to initialize the registers (60) of the first plurality of registers (60) in succession to each other.
Each register (60) may include a second plurality of memory elements (70) of without-reset type.
Each register (60) of the first plurality of registers (60) may have a respective write datum input (60a) and a respective write enable input (60b), wherein the write datum input (60a) of each register (60i) forms the write datum input (50a) of the register bank (50), wherein the register bank (50) further comprises: a decoder (62) having an input (62a) and having a respective output (62bi) for each register (60), the input (62a) of the decoder (62) forming the write address input (50c) of the register bank (50) and being configured to receive the write address signal (WR_ADDR); and a respective main AND logic gate (64) for each register (60), each main AND logic gate (64) being of AND type and respectively having a first input (64a), a second input (64b) and an output (64c), wherein the first input (64a) of each main AND logic gate (64i) is connected to a respective output (62bi) of the decoder (62), the second input (64b) of each main AND logic gate (64i) forms the write enable input (50b) of the register bank (50) and is configured to receive the write enable signal (WR_EN) and the output (64c) of each main AND logic gate (64i) is connected to the write enable input (60b) of a respective register (60i) of the registers (60).
An electronic processor (10) may be summarized as including: a register bank (50), as discussed above; a control unit (20) configured to generate a control signal (SEL), the write enable signal (WR_EN) and the write address signal (WR_ADDR); an input datum multiplexer (52), which has at least a first input (52a), a second input (52b), a control input (52e) and an output (52d), the first input (52a) being configured to receive an operating datum (D_SENS; D_ALU), the second input (52b) being configured to acquire the initialization datum (D_INIT), the control input (52e) being connected to the control unit (20) and being configured to receive, from the control unit (20), the control signal (SEL), the input datum multiplexer (52) being configured to transmit to the output (52d) the operating datum (D_SENS; D_ALU) or the initialization datum (D_INIT), on the basis of the control signal (SEL), wherein the write datum input (50a) is connected to the output (52d) of the input datum multiplexer (52) and wherein the write enable input (50b) and the write address input (50c) are connected to the control unit (20), wherein the write datum input (50a) is configured to receive from the input datum multiplexer (52) the operating datum (D_SENS; D_ALU) and the initialization datum (D_INIT), the write enable input (50b) is configured to receive from the control unit (20) the write enable signal (WR_EN) and the write address input (50c) is configured to receive from the control unit (20) the write address signal (WR_ADDR), wherein, in the initialization mode of the at least one register (60) of the first plurality of registers (60), the control unit (20) is configured to: set, in the initialization mode, the control signal (SEL) in such a way that the input datum multiplexer (52) transmits to the output (52d) the initialization datum (D_INIT); set, in the initialization mode, the write enable signal (WR_EN) to a value identifying the enabling of the update of the at least one register (60) to be initialized; and set, in the initialization mode, the write address signal (WR_ADDR) to a value identifying the address of the at least one register (60) to be initialized.
The electronic processor's (10) registers (60) may be of without-reset type.
The electronic processor (10) may further include: an instruction register (12) which comprises a multiplicity of memory registers and is configured to store one or more instructions to be executed by the processor (10); a load-and-store unit (14), which comprises a respective multiplicity of further memory registers and is configured to store data usable by the processor (10); and an arithmetic-logic unit (32), wherein the input datum multiplexer (52) further has a third input (52c), wherein the first input (52a) is connected to the load-and-store unit (14) to receive the operating datum corresponding to a sensor datum (D_SENS) stored in the load-and-store unit (14), the second input (52b) is connected to a reference node (GND) of the electronic processor (10) to acquire the initialization datum (D_INIT), the third input (52c) is connected to the arithmetic-logic unit (32) to receive an ALU datum (D_ALU) generated by the arithmetic-logic unit (32), wherein the input datum multiplexer (52) is configured to transmit to the output (52d) one of the sensor datum (D_SENS), the ALU datum (D_ALU) and the initialization datum (D_INIT), on the basis of the control signal (SEL).
An initialization method of a register bank (50) may be summarized as including, in the initialization mode of the at least one register (60) of the first plurality of registers (60), the steps of: a. receiving, in the initialization mode and through the register bank (50), the initialization datum (D_INIT); b. receiving, in the initialization mode and through the register bank (50), the write enable signal (WR_EN) identifying the enabling of the update of the at least one register (60) to be initialized; c. receiving, in the initialization mode and through the register bank (50), the write address signal (WR_ADDR) identifying an address of the at least one register (60) to be initialized; and d. in response to receiving the write enable signal (WR_EN), storing, through the register bank (50), the initialization datum (D_INIT) in the at least one register (60) to be initialized.
The initialization method may further include performing steps a-d for each register (60) of the first plurality of registers (60) of the register bank (50).
The registers (60) may be of without-reset type, wherein each register (60) comprises a second plurality of memory elements (70) of without-reset type, and wherein the initialization datum (D_INIT) is formed by a number of bits equal to said second plurality, each bit of the initialization datum (D_INIT) being equal to an initialization value (‘0’).
A control method (100) of an electronic processor (10) may be summarized as including the steps of: controlling the electronic processor (10) in a default unknown state (104) up to receiving by the control unit (20) a reset signal (RST) indicative of an initialization request of the registers (60) of the register bank (50); in response (106) to receiving by the control unit (20) the reset signal (RST) and until (110) an initialization completed signal (DONE) is generated by the control unit (20), indicative of the completion of the initialization of the registers (60) of the register bank (50), initializing the registers (60) of the register bank (50) through an initialization method discussed above; in response (110) to generating by the control unit (20) the initialization completed signal (DONE) and until (114) an operation start signal (START) is received by the electronic processor (10), indicative of instruction execution start, controlling the processor (10) in an idle state (112); and in response (114) to receiving by the control unit (20) the operation start signal (START), controlling the processor (10) into an operation execution state (116-124).
The step of controlling the processor (10) in the operation execution state (116-124) may include, in the write mode of at least one register (60) of the first plurality of registers (60): receiving, in the write mode and through the register bank (50), the operating datum (D_SENS; D_ALU); receiving, in the write mode and through the register bank (50), the write enable signal (WR_EN) identifying the enabling of the update of the at least one register (60) to be overwritten; receiving, in the write mode and through the register bank (50), the write address signal (WR_ADDR) identifying the address of the at least one register (60) to be overwritten; and in response to receiving the write enable signal (WR_EN), storing, through the register bank (50), the operating datum (D_SENS; D_ALU) in the at least one register (60) to be overwritten.
A computer program product may be summarized as storable in an electronic processor (10) and designed such that, when executed on the electronic processor (10), the electronic processor (10) becomes configured to perform an initialization method of a register bank (50) of the electronic processor (10), as described above, or a control method of the electronic processor (10), as described above.
In an embodiment, a register bank comprises: a first plurality of without-reset registers; a write input coupled to the first plurality of without-reset registers; a write-enable input coupled to the first plurality of without-reset registers; and a write-address input coupled to the first plurality of without-reset registers. The register bank has a plurality of operating modes including an initialization mode of operation and a write mode of operation. In the initialization mode of operation, the register bank responds to receipt of a write-enable signal on the write-enable input by storing initialization data received on the write input into a register of the first plurality of without-reset registers based on a write-address signal received on the write-address input.
In an embodiment, in the write mode of operation, the register bank responds to receipt of a write-enable signal on the write-enable input by storing operating data received on the write input into a register of the first plurality of without-reset registers based on a write-address signal received on write-address input.
In an embodiment, the register bank comprising: a first read address input; and a first read output, wherein the plurality of operating modes include a read mode of operation, and in the read mode of operation, the register bank responds to receipt of a read-address on the first read address input by generating an output on the first read output based on data stored in a register of the first plurality of without-reset registers corresponding to the read-address on the first read address input.
In an embodiment, in the initialization mode of operation, the register bank sequentially initializes the registers of the first plurality of without-reset registers.
In an embodiment, each register of the first plurality of without-reset registers comprises a plurality of without-reset memory elements.
In an embodiment, the without-reset memory elements comprise without-reset flip-flops.
In an embodiment, the register bank comprises: decoding circuitry coupled to the write-address input and to the write-enable input, wherein the decoding circuitry, in operation, selectively enables registers of the first plurality of without-reset registers based on the write-enable signal on the write-enable input and the write-address signal on write-address input. In an embodiment, the decoding circuitry comprises: an address decoder, which, in operation, decodes the write-address signal on the write-address input; and a plurality of AND logic gates each having a first input coupled to respective outputs of the address decoder and a second input coupled to the write-enable input of the register bank. Each register of the plurality of without-reset registers has a respective register write-enable input coupled an output of a respective AND logic gate of the plurality of AND logic gates.
In an embodiment, an electronic processor comprises a register bank, including: a first plurality of without-reset registers; a write input coupled to the first plurality of without-reset registers; a write-enable input coupled to the first plurality of without-reset registers; and a write-address input coupled to the first plurality of without-reset registers, wherein, the register bank has a plurality of operating modes including an initialization mode of operation and a write mode of operation, and in the initialization mode of operation, the register bank responds to receipt of a write-enable signal on the write-enable input by storing initialization data received on the write input into a register of the first plurality of without-reset registers based on a write-address signal received on the write-address input. The electronic processor includes control circuitry coupled to the register bank, wherein the control circuitry, in operation, generates a control signal, the write-enable signal and the write-address signal. The electronic processor includes a multiplexer having: a plurality of data inputs including: a first data input, which, in operation, receives operating data signals; a second data input, which, in operation, receives initialization data signals; a control input coupled to the control circuitry, wherein, in operation, the control input receives the control signal; and an output coupled to the write input of the register bank, wherein the multiplexer, in operation, couples one of the plurality of data inputs of the multiplexer to the output of the multiplexer based on the control signal.
In an embodiment, the electronic processor comprises: an instruction register having a plurality of memory registers, wherein the instruction register, in operation, stores instructions executable by the electronic processor; load-and-store circuitry (LSU) having a plurality of memory registers, wherein the LSU, in operation, stores operating data; and an arithmetic-logic circuitry (ALU), which, in operation, performs arithmetic operations, wherein, the plurality of data inputs of the multiplexer includes a third data input coupled to the ALU, the first data input of the multiplexer is coupled to the LSU, and the second data input of the multiplexer is coupled to a reference node of the electronic processor.
In an embodiment, the electronic processor comprises: one or more sensors coupled to the LSU, wherein the LSU, in operation, stores data generated by the one or more sensors.
In an embodiment, a method comprises: operating a register bank having a plurality of operational modes in an initialization mode of operation, the plurality of operational modes including the initialization mode of operation and a write mode of operation; and responding to receipt of a write-enable signal by the register bank during the initialization mode of operation by storing initialization data into a register of a plurality of without-reset registers of the register bank based on a write-address received by the register bank.
In an embodiment, the method comprises: operating the register bank in the write mode of operation; and responding to receipt of a write-enable signal by the register bank during the write mode of operation by storing operating data into a register of the plurality of without-reset registers based on a write-address signal received by the register bank.
In an embodiment, the plurality of operational modes includes a read mode of operation, and the method comprises: operating the register bank in the read mode of operation; and responding to receipt of a read-address by the register bank by generating an output based on data stored in a register of the plurality of without-reset registers corresponding to the read-address.
In an embodiment, the method comprises, in the initialization mode of operation, sequentially initializing the registers of the plurality of without-reset registers.
In an embodiment, the method comprises: selectively enabling registers of the plurality of without-reset registers based on the write-enable signal and the received write-address.
In an embodiment, the method comprises: receiving a reset signal; and responding to the reset signal by operating the register bank in the initialization mode of operation.
In an embodiment, a method comprises: operating a processor having a register bank in one of a plurality of operational modes, the plurality of operational modes including a reset mode, a write mode, and a read mode; responding to receipt of a write-enable signal by the register bank during the reset mode of operation by storing initialization data into one or more registers of a plurality of without-reset registers of the register bank based on write-addresses received by the register bank; and responding to receipt of a write-enable signal by the register bank during the write mode of operation by storing operating data into one or more registers of the plurality of without-reset registers of the register bank based on write-addresses received by the register bank.
In an embodiment, the method comprises, in the reset mode of operation, sequentially initializing the registers of the plurality of without-reset registers.
In an embodiment, a non-transitory computer-readable medium's contents cause a processing system to perform a method, the method comprising: operating the processing system in one of a plurality of operational modes, the plurality of operational modes including a reset mode, a write mode, and a read mode; responding to receipt of a write-enable signal by a register bank of the processing system during the reset mode of operation by storing initialization data into one or more registers of a plurality of without-reset registers of the register bank based on write-addresses received by the register bank; and responding to receipt of a write-enable signal by the register bank during the write mode of operation by storing operating data into one or more registers of the plurality of without-reset registers of the register bank based on write-addresses received by the register bank.
In an embodiment, the method comprises, in the reset mode of operation, sequentially initializing the registers of the plurality of without-reset registers.
In an embodiment, the contents comprise instructions executable by the processing system.
Some embodiments may take the form of or comprise computer program products. For example, according to one embodiment there is provided a computer readable medium comprising a computer program adapted to perform one or more of the methods or functions described above. The medium may be a physical storage medium, such as for example a Read Only Memory (ROM) chip, or a disk such as a Digital Versatile Disk (DVD-ROM), Compact Disk (CD-ROM), a hard disk, a memory, a network, or a portable media article to be read by an appropriate drive or via an appropriate connection, including as encoded in one or more barcodes or other related codes stored on one or more such computer-readable mediums and being readable by an appropriate reader device.
Furthermore, in some embodiments, some or all of the methods and/or functionality may be implemented or provided in other manners, such as at least partially in firmware and/or hardware, including, but not limited to, one or more application-specific integrated circuits (ASICs), digital signal processors, discrete circuitry, logic gates, standard integrated circuits, controllers (e.g., by executing appropriate instructions, and including microcontrollers and/or embedded controllers), field-programmable gate arrays (FPGAs), complex programmable logic devices (CPLDs), etc., as well as devices that employ RFID technology, and various combinations thereof.
The various embodiments described above can be combined to provide further embodiments. Aspects of the embodiments can be modified, if necessary to employ concepts of the various patents, applications and publications to provide yet further embodiments.
These and other changes can be made to the embodiments in light of the above-detailed description. In general, in the following claims, the terms used should not be construed to limit the claims to the specific embodiments disclosed in the specification and the claims, but should be construed to include all possible embodiments along with the full scope of equivalents to which such claims are entitled. Accordingly, the claims are not limited by the disclosure.
| Number | Date | Country | Kind |
|---|---|---|---|
| 102023000002409 | Feb 2023 | IT | national |
