Abstract:
One embodiment of the present invention provides a processor that is configured to execute load-swapped-partial instructions. An instruction fetch unit within the processor is configured to fetch the load-swapped-partial instruction to be executed. Note that the load-swapped-partial instruction specifies a source address in a memory, which is possibly an unaligned address. Furthermore, an execution unit within the processor is configured to execute the load-swapped-partial instruction. This involves loading a partial-vector-sized datum from a naturally-aligned memory region encompassing the source address. While loading the partial-vector-sized datum, bytes of the partial-vector-sized datum are rotated to cause the byte at the specified source address to reside at the least-significant byte position within the partial-vector-sized datum for a little-endian memory transaction, or to cause the byte to be positioned at the most-significant byte position within the partial-vector-sized datum for a big-endian memory transaction.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is a continuation-in-part of co-pending U.S. patent application Ser. No. 11/591,804 filed on Nov. 1, 2006, entitled “Instructions for Efficiently Accessing Unaligned Vectors,” the entire contents of which are herein incorporated by reference. 
     
    
     BACKGROUND 
       [0002]    1. Field of the Invention 
         [0003]    The present invention relates to techniques for improving computer system performance. More specifically, the present invention relates to instructions for efficiently accessing a partial vector located at an arbitrarily aligned memory address. 
         [0004]    2. Related Art 
         [0005]    In Single-Instruction-Multiple-Data (SIMD)-vector processors, accessing a vector in memory that is not naturally aligned (i.e., which resides at an address that is not an integer multiple of the vector length in bytes) is an inefficient multi-step process, which is complicated by the need to handle edge-cases without producing spurious virtual-memory faults. For example, see  FIG. 1A , which presents a block diagram illustrating an existing memory  100  that includes both an aligned vector  102  and an unaligned vector  104 . 
         [0006]    Referring to  FIG. 1B , which presents a block diagram illustrating an existing alignment process, conventional practice for manipulating unaligned vectors is to process the beginning  108  and ending portions  110  of the unaligned vectors separately, thereby allowing the large inner portion of the vectors to be processed as a naturally aligned vector  112 , which is much faster. However, this is a complicated process and it is not always possible to perform it in all systems and applications. 
         [0007]    Many processors that support vector data types provide memory-access instructions that automatically handle misalignment by loading vector data from unaligned addresses into vector registers or storing data from vector registers into unaligned addresses. For example,  FIG. 2B  presents a block diagram of alignment circuitry  204  illustrating how an unaligned vector which spans two or more registers is aligned to fit into a single register. However, this approach places the burden of aligning data on the processor hardware, which must perform multiple aligned memory accesses and must assemble elements from each access into a coherent vector. Note that this hardware-based technique requires additional hardware and is consequently more expensive. Furthermore, this technique is inefficient for streaming because it discards good data during the streaming process. 
         [0008]    Explicitly handling alignment in software (rather than in hardware) is even less efficient because it involves executing multiple load-store and bit-manipulation instructions for each vector of data that is processed. 
         [0009]    It is also common for some types of code, such as mathematical kernels, to be implemented in several variants, each handling a different alignment case as efficiently as possible. This approach is time-consuming and error-prone, and also increases the debugging effort and lengthens the development process. Furthermore, the variants which handle unaligned data are less efficient than the aligned variants. This difference in efficiency can cause performance variations that depend on the alignment of the data. 
         [0010]    Hence what is needed is a technique for efficiently accessing unaligned vectors without the above-described problems. 
       SUMMARY 
       [0011]    One embodiment of the present invention provides a processor that is configured to execute load-swapped-partial instructions. An instruction fetch unit within the processor is configured to fetch the load-swapped-partial instruction to be executed. Note that the load-swapped-partial instruction specifies a source address in a memory, which is possibly an unaligned address. Furthermore, an execution unit within the processor is configured to execute the load-swapped-partial instruction. This involves loading a first partial-vector-sized datum from a first naturally-aligned memory region encompassing the source address. While loading the first partial-vector-sized datum, bytes of the first partial-vector-sized datum are rotated to cause the byte at the specified source address to reside at the least-significant byte position within the first partial-vector-sized datum for a little-endian memory transaction, or to cause the byte at the specified source address to be positioned at the most-significant byte position within the first partial-vector-sized datum for a big-endian memory transaction. 
         [0012]    In some embodiments, the first partial-vector-sized datum is loaded via a load-store path between a cache memory and a register. Note that a ratio of a first number of bits in a vector register to a second number of bits in the load-store path may be rounded up to a nearest integer M. Furthermore, in some embodiments the load-swapped-partial instruction rotates bytes of the first partial-vector-sized datum as the first partial-vector-sized datum passes through the load-store path. 
         [0013]    In some embodiments, the load-swapped-partial instruction is a load-swapped-partial-and-duplicate instruction which copies the first partial-vector-sized datum to M register locations. 
         [0014]    In some embodiments, the load-swapped-partial instruction is a load-swapped-partial-and-shift instruction which shifts register data to make room for the first partial-vector-sized datum. 
         [0015]    In some embodiments, the load-swapped-partial instruction rotates bytes of the first partial-vector-sized datum N positions in a direction determined by the endian-ness of the memory transaction. Note that N is equivalent to the source address specified by the instruction modulo the first partial-vector-sized datum length in bytes. Furthermore, the first partial-vector-sized datum is rotated to the left N byte positions for a big-endian memory transaction, or the first partial-vector-sized datum is rotated to the right N byte positions in the case of little-endian memory transactions. 
         [0016]    In another embodiment of the present invention the processor is configured to execute store-swapped-partial instructions. In doing so, the instruction fetch unit within the processor is configured to fetch the store-swapped-partial instruction to be executed. Note that the store-swapped-partial instruction specifies a destination address in the memory, which is possibly an unaligned address. Furthermore, the execution unit within the processor is configured to execute the store-swapped-partial instruction. This involves storing a second partial-vector-sized datum in a second naturally-aligned memory region encompassing the destination address. While storing the second partial-vector-sized datum, bytes of the second partial-vector-sized datum are rotated to cause the least significant byte of the second partial-vector-sized datum to be stored at the specified destination address on the little-endian processor, or to cause the most significant byte of the second partial-vector-sized datum to be stored at the specified destination address on the big-endian processor, or to cause the specified byte to be stored to the destination address in the case of the endian-specific store-swapped-partial variant. 
         [0017]    In some embodiments, the second partial-vector-sized datum is stored via the load-store path. 
         [0018]    In some embodiments, where the store-swapped-partial instruction is a store-swapped-leading-partial instruction, storing the second partial-vector-sized datum to the destination address involves storing a whole partial-vector-sized datum to the destination address if the destination address is naturally aligned. However, if the destination address is unaligned, storing the second partial-vector-sized datum to the destination address may involve storing a portion of the second partial-vector-sized datum to the destination address. 
         [0019]    In some embodiments, where the store-swapped-partial instruction is a store-swapped-trailing-partial instruction, storing the second partial-vector-sized datum to the destination address involves storing nothing to the destination address if the destination address is aligned with memory. However, if the destination address is unaligned, storing the second partial-vector-sized datum to the destination address may involve storing a portion of the second partial-vector-sized datum to the destination address. 
         [0020]    In some embodiments, the store-swapped-partial instruction rotates bytes of the second partial-vector-sized datum N positions in a direction determined by the endian-ness of the memory transaction. Note that N is equivalent to the destination address specified by the instruction modulo the second partial-vector-sized datum length in bytes. Furthermore, the second partial-vector-sized datum is rotated to the left N byte positions for a big-endian memory transaction, or the second partial-vector-sized datum is rotated to the right N byte positions in the case of little-endian memory transactions. 
         [0021]    In some embodiments, the store-swapped-partial instruction rotates bytes of the second partial-vector-sized datum as the second partial-vector-sized datum passes through the load-store path. 
         [0022]    In another embodiment of the present invention the processor is configured to execute load-swapped-control-vector-partial instructions. In doing so, the instruction fetch unit within the processor is configured to fetch the load-swapped-control-vector-partial instruction to be executed. Note that the load-swapped-control-vector-partial instruction specifies a target address in the memory, which is possibly an unaligned address. Furthermore, the execution unit within the processor is configured to execute the load-swapped-control-vector-partial instruction. This involves determining a value N, wherein N is the specified target address modulo a length in bytes of a third partial-vector-sized datum, and constructing a control vector where N elements in the control vector are set to a given polarity, and the remaining elements of the vector are set to the opposite polarity. 
         [0023]    In some embodiments, the N elements in the control vector are the N most-significant elements in the partial-vector-sized datum. However, in other embodiments the N elements in the control vector are the N least-significant elements in the partial-vector-sized datum. 
         [0024]    Another embodiment of the invention provides a computer system that includes the processor and the memory. The computer system is configured to execute the load-swapped-partial instruction, the store-swapped-partial instruction, and/or the load-swapped-control-vector-partial instruction. 
     
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         [0025]      FIG. 1A  is a block diagram illustrating a memory. 
           [0026]      FIG. 1B  is a block diagram illustrating an alignment process. 
           [0027]      FIG. 2A  is a block diagram illustrating a computer system in accordance with an embodiment of the present invention. 
           [0028]      FIG. 2B  is a block diagram illustrating alignment circuitry in accordance with an embodiment of the present invention. 
           [0029]      FIG. 3  is a flow chart illustrating a process for moving an unaligned vector in accordance with an embodiment of the present invention. 
           [0030]      FIG. 4  illustrates an exemplary vector-move operation in accordance with an embodiment of the present invention. 
           [0031]      FIG. 5  illustrates an exemplary vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. 
           [0032]      FIG. 6  is a flow chart illustrating a process for moving an unaligned partial vector in accordance with an embodiment of the present invention. 
           [0033]      FIG. 7A  illustrates an exemplary partial-vector-move operation in accordance with an embodiment of the present invention. 
           [0034]      FIG. 7B  illustrates an exemplary partial-vector-move operation in accordance with an embodiment of the present invention. 
           [0035]      FIG. 8A  illustrates an exemplary partial-vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. 
           [0036]      FIG. 8B  illustrates an exemplary partial-vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. 
       
    
    
       [0037]    Table 1 provides exemplary code for a vector-move operation in accordance with an embodiment of the present invention. 
         [0038]    Table 2 provides exemplary code for a vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. 
         [0039]    Table 3 provides exemplary code for a partial-vector-move operation in accordance with an embodiment of the present invention. 
         [0040]    Table 4 provides exemplary code for a partial-vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. 
         [0041]    Note that like reference numerals refer to corresponding parts throughout the drawings. 
       DETAILED DESCRIPTION 
       [0042]    The following description is presented to enable any person skilled in the art to make and use the invention, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present invention. Thus, the present invention is not limited to the embodiments shown, but is to be accorded the widest scope consistent with the claims. 
         [0043]    The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. This includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer readable media now known or later developed. 
       Computer System 
       [0044]      FIG. 2A  presents a block diagram of a computer system  200  in accordance with an embodiment of the present invention. Computer system  200  can generally include any type of computer system, including, but not limited to, a computer system based on a microprocessor, a mainframe computer, a digital signal processor, a portable computing device, a personal organizer, a device controller, a cell phone or a computational engine within an appliance. 
         [0045]    Computer system  200  includes a central-processing unit (CPU) core  201  which performs computational operations. While performing these computational operations, CPU core  201  operates on data items retrieved from cache memory  202 , which is coupled to a memory subsystem (not illustrated). In one embodiment of the present invention, cache memory  202  is a Level-One (L 1 ) data cache which communicates with a memory subsystem that includes a Level-Two (L 2 ) unified instruction/data cache and a main memory. 
         [0046]    CPU core  201  includes a register file  206  which holds operands which are processed by functional units within CPU core  201 . 
         [0047]    CPU core  201  additionally includes alignment circuitry  204  which is located along a load-store path  203  between cache memory  202  and register file  206 . This alignment circuitry  204  performs “byte-swapping operations” to facilitate performing “load-swapped” instructions (which are referred to as load-partial instructions and/or load-swapped-partial instructions) and “store-swapped” instructions (which are referred to as store-partial instructions and/or store-swapped-partial instructions), which are described in more detail below. 
         [0048]    As illustrated in  FIG. 2B , in one embodiment of the present invention the alignment circuitry  204  includes a number of multiplexers  231 - 238 . During operation, the alignment circuitry  204  illustrated in  FIG. 2B  receives a number of bytes  221 - 228  on load-store path  203  ( FIG. 2   a ) and then swaps the bytes using multiplexers  231 - 238  to form a swapped set of bytes  241 - 248 . This swapping process is also described in more detail below. 
         [0049]    Note that while the computer system  200  ( FIG. 2A ) and the alignment circuitry  204  are illustrated as having a number of components in a given configuration, in other embodiments the computer system  200  ( FIG. 2A ) and the alignment circuitry  204  may include fewer components or additional components, two or more components may be combined into a single component, and/or a position of one or more components may be changed. 
       The Load-Swapped-Control-Vector Instruction 
       [0050]      FIG. 3  presents a flow chart illustrating a process for moving an unaligned vector in accordance with an embodiment of the present invention. During this process, the system uses a load-swapped-control-vector instruction to construct a control vector containing predicate elements to control the vector-select instructions ( 302 ). 
         [0051]    Upon receiving the load-swapped-control-vector instruction along with a target address (such as source address or a destination address) of arbitrary alignment, the processor takes the target address and computes a control vector of predicate elements (true/false) based on the target address, and then stores this control vector in a register. The instruction evaluates the target address with respect to the naturally aligned address less than or equal to the target address and the difference between the target address and the naturally aligned address (N) is used to set the predicate elements. On a little-endian processor, predicate elements corresponding to the N least significant bytes of the control vector are set to a given polarity, and predicate elements corresponding to the remaining bytes of the control vector are set to the opposite polarity. On a big-endian processor, predicate elements corresponding to the N most significant bytes of the control vector are set to a given polarity, and predicate elements corresponding to the remaining bytes of the control vector are set to the opposite polarity. This control vector may be used by subsequent “vector-select” instructions or logical operations to merge individual bytes from multiple vectors into a single result vector. 
       The Load-Swapped Instruction 
       [0052]    The load-swapped instruction is used to load a vector into registers ( 304 ). Upon receiving a load-swapped instruction, the processor loads a vector encompassing the source address from a naturally-aligned memory address into a register and in doing so rotates bytes of the vector, so that the byte at the source address resides in the least significant byte position of the register on a little-endian processor, or in the most-significant byte position in the vector for a big-endian processor. More specifically, the load-swapped instruction takes a source address of arbitrary alignment and loads a vector-sized datum from the nearest naturally aligned address that is less-than-or-equal-to the source address provided, i.e., 
         [0053]    naturally_aligned_address=(source_address-N); where N=(source_address mod vector_length_in_bytes). 
         [0000]    During the Load-Swapped operation, the processor hardware rotates bytes through the vector to affect a possible transformation: on a little-endian processor, bytes are rotated to the right N positions, while on a big-endian processor, bytes are rotated left N positions. Equivalently, bytes may be rotated in the opposite direction by (vector_length_in_bytes—N) positions. These transformations are functionally equivalent to swapping data such that the bytes residing at addresses lower than the source address are swapped, as a set, with the set of bytes residing at addresses greater than or equal to the source address. 
         [0054]    The system may optionally employ vector-select instructions to repartition the vector between the registers to create a vector containing the data from the possibly unaligned address above. Note that each vector-select instruction selects between bytes of input registers containing the vector ( 306 ) using a control vector. The system may then optionally perform one or more operations on the vector ( 308 ). 
         [0055]    Furthermore, the system may then optionally employ vector-select instructions to repartition the vector between the registers in a manner which is consistent with using a later store-swapped instruction to store the vector to a memory address or arbitrary alignment. Note that each vector-select instruction selects between bytes of input registers containing the vector ( 310 ). 
       The Store-Swapped Instruction 
       [0056]    The store-swapped instruction is used to store a vector register containing the vector to the destination address. Note that each store-swapped instruction stores a whole vector from a register into memory and in doing so rotates bytes of the vector, so that the least significant byte of the vector is stored to the destination address on a little-endian processor, or so that the most-significant byte of the vector is stored to the destination address on in a big-endian processor ( 312 ). More specifically, upon receiving a store-swapped instruction, the processor takes a vector register, and a destination address of arbitrary alignment, and stores the vector from the register into the nearest naturally-aligned memory address less than or equal to the destination address, i.e., 
         [0057]    naturally_aligned_address=(destination_address-N); where N=(destination_address mod vector_length_in_bytes). 
         [0000]    During the store-swapped operation, the processor hardware rotates bytes through the vector to affect a possible transformation: on a little-endian processor, bytes are rotated to the left N positions, while on a big-endian processor, bytes are rotated right N positions. Equivalently, bytes may be rotated in the opposite direction by (vector_length_in_bytes-N) positions. These transformations are functionally equivalent to swapping data such that the bytes residing at addresses lower than the source address are swapped, as a set, with the set of bytes residing at addresses greater than or equal to the source address. 
         [0058]    If the destination address is unaligned, a “store-swapped-leading instruction” and a “store-swapped-trailing instruction” can be used to store partial vectors at the beginning and the end of a range of consecutive vectors. 
         [0059]    Upon receiving a store-swapped-leading instruction, the processor stores a partial vector, swapped in the manner described above, to the destination address. The amount of data stored is dependent upon the destination address. Data is stored into the memory ranging from the destination address until one-byte before the next naturally aligned address boundary, inclusive (N-bytes). On a little-endian processor, the N least-significant bytes of the vector are stored. On a big-endian processor, the N most-significant bytes of the vector are stored to the destination address. 
         [0060]    Similarly, upon receiving a store-swapped-trailing instruction, the processor stores a partial vector swapped in the manner described above, to the nearest naturally aligned address less than or equal to the destination address. The amount of data stored is dependent upon the destination address. Data is stored into the memory ranging from the nearest naturally-aligned address which is less than or equal to the destination address until one-byte before the destination address, inclusive (N-bytes). On a little-endian processor, the N most-significant bytes of the vector are stored. On a big-endian processor, the N least-significant bytes of the vector are stored to the nearest naturally aligned address less than or equal to the destination address. The processor may optionally store no data if the destination address is naturally aligned. 
         [0061]    As described further below, note that the above-described embodiment of the present invention can leverage existing hardware found in most processors for reading-from and writing-to the data cache(s). Such circuits exist to load data types shorter than the length of a cache-line, which is the typical case for all data types of a given processor. Moreover, since the load-swapped and store-swapped instructions only read/write data corresponding to a single naturally aligned address, there is no need to correlate multiple memory-read accesses in hardware. Also note that in some embodiments of the process there may be additional or fewer operations, an order of the operations may be changed, and/or two or more operations may be combined into a single operation. 
         [0000]    
       
         
               
               
             
           
               
                   
                 TABLE 1 
               
               
                   
                   
               
             
             
               
                   
                 R = Load_Swapped_Control_Vector(source_ptr); 
               
               
                   
                 W = Load_Swapped_Control_Vector(dest_ptr); 
               
               
                   
                 A = Load_Swapped(source_ptr++); 
               
               
                   
                 B = Load_Swapped(source_ptr++); 
               
               
                   
                 C = Load_Swapped(source_ptr++) ; 
               
               
                   
                 if (unaligned) 
               
               
                   
                   D = LoadSwapped(source_ptr++) 
               
               
                   
                 J = Vector_Select(R,A,B); // compose vectors from swapped data 
               
               
                   
                  K = Vector_Select(R,B,C); 
               
               
                   
                 L = Vector_Select(R,C,D); 
               
               
                   
                 // J, K, and L are 3 consecutive vectors of data from an unaligned 
               
               
                   
                 source address 
               
               
                   
                 M = Vector_Select(W,K,J); // decompose into swapped vectors 
               
               
                   
                 N = Vector_Select(W,L,K); 
               
               
                   
                 Store_Swapped_Leading(J,dest_ptr++); 
               
               
                   
                 Store_Swapped(M,dest_ptr++); 
               
               
                   
                 Store_Swapped(N,dest_ptr++); 
               
               
                   
                 if (unaligned) 
               
               
                   
                   Store_Swapped_Trailing(L,dest_ptr); 
               
               
                   
                   
               
             
          
         
       
     
       Example 
       [0062]    Table 1 illustrates how alignment-agnostic vector code can be written to perform a vector-move operation in accordance with an embodiment of the present invention. This example performs a vector-move operation for arbitrarily-aligned source and destination pointers on a little-endian processor. Note that in this example, there are two vector-select operations per move. ( FIG. 4  graphically illustrates the how the move operation is accomplished.) 
       Example which does not Construct an Aligned Vector 
       [0063]    Table 2 illustrates how alignment-agnostic vector code can be written to perform a vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. This example similarly performs a data-move operation for arbitrarily-aligned source and destination pointers on a little-endian processor. However, in this example, only a single vector-select operation is performed at the cost of never forming a proper vector in the processor registers. Because a proper vector is never formed in the registers, the system can only perform at limited set of operations on the vector during the moving process. More specifically, the system can only perform operations on the vector which do not require interactions between different byte positions in the vector ( FIG. 5  graphically illustrates the how this move operation is accomplished.) 
         [0000]    
       
         
               
               
             
           
               
                   
                 TABLE 2 
               
               
                   
                   
               
             
             
               
                   
                 R = Load_Swapped_Control_Vector(source_ptr); 
               
               
                   
                 W = Load_Swapped_Control_Vector(dest_ptr); 
               
               
                   
                 X = R {circumflex over ( )} W; 
               
               
                   
                 A = Load_Swapped(source_ptr++); 
               
               
                   
                 B = Load_Swapped(source_ptr++); 
               
               
                   
                 C = Load_Swapped(source_ptr++); 
               
               
                   
                 D = Load_Swapped(source_ptr++); 
               
               
                   
                 J = Vector_Select(X,B,A); 
               
               
                   
                 K = Vector_Select(X,C,B); 
               
               
                   
                 L = Vector_Select(X,D,C); 
               
               
                   
                 Store_Swapped_Leading(A,dest_ptr++); 
               
               
                   
                 StoreSwapped(J,dest_ptr++); 
               
               
                   
                 StoreSwapped(K,dest_ptr++); 
               
               
                   
                 Store_Swapped_Trailing(L,dest_ptr); 
               
               
                   
                   
               
             
          
         
       
     
       The Load-Swapped-Control-Vector-Partial Instruction 
       [0064]    Modified versions of the previously described techniques may also be applied to partial vectors or partial-vector-sized datums, which may be aligned or unaligned. For example, a portion of a vector may be loaded from or stored to cache memory in chunks. This may be useful when the number of bits in a full vector register (i.e., the full width of the register) is larger than number of bits or bandwidth of the load-store path coupling cache memory and the register (i.e., the width of the load/store path). In particular, by using load-swapped-partial and store-swapped-partial instructions described below, it may not be necessary to correlate multiple memory-read accesses in hardware. 
         [0065]      FIG. 6  presents a flow chart illustrating a process for moving an unaligned partial vector or partial-vector-sized datum in accordance with an embodiment of the present invention. During this process, the system first uses a load-swapped-control-vector-partial instruction to construct a control vector containing predicate elements to control the vector-select instructions ( 602 ). 
         [0066]    Upon receiving the load-swapped-control-partial vector instruction along with a target address (such as a source address or a destination address) of arbitrary alignment, the processor takes the target address and computes a control vector of predicate elements (true/false) based on the target address, and then stores this control vector in a register. Note that the process may use the control vector and subsequent instructions to merge individual bytes from multiple vectors into a single result vector. 
         [0067]    Note that the target address modulo the partial-vector length in bytes (denoted as N) and the length in bytes of the partial-vector-sized datum divisible evenly into the vector size in bytes (denoted as M) are used to set the predicate elements. On a little-endian processor, predicate elements corresponding to the N most-significant bytes of the control vector are set to a given polarity and the remainder elements (modulo M) are set to the opposite polarity. This pattern is repeated while inverting the polarity of the predicate elements over the remainder of the full vector size. On a big-endian processor, predicate elements corresponding to the N least-significant bytes of the control vector are set to a given polarity and the remainder elements (modulo Al) are set to the opposite polarity. Once again, this pattern is repeated while inverting the polarity of the predicate elements over the remainder of the full vector size. 
       The Load-Swapped-Partial Instruction 
       [0068]    The load-swapped-partial instruction is used to load a partial-vector-sized datum into registers ( 604 ). Upon receiving a load-swapped-partial instruction, the processor loads a partial-vector-sized datum encompassing the source address from a naturally-aligned memory address into a register and in doing so rotates bytes of the partial-vector-sized datum. In particular, the byte at the source address resides in the least significant byte position of the register on a little-endian processor, or in the most-significant byte position in the register for a big-endian processor. More specifically, the load-swapped-partial instruction takes a source address of arbitrary alignment and loads a partial-vector-sized datum from the nearest naturally aligned address that is less-than-or-equal-to the source address provided, i.e., 
         [0069]    naturally_aligned_address=(source_address-N); where N=(source_address mod partial_vector_length_in_bytes). 
         [0070]    During the Load-Swapped-Partial operation, the processor hardware rotates bytes through the partial-vector-sized datum to affect a possible transformation: on a little-endian processor, bytes are rotated to the right N positions until the byte at the source address comes to the least-significant end of the partial-vector-sized datum, while on a big-endian processor, bytes are rotated left N positions until the byte at the source address comes to the most-significant end of the partial-vector-sized datum. The remaining bytes of the full vector are unaffected by this operation. Equivalently, bytes may be rotated in the opposite direction by (vector_length_in_bytes-N) positions. These transformations are functionally equivalent to swapping data such that the bytes residing at addresses lower than the source address are swapped, as a set, with the set of bytes residing at addresses greater than or equal to the source address. 
         [0071]    The system may optionally employ vector-select instructions to repartition the partial-vector-sized datum between the registers to create a vector containing the data from the possibly unaligned address above. Note that each vector-select instruction may select between bytes of input registers containing the partial-vector-sized datum ( 606 ) using a control vector. The system may then optionally perform one or more operations on the partial-vector-sized datum ( 608 ). 
         [0072]    Furthermore, the system may then optionally employ vector-select instructions to repartition the partial-vector-sized datum between the registers in a manner which is consistent with using a later store-swapped-partial instruction to store the partial-vector-sized datum to a memory address of arbitrary alignment. Note that each vector-select instruction may select between bytes of input registers containing the partial-vector-sized datum ( 610 ). 
         [0073]    Note that the Load-Swapped-Partial operation has a number of variations, such as a load-swapped-partial-and-shift instruction, a load-swapped-partial-after-swap instruction, and/or a load-swapped-partial-and-duplicate instruction. In the load-swapped-partial-and-shift instruction rather than overwriting the partial-vector-sized datum in the vector register with the data being loaded, at least the partial-vector-sized datum is relocated to another part of the register. In the load-swapped-partial-after instruction, the high and low partial-vector-sized datums are swapped before the load, sparing the data that would have otherwise been overwritten by the load. And in the load-swapped-partial-and-duplicate instruction, the partial-vector-sized datum is duplicated across the entire vector register. 
       The Store-Swapped-Partial Instruction 
       [0074]    The store-swapped-partial instruction is used to store a vector register containing the partial-vector-sized datum to the destination address. Note that each store-swapped-partial instruction may store the partial-vector-sized datum from a register into memory and in doing so rotates bytes of the partial-vector-sized datum, so that the least significant byte of the partial-vector-sized datum is stored to the destination address on a little-endian processor, or so that the most-significant byte of the partial-vector-sized datum is stored to the destination address on in a big-endian processor ( 612 ). More specifically, upon receiving a store-swapped-partial instruction, the processor takes a vector register, and a destination address of arbitrary alignment, and stores the partial-vector-sized datum from the register into the nearest naturally-aligned memory address less than or equal to the destination address, i.e., 
         [0075]    naturally_aligned_address=(destination_address-N); where N=(destination_address mod partial_vector_length_in_bytes). 
         [0076]    During the store-swapped operation, the processor hardware rotates bytes through the partial-vector-sized datum to affect a possible transformation: on a little-endian processor, bytes are rotated to the left N positions until the least-significant byte is stored to the destination address, while on a big-endian processor, bytes are rotated right N positions until the most-significant byte is stored to the destination address. Equivalently, bytes may be rotated in the opposite direction by (vector_length_in_bytes—N) positions. These transformations are functionally equivalent to swapping data such that the bytes residing at addresses lower than the destination address are swapped, as a set, with the set of bytes residing at addresses greater than or equal to the destination address. 
         [0077]    If the destination address is unaligned, a “store-swapped-partial-leading instruction” and a “store-swapped-partial-trailing instruction” may be used to store partial-vector-sized datums at the beginning and the end of a range of consecutive vectors. 
         [0078]    Upon receiving a store-swapped-partial-leading instruction, the processor stores a partial-vector-sized datum, swapped in the manner described above, to the destination address. The amount of data stored is dependent upon the destination address and the size of the partial-vector-sized datum. Data is stored into the memory ranging from the destination address until one-byte before the next naturally aligned address boundary, inclusive (N-bytes). On a little-endian processor, the N least-significant bytes of the partial-vector-sized datum are stored, and on a big-endian processor the N most-significant bytes of the partial-vector-sized datum are stored to the destination address. Note that the processor may optionally not store the entire partial-vector-sized datum if the destination address is naturally aligned. 
         [0079]    Similarly, upon receiving a store-swapped-partial-trailing instruction, the processor stores a partial-vector-sized datum swapped in the manner described above, to the nearest naturally aligned address less than or equal to the destination address. The amount of data stored is dependent upon the destination address and the size of the partial-vector-sized datum. Data is stored into the memory ranging from the nearest naturally-aligned address which is less than or equal to the destination address until one-byte before the destination address, inclusive (N-bytes). On a little-endian processor, the N most-significant bytes of the partial-vector-sized datum are stored, and on a big-endian processor the N least-significant bytes of the partial-vector-sized datum are stored to the nearest naturally aligned address less than or equal to the destination address. Note that the processor may optionally store no data if the destination address is naturally aligned. Alternatively, the processor may rely on software not to execute this instruction for aligned addresses. 
         [0080]    Note that in some embodiments of the process there may be additional or fewer operations, an order of the operations may be changed, and/or two or more operations may be combined into a single operation. 
         [0000]    
       
         
               
               
             
           
               
                   
                 TABLE 3 
               
               
                   
                   
               
             
             
               
                   
                 LoadSwapCtlP = Load Control Vector for Partial Swapped; 
               
               
                   
                 LoadSwapPS = Load-Swapped-Partial-After-Swap; 
               
               
                   
                 LoadSwapPD = Load-Swapped-Partial-Duplicate; 
               
               
                   
                 StoreSwapP = Store-Swapped-Partial; 
               
               
                   
                 StoreSwapLeadP = Store-Swapped-Partial-Leading; 
               
               
                   
                 StoreSwapTrailP = Store-Swapped-Partial-Trailing; 
               
               
                   
                 SwapHighLow = Swap high and low halves (parts) of vector; 
               
               
                   
                 VecSelect = Select Bytes From Two Vectors Based on Predicates; 
               
               
                   
                 ld = LoadSwapCtlP (LoadAddress); 
               
               
                   
                 st = LoadSwapCtlP (StoreAddress); 
               
               
                   
                 a = LoadSwapPS (a, LoadAddress + PartSize * 0); 
               
               
                   
                 b = LoadSwapPD (LoadAddress + PartSize * 1); 
               
               
                   
                 a = LoadSwapPS (a, LoadAddress + PartSize * 2); 
               
               
                   
                 e = VecSelect (ld, a, b); 
               
               
                   
                 d = LoadSwapPD (LoadAddress + PartSize * 3); 
               
               
                   
                 c = LoadSwapPS (a, LoadAddress + PartSize * 4); 
               
               
                   
                 f = VecSelect (ld, c, d); 
               
               
                   
                 (Optional Processing) 
               
               
                   
                 StoreSwapLeadP (e, StoreAddress + PartSize * 0); 
               
               
                   
                 temp1 = SwapHighLow(e); 
               
               
                   
                 g = VecSelect(st, temp1, e); 
               
               
                   
                 StoreSwapP (g, StoreAddress + PartSize * 1); 
               
               
                   
                 h = VecSelect(st, f, temp1); 
               
               
                   
                 StoreSwapP (h, StoreAddress + PartSize * 2); 
               
               
                   
                 temp2 = SwapHighLow(f); 
               
               
                   
                 i = VecSelect(st, temp2, f); 
               
               
                   
                 StoreSwapP (i, StoreAddress + PartSize * 3); 
               
               
                   
                 StoreSwapTrailP (temp2, StoreAddress + PartSize * 4); 
               
               
                   
                   
               
             
          
         
       
     
       Example 
       [0081]    Table 3 illustrates how vector code can be written to perform a partial-vector-move operation in accordance with an embodiment of the present invention. This example loads a partial-vector-sized datum from an unaligned address, processes the partial-vector-sized datum, and writes the partial-vector-sized datum to another unaligned address on a little-endian processor. Note that in this example, there are two vector-select operations per move. ( FIGS. 7A and 7B  graphically illustrate the how the move operation is accomplished.) 
       Example which does not Construct an Aligned Vector 
       [0082]    Table 4 illustrates how vector code can be written to perform a partial-vector-move operation in which an aligned vector is never constructed in accordance with an embodiment of the present invention. This example similarly performs a partial-vector-move operation for arbitrarily-aligned source and destination pointers on a little-endian processor. However, in this example a proper vector is never formed in the processor registers. As a consequence, the system can only perform at limited set of operations on the partial-vector-sized datum during the moving process. More specifically, the system can only perform operations on the partial-vector-sized datum that do not require interactions between different byte positions in the partial-vector-sized datum ( FIGS. 8A and 8B  graphically illustrates the how this move operation is accomplished.) 
         [0000]    
       
         
               
               
             
           
               
                   
                 TABLE 4 
               
               
                   
                   
               
             
             
               
                   
                 LoadSwapCtlP = Load Control Vector for Partial Swapped; 
               
               
                   
                 LoadSwapPS = Load-Swapped-Partial-After-Swap; 
               
               
                   
                 LoadSwapPD = Load-Swapped-Partial-Duplicate; 
               
               
                   
                 StoreSwapP = Store-Swapped-Partial; 
               
               
                   
                 StoreSwapLeadP = Store-Swapped-Partial-Leading; 
               
               
                   
                 SwapHighLow = Swap high and low halves (parts) of vector; 
               
               
                   
                 VecSelect = Select Bytes From Two Vectors Based on Predicates; 
               
               
                   
                 XORInvertPart = XOR vectors, inverting polarity of a partial vector; 
               
               
                   
                 ld = LoadSwapCtlP (LoadAddress); 
               
               
                   
                 st = LoadSwapCtlP (StoreAddress); 
               
               
                   
                 ctl = XorInvertPart (ld, st); 
               
               
                   
                 temp = LoadSwapPS (temp, LoadAddress + PartSize * 0); 
               
               
                   
                 b = LoadSwapPD (LoadAddress + PartSize * 1); 
               
               
                   
                 a = LoadSwapPS (temp, LoadAddress + PartSize * 2); 
               
               
                   
                 d = LoadSwapPD (LoadAddress + PartSize * 3); 
               
               
                   
                 c = LoadSwapPS (a, LoadAddress + PartSize * 4); 
               
               
                   
                 e = VecSelect (ctl, a, b); 
               
               
                   
                 f = VecSelect (ctl, c, d); 
               
               
                   
                 StoreSwapLeadP (a, StoreAddress + PartSize * 0); 
               
               
                   
                 StoreSwapP (e, StoreAddress + PartSize * 1); 
               
               
                   
                 temp1 = SwapHighLow(e); 
               
               
                   
                 StoreSwapP (temp1, StoreAddress + PartSize * 2); 
               
               
                   
                 StoreSwapP (f, StoreAddress + PartSize * 3); 
               
               
                   
                 temp2 = SwapHighLow(f); 
               
               
                   
                 StoreSwapP (temp2, StoreAddress + PartSize * 4); 
               
               
                   
                   
               
             
          
         
       
     
         [0083]    The foregoing descriptions of embodiments of the present invention have been presented only for purposes of illustration and description. They are not intended to be exhaustive or to limit the present invention to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art. Additionally, the above disclosure is not intended to limit the present invention. The scope of the present invention is defined by the appended claims.