Abstract:
A Viterbi decoder which is based on a special instruction set implemented in the processor, enabling it to handle the Viterbi processing with a much lower CPU loading without significantly increasing the hardware complexity. By careful application of appropriate design constraints specific to the SV navigation and analysis of the Viterbi algorithm an optimised architecture can be realised for embedding Viterbi acceleration logic efficiently into a GNSS chipset.

Description:
FIELD OF THE INVENTION 
       [0001]    The present invention concerns a receiver for a Global Navigation Satellite System (GNSS) including a receiver to decode convolution-encoded data. In particular, but not exclusively, embodiments of the present invention relate to a GPL receiver able to decode augmentation data transmitted by geostationary satellites, like WAAS/EGNOS satellites, as well as a GALILEO receiver for convolution-encoded data according to the GALILEO standard. 
       RELATED ART 
       [0002]    In GPS the existing Satellite Based Augmentation System (SBAS) Geosynchronous satellites are operated by different nations are used to provide additional information to augment the GPS position fix quality and integrity available from portable GPS receiver devices. 
         [0003]    Such information provides additional information on atmospheric corrections which can be applied to improve the quality of the fix, and information about the satellite integrity. 
         [0004]    Due to the greater orbital radius, and geo-stationary orbit of the SBAS satellites more complex convolution encoding has been used for the data transfer, this requires more complex decoding capabilities in the receiver, typically a Viterbi decoder, which places an increased processing load on the system. In the case of SBAS implementations Viterbi decoding typically applies to a single SV and it is known to implement it by a software decoder executed by a general-purpose processor. This solution is straightforward, but is sub-optimal as far as speed and power economy are concerned. 
         [0005]    The proposed Galileo system signal will also make use of this convolution encoding mechanism for the data channels on all of the SV&#39;s in the constellation, utilizing the same basic convolution coding technique, however possibly using a different generator polynomial and symbol rates. 
         [0006]    The effect of this new navigation signal format will significantly increase the processing overhead since all Galileo SV&#39;s used in the solution will require the Viterbi decode algorithm to be operated simultaneously, so the load of the Viterbi decoders on system resources becomes very significant. Whilst it is theoretically possible to perform all of this in software the processing overhead and additional memory requirements will place additional cost and power requirements on GNSS navigation solutions which are in direct conflict with the market goals of small size, low power, and low cost. 
         [0007]    One solution to this is to implement the Viterbi decoders in hardware to offload the processing completely from the processor. While this way of doing reduces the load on the main processor, the cost and power are simply moved into a different subsystem. 
         [0008]    There is therefore a need to provide a low-power GNSS receiver able to decode convolutional encoded signals without placing a high load on system resources. The present invention aims moreover to provide a low-power GNSS receiver that can decode convolution-encoding signal faster and using less power than the receivers known in the art. 
       BRIEF SUMMARY OF THE INVENTION 
       [0009]    The goals of the present invention are obtained by the object of the appended claims. In variants of the present invention, this goal is attained by a software Viterbi decoder based on a special instruction set implemented in the processor, enabling it to handle the Viterbi processing with a much lower CPU loading without significantly increasing the hardware complexity. 
         [0010]    By careful application of appropriate design constraints specific to the SV navigation and analysis of the Viterbi algorithm an optimised architecture can be realised for embedding Viterbi acceleration logic efficiently into a GNSS chipset. 
         [0011]    Moreover, by close integration between hardware and software this can be performed by extending the instruction set of a conventional RISC processor without significant increase in system resources. 
     
    
     
       SHORT DESCRIPTION OF THE DRAWINGS 
         [0012]      FIG. 1  represents a trellis state diagram 
           [0013]      FIG. 2  illustrates a lowest-cost path in the diagram of  FIG. 1   
           [0014]      FIG. 3  represents the calculation of the Hamming distance 
           [0015]      FIG. 4  Illustrate a cost distribution 
           [0016]      FIG. 5  illustrates a cumulative state cost diagram 
           [0017]      FIG. 6  shows schematically different data access method in the Viterbi algorithm 
           [0018]      FIG. 7  illustrates a instruction architecture relative to an embodiment of the present invention. 
           [0019]      FIGS. 8 and 9  relate to an implicit addressing of the instruction relative to the present invention. 
           [0020]      FIG. 10  illustrate a sequence of transmitted bits. 
           [0021]      FIGS. 11 and 12  represent a decoding of the sequence of bits of  FIG. 10 . 
           [0022]      FIG. 13  illustrates schematically the operation of a processor with a special instruction set according to an aspect of the invention. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0023]    Viterbi encoding and decoding algorithms are generally known in the art and described in the technical literature. In the following only the aspects specific to GNSS implementation will be discussed. 
         [0024]    Several criteria must be considered in Viterbi implementation: the symbol size, symbol interpretation, generator polynomial and length, and the symbol rate. For GNSS application the constraint length K=7, (memory m=6), meaning that the transmitted symbol is a function of the current data bit and the previous six data bits, the code rate is two, meaning that for each data bit two symbols are transmitted, the symbol rates are generally around 250 or 500 symbols/second, and the generator polynomial may vary. 
         [0025]    Viterbi is a convolutional coding and decoding technique which operates on a path cost table computing the maximum likelihood of being in a particular state based on potential interpretations of the previously received symbols. Since the polynomial is length seven the implementation requires 62 states representing the previous six data bits. 
         [0026]    The convolutional code used produces two bit symbols for each data bit transmitted which is represented as a transition between two states, and has 64 states (K=7), from each state there are two possible next states represented by two potential symbols, and for each state there are two potential symbols which can never be transmitted. The actual symbols transmitted for a data bit are determined by the generator polynomial and are a function of the previous 6 data bits and the bit being transmitted. 
         [0027]    For each data state therefore the symbol is determined by the polynomial, and the states are predictable as follows: If the bit is a “1” the next state is 32+(current_state/2), otherwise it is simply current_state/2, hence no state transition table is required. 
         [0028]    As each symbol is transmitted the representation is thus determined by seven data bits, and when it is received it is interpreted by the decoder based on the polynomial and the previous six data bits. As each symbol is received it is interpreted and awarded a probability value based on its similarity to the potentially valid symbols and used to calculate a probability of a certain symbol sequence interpretation being correct. 
         [0029]    To achieve this the Viterbi decoder keeps a record of the lowest cost path found for all possible states, and for each possible state it records the previously most likely sequence of symbols being received and their cumulative cost. 
         [0030]    Once sufficient symbols have been received the data is decoded by picking the lowest cost state and working back through the history to determine the sequence of data bits that were most likely transmitted to lead to that state. 
         [0031]    The principles of Viterbi encoding and decoding are generally understood by people familiar with convolutional coding mechanism&#39;s and available analysis shows that the overall SNR improvements gained by these schemes benefit from awarding a range of potential values to each symbol, rather than a simple binary decision, and that typically significant gains can be achieved with up to an eight level interpretation for each symbol. 
         [0032]    For K=7 the usual Viterbi decoding algorithms require processing of at least 35 symbols before we can extract the first data bit for the optimum performance, for this processing we need to keep at least two sets of state information representing the cumulative costs of being in a particular state, and for each state we need to keep a record of typically the previous 34 transitions (data bits) leading to that state for optimal decoding performance. 
         [0033]    Given these constraints we can first select appropriate minimal data structures to represent the Viterbi decode states and then optimize these for embedded implementation, giving specific consideration to the HW/SW interaction and the processor subsystem architecture. 
         [0034]    In each potential current state there are two valid state transitions (branches) represented by two symbol encodings, and there are two symbol encodings representing invalid transitions, thus for each state there are only two potential successor states, and two potential predecessor states. These can be represented by the trellis diagram of  FIG. 1 . 
         [0035]    Depending on each potential current state the valid and invalid branches are indicated by different symbols, thus for each state we require to know the two potential next states (which can be calculated trivially) and the appropriate symbols associates with the branches which could also be calculated using dedicated logic, but can more easily be loaded form a table thus making the implementation independent of the polynomial 
         [0036]    Since we are implementing a soft decision decoder we first need to determine a cost factor for all potential symbol pairs weighted according to the strength of the received symbols, and since all valid state transitions for all states have equal probability this weighting is independent of the current state and is only dependant on the received symbol pair and the Hamming distance between the received symbol pair and the actual symbol pair associated with the branch. This means that for each symbol the software must calculate a weighting table associated with the Hamming distance, and this can then be applied to all states and branch cost calculations using a mapping between the Hamming distances and states. 
         [0037]    The basic Viterbi algorithm will thus perform the following sequence of calculations for each symbol pair received, the actual implementations will parallelize these processes to minimize the loads/stores and complex instruction sequences by careful design of the associated data structures and the implementation of custom instructions where appropriate. 
         [0038]    For the received symbol pair calculate a set of four costs associated with the Hamming code between the symbol pairs interpretation and the four possible transmitted symbol pairs. The Hamming cost table is effectively a table of four values representing the cost associated with interpreting the actual received input symbol pair in each possible way, i.e. 00, 01, 10, 11. 
         [0039]    For each potential current state (64 states) calculate the costs of reaching each of the next states (branch cost) for each of the two potential interpretation of the received symbol pair, this is based on the states current cost and the pre-calculated cost table for the received symbol, i.e. for each state there are two potential next states and two transitions with associated costs based on the required symbol pair and its re-interpretation as the symbol associated with the transition. 
         [0040]    For each of the successor states, select the transition into the state with the lowest cost and update the trace history for the state to record the cost of getting to the state and the transition which arrived there (“1” or “0”) representing the transmitted data bit. 
         [0041]    The result is a table of the lowest cost achievable for each state and the path to get there as shown in figure two. 
         [0042]    Finally, once sufficient symbols have been decoded select the state with the lowest cumulative cost and trace back through the transitions into each state to recover the lowest cost data sequence which arrived in that state, this is the Viterbi decoding of the received bit stream. 
         [0043]    It is clear from this that Viterbi decoding is a data intensive operation, and also involves accessing the data in a non sequential order, generally referred to as the Viterbi butterfly due to the pattern formed when the data access order is drawn. 
         [0044]    Generally Viterbi acceleration is performed using a Viterbi Butterfly operation using multiple memories for efficiency, and dedicated hardware performing the well known add-compare-select operation. Although the add-compare-select operation can easily be accelerated and is often supported by custom instructions in a DSP, accelerating this alone does not greatly improve the speed since the operation becomes data access dominated, usually with the effective address calculation taking as much time as the data access itself. 
         [0045]    Typically DSP&#39;s have custom instructions for calculating the addresses and add-compare-select instructions for the path cost calculations 
       Optimization and Data Representation. 
       [0046]    Due to the nature of the convolution algorithm the state transitions are predictable, and can be grouped into partially independent data sets, that is for each pair of potential successor states there are exactly 4 current states which could have led to them, thus an optimum architecture for memory access should be able to operate on this data set independently of all other data sets to minimize memory accesses. 
         [0047]    Since there are two potential current states leading to each potential successor state, and there are two potential symbols associated with any current state it follows that there are a maximum of 128 branches to be calculated. For each symbol pair there are four possible interpretations, thus two bits associated with each potential branch to indicate the corresponding symbol pair, thus we can store the branch cost mapping for eight states (16 branches) in one word. 
         [0048]    For any branch there are four possible symbols, and for each state there are two possible branches, thus the branches must differ by at least one symbol, since the maximum symbol cost is therefore 14. Since the channel is not perfect there will inevitably be symbol errors, hence the reason for the convolutional code being used, there will be cumulative errors over time with a maximum value determined by the block length used. 
         [0049]    Since the maximum difference between a symbol transmitted and received is 14, for all symbols the maximum value for the lowest cost state after N data bits will be less than 8N, depending on the polynomial used. 
         [0050]    For a given data bit transmitted in a given state there are two symbol bits transmitted from a possible four combinations, assume for now that these are binary representations although the principal can be extended to a soft decision. Comparing the received symbol against the transmitted symbol and counting the differences for each possible interpretation we calculate the hamming distance, 0 for the correct interpretation, 1 if one of the symbol bits is incorrect, 2 if both bits are incorrect.  FIG. 3  shows this. 
         [0051]    For each possible state we calculate the potential costs of being in each possible successor state and keep the lowest cost, over time the range of possible state costs expands due to the errors in the signal and the possible interpretations, one of which is always wrong by definition. 
         [0052]    Assuming we have a perfect signal we will see the costs distribution change as shown in  FIG. 4 . 
         [0053]    However, since there are only a finite number of memory bits in the decoder, it follows that if there are K bits, then every state can be reachable in K steps from every previous state, even if it means misinterpreting every received symbol; this allows us to construct the cumulative costs as shown in the diagram of  FIG. 5 . 
         [0054]    For simplicity we assume that there are only two memory bits, hence the triangle on the left shows the maximum distribution of costs for any state  51  derived from the current state SO at time T+2 showing that the a maximum cost that can be obtained in K steps where K is the number of memory bits is, in this case, M=4. In the signal state transition diagram we indicated the presence of noise after state T 1  such that every symbol has at least one error (H=I), then applied the constraints of the two bit memory and masked the potential range of costs for all states based on the worst possible interpretation of the previous two symbols. 
         [0055]    At T 4  all costs are not below the maximum state cost of M=4, so at T 5  we can adjust all new costs by subtracting a common offset, thus constraining the range of the cost results. Thereby the method of the invention includes a step of setting the transition costs to non-negative values in the range 0 to M, where M is the maximum cost that can be obtained in K steps where K is the number of memory bits in the convolutional encoded data. Preferably N bits are allocated per cumulative path cost where (2̂(K+1)*M)−1&lt;2̂N−1. 
         [0056]    For any state Sn the predecessor states are S(2n) and S(2n+1). Let Hn0/1 be the Hamming costs of interpreting the symbol as a 0/1 respectively in state n. 
         [0057]    Let C(N) represent the lowest cumulative path cost of state N, 
         [0058]    Let KT represent the set of C 0  . . . C 63  at time T 
         [0059]    Assuming we have a set of state costs KT 0  at time T 0  and at a future time T 1  we have a set of associated costs KT 1 . It follows that Min(KT 1 )&gt;=Min(KT 0 ) and Max(KT 1 )&lt;=Min(KT 0 )+84. For data recovery to start we care about the index of the smallest member of KTn, but not the actual values of KT it follows that we can constrain the costs KT by normalizing them to some value&lt;=Min(KT). 
         [0060]    Thus we need seven bits to represent the accumulated state transition costs, so for alignment with the CPU architecture it is convenient to store the accumulated costs as eight bit values, this allowing packing the costs for the four possible interpretation of a symbol pair into a 32 bit word. 
         [0061]    To avoid overflow of the accumulated costs it is therefore necessary to scale them when any state approaches overflow, provided we have sufficient range to uniquely represent all values within KT and preserve their ordering. To achieve this each accumulated cost will be represented as an eight bit value, and as costs are accumulated for all state transitions they cannot diverge by more than 84, this enables the cost adjustment to be performed by constraining all values to be between less than 256 which is easily achieved by resetting the MSB of all state costs when the lowest state cost reaches 128 prior to accumulation with the new transition costs. 
         [0062]    Now that data representation has been determined it is desirable to optimize the processing of the data to minimize the overhead of memory accesses. 
         [0063]    The calculation of the branch costs for any state involves calculating the potential costs of the two paths than lead to it Cn= 
         [0064]    Since there are two potential branches into each successor state it is preferable to calculate these transitions simultaneously so that the lowest cost branch can be detected and stored without the need to store intermediate values. 
         [0065]    Viterbi operates using its result as source data for the next iteration, consequently it is necessary to organize the results in the same order as the operands, this implies a linear array of state costs occupying 64 bytes, (16 32 bit words). 
         [0066]    Since we can store four state costs in one word it is desirable to read the word once and process all states within it before discarding it and write the results back directly into the same type of structure, using two copies of the structure and alternating which is the input and output. 
         [0067]    With this organization each word processed produces four new states which are in two groups that do not fit into the same word in the output array, however processing two consecutive source words will produce eight results in two groups where each group fits into a single word, but the two words are not contiguous. 
         [0068]    Thus for the Viterbi operation we need to process eight states as eight groups of two words, and since each state requires 4 bits in the mapping register we can pack the mapping register so that each group also requires one 32 bit register to contain this mapping. 
         [0069]    This fits nicely into an eight iteration loop, processing eight states per loop, where all data required fills a CPU register, each operand is read once per loop, and each result is written one with no partial word updates required, thus memory efficiency is optimized. 
         [0070]    For each new state the lowest cost branch must be recorded, this requires 64 bits which will fit neatly into a pair of 32 bit registers, these will need to be partially updated for each loop iteration and stored to the history or ‘traceback’ table after completion of the loop. 
         [0071]    We also need to calculate the index of the lowest cost state, and detect when all states are above a minimum threshold so that we can adjust them on the next loop iteration, this is easily achieved using a flag to indicate all states are above 128 and masking the MSB on the next iteration. 
         [0072]    During iteration of the loop we need to address the source and result data efficiently, but the addressing is a simple function of the loop index, as are the field to update in the traceback registers, so an ideal extension will include registers for the loop index, addressing, lowest cost state index, and normalization flag.  FIG. 6  shows the different methods in which data can be accessed for the Viterbi loop, in the diagram  61  two source values  56  are used to produce one result  66 , this is inefficient because it does not utilize all the source data. In the case illustrated in diagram  62 , one source operand  65  is used to calculate two costs  66 , but these relate to different states in different words and, in the third diagram  63 , eight states  65  in two words are utilized to compute eight new states  66  in two words, all data is perfectly aligned and no data is wasted. 
         [0073]    Overall this leads to an ideal implementation that requires multiple source and destination registers which cannot be implemented easily using a typical instruction set architecture, as  FIG. 7  below shows. 
         [0074]      FIG. 7  illustrates a typical sequence of operations to calculate 3 results from 4 source variables. The upper diagram shows how these would typically be implemented on a standard 3 operand CPU, where the 3 operands would represent 2 source operands and 1 destination operand. Here it can be seen that the operation must be divided into at least 3 sequential instructions. This is due to the instruction operand format restrictions which do not allow sufficient bits for the encoding of sufficient registers, and also generally would be a limitation of the ability of the register file to accept more than 1 write operation in a cycle. In this encoding all registers are explicitly coded in each opcode and all register exist in the general register file. 
         [0075]    In the lower part the same operation is illustrated using implicit encoding of some of the registers, and the implementation of these special fields as dedicated registers separate to the general purpose register file. 
         [0076]      FIGS. 8 and 9  relate to an aspect of the present invention in which the optimal approach of  FIG. 3  is obtained by making the register addressing implicit in the instructions. 
         [0077]    The diagram of  FIG. 9  shows the actual function implemented by the Viterbi instructions. In this figure a pair of previous states (Sa, Sb) are selected corresponding to the pair of potential predecessor states for the new state Sc. The corresponding costs of interpreting the new symbol in such a way that it would lead to the new state are selected by multiplexors ( 901 ) and added to the corresponding costs of these previous states by adders ( 902 ) producing a pair of potential costs( 903 ) of arriving at state Sc. These costs are compared and the lowest costs predecessor state selected by selector ( 904 ), the corresponding bit transition is indicated ( 905 ) and the corresponding cost is output ( 906 ). This corresponding costs will potentially increase for each state as each new symbol is applied however as the state memory is limited to a finite number of states (in this case 6 states) there is a set of values at any instance corresponding to the costs of all states where the range between the minimum and maximum values is limited by the maximum state transition costs and the maximum state memory. In this example this is less than 64, so to prevent the state costs growing indefinitely an indication is output when any state cost exceeds 128 ( 907 ). 
         [0078]    The indication that at least one of the previous state costs was &gt;128 ( 908 ) is supplied to the normalize block  909  and this normalizes the state cost by subtracting 64, this guarantees that all state costs will remain within a finite integer range. 
         [0079]    The resulting new state cost  910  is output from the instruction and also used by the minimum cost block  911 . The purpose of this block is to monitor all state costs calculated during a new symbol processing and determine the lowest costs of all the resulting set of new state costs. 
         [0080]    Once the transition that led to a state has been determined the new cost for that state is calculated and the state cost table updated 
         [0081]    New symbol is supplied, each of the associated costs of interpreting the symbol as a 1 or 0 is selected by multiplexors  901 , these costs are added to the previous symbol costs in adders  902  producing a pair of costs  903  associated with the 2 possible interpretations of the symbol. 
         [0082]    Since several of the results and control variables are less than 32 bits in length these can be merged into sub-fields of a single 32 bit core register. 
         [0083]    To enable operation of the instruction set extension in multiple pre-emptive tasks it is also necessary to save these registers and any status, this is further simplified if these status flags are also merged into the same control register. 
         [0084]    Once sufficient symbols have been processed it is necessary to perform a traceback operation to determine the sequence of branches leading to the current state. This is a relatively simple operation but again involves significant address calculation, bit manipulation, and data load operations. Again these can be efficiently implemented using a dedicated instruction to perform each traceback step and dedicated registers for the addressing of the traceback history. 
         [0085]    Consider the sequence of bits transmitted in the trellis diagram of  FIG. 10 . In this encoding Rx and Ry represent 2 of the 4 required source operands which exist in special registers outside of the general purpose register file, and Rp, Rq represent 2 of the results which are saved in special registers outside of the register file and may therefore be sub-fields of a register and may even overlap with Rx and Ry. 
         [0086]    After transmitting the data the receiver calculates costs and traceback and achieves the cost and traceback history of  FIG. 2 . 
         [0087]    If the traceback starts at T=6 and finds state  10  to be the lowest cost state, the receiver decodes the sequence 101101, which is in the reverse order that data was transmitted and then needs to be reversed as in  FIG. 11   
         [0088]    After receiving another symbol and starting again from the lowest cost path which assume is state “10” again, the receiver now decodes 1000101, as shown in  FIG. 12 ; clearly after a few symbols the paths converged and it was not necessary to trace back further than state T=3 
         [0089]    During traceback the path will often not change significantly after each new symbol is added, apart from being offset by 1 bit, it is also apparent that once the new traceback history converges on a state in the previous history they will never diverge again, consequently it is possible to reduce the effort spent in traceback by detecting convergence with the previous traceback operation. In SW this is a complex task involving masking and rotation of bit fields prior to comparison, the overhead of this adds sufficient extra cycles to each iteration that its benefits are negated, however using dedicated hardware to access these bit field using the traceback index to select the field means that it can be performed transparently and greatly reduce the power and cycles consumed by the traceback operation. 
         [0090]    Once a traceback has been performed the oldest data bits are extracted usually 1 byte at a time, however during the initial phase typically a synchronization pattern is being searched for and bit alignment is not known, this further complicates the initial traceback operation for SW but again can be optimized by adding specific instructions to extract the oldest bits in the correct order aligned into a CPU register, and a separate instruction to “consume” a number of bits when they have been used, in this way bytes can be extracted and compared discarding one bit at a time until the synchronization has been detected, thereafter consuming bits at the rate they are processed by the application. 
         [0091]    As a final function, each of the Viterbi process requires a data structure containing the Viterbi status, traceback history, traceback table, and state cost tables. These need to be separated for each channel and therefore all addresses will require some offset. This can again be hidden from the processor by implementing a Viterbi data structure base address as part of the Viterbi control/status word. 
         [0092]    In order to minimize impact on other processes it is preferable that the implicit Viterbi registers be in addition to the core cpu registers, and that the SW be able to efficiently save their state when context switching, however most processes will not use these registers therefore they do not need to save them. 
         [0093]    In order to minimize the number of times that they are saved, without the OS needing to know for each process whether they are required, additional status bits can be added to the Viterbi status/control register to indicate when the Viterbi block is in use, these may be automatically set/cleared by the Viterbi instructions according to the status of the process, in this way context switching can test these flags to determine if there is any context to be saved, in this way they do not take valuable stack space from processes that do not use the functionality and they are not stored if they are not actively in use thus the Viterbi can be efficiently used in a multi-threaded environment. 
         [0094]    According to another aspect of the invention, the present invention relates to a processor optimized for the decoding of convolutional encoded data according to the methods of the invention described above. The processor is arranged to extend the register set of the processor with phantom registers which do not physically have any register storage, but return addresses for the source and destination state cost operands based on a core register field used as the loop control register and a state register field indicating the current state cost set allocation and a base address for the data structures and selecting the mapping of current and next state tables. 
         [0095]    With reference to  FIG. 13 , the operation of the processor of the invention is controlled by instruction stored in memory in the form of single words (or opcodes) comprising multiple fields. In the illustrated example, for example, opcode  147  illustrates a typical 3 operand instruction consisting of two source operands  148 , an instruction field  150  and a destination register address ( 149 ). 
         [0096]    Operands OP 1 , OP 2  are used to select the two source operands from the register file  141  by means of the multiplexor  142  that are passed to the ALU  146 , The output of the ALU is typically written back into the register file  141  using address  149  through a path not illustrated. 
         [0097]    In the illustrated example the register file  141  comprises 32 locations or registers R 0 -R 31 , but this is not a limitation of the invention. It must be understood also that  FIG. 14  is a simplified functional diagram meant to illustrate the logical data flow in the processor and it does not limit the structure of the processor of the invention. In particular the invention also includes pipelined architectures, in which these operations are performed at different times. 
         [0098]    According to the invention, the opcode  147  can include addresses to “phantom registers”  143  which do not correspond to a separate storage space in the register file,  141 , but rather are a logical function of the values 
         [0099]    In the registers R 0 -R 31  and/or additional values  151 ,  152  internal or external to the CPU. When addressed by an instruction, the phantom register or registers return a value calculated from signals and/or registers not explicitly addressed by the instruction. 
         [0100]    Opcode  147  stores the operand addresses  148  with 6 bits each, in this example, thus giving the ability to address more operands than the thirty-two physical registers. The phantom registers are accessible, for example, by encoding one of the addresses that has no counterpart in the register file  141 . 
         [0101]    Whilst the diagram of  FIG. 14  shows the typical format and processing of an arithmetic instruction, a CPU has typically also non-arithmetic instruction, for example load/store instruction. According to the invention, the operand of these instructions could be a phantom register  143  as well. It is also intended that the invention may include a plurality of phantom registers, and that they might interact with each other, for example with some phantom registers depending, among others, from values of other phantom registers. The invention also includes the case in which some phantom registers are related to independent memory elements, and that they may retain a status such as additional hidden registers. 
         [0102]    Advantageously, the phantom registers are arranged to return addresses for the source and destination state cost operands based on a core register field used as the loop control register and a state register field indicating the current state cost set allocation and a base address for the data structures and selecting the mapping of current and next state tables.