TW201224933A - Systems and methods for compiler-based vectorization of non-leaf code - Google Patents

Abstract

Systems and methods for the vectorization of software applications are described. In some embodiments, source code dependencies can be expressed in ways that can extend a compiler's ability to vectorize otherwise scalar functions. For example, when compiling a called function, a compiler may identify dependencies of the called function on variables other than parameters passed to the called function. The compiler may record these dependencies, e.g., in a dependency file. Later, when compiling a calling function that calls the called function, the same (or another) compiler may reference the previously-identified dependencies and use them to determine whether and how to vectorize the calling function. In particular, these techniques may facilitate the vectorization of non-leaf loops. Because non-leaf loops are relatively common, the techniques described herein can increase the amount of vectorization that can be applied to many applications.

Description

201224933 VI. Description of the Invention: TECHNICAL FIELD OF THE INVENTION The present invention relates to computer systems and, more particularly, to systems and methods for implementing generalized vectorization of software applications. [Prior Art] Typical software development examples are well known. Computer programmers write high-level programming languages (such as 'Basic, C++, etc.) to write the original code. At some point, the programmer uses the compiler to convert the source code into the destination code. Upon conversion to an executable code (e.g., after a link or other stage of compilation or execution stage processing), the resulting program code can then be executed by a computer or computing device. The computer now has multiple processing units and is capable of executing instructions in parallel. To take advantage of this architecture, modern compilers may attempt to "parallelize" or "vectorize" some of the software functions so that instead of having a single processing unit execute an instruction sequentially, multiple processing units can execute the instructions simultaneously. During the compilation process, the compiler analyzes the software functions to determine if there are any vectorization barriers. - One such obstacle is the existence of, for example, real data dependencies. This happens when the current instruction references the data obtained by executing the first =. In the case of τ, the post-instruction can only be performed after the first two instructions, and therefore the two instructions cannot be executed side by side. Another: The potential obstacle is the existence of a function call. For example, ^ is called a foreign language τ ^ to compile the function of the function, the compiler may not be able to vectorize the [invention] function. The present invention provides a general purpose for implementing software applications. System J5875I.doc 201224933 and method: To this end, the systems and methods disclosed herein provide for the interdependence of the ability to extend the vectorization function of the compiler and/or the expression of the interface.

In a non-limiting embodiment, a compiler can check the memory and data dependencies of the function during compilation of the function ("called function"), and in a dependency database (such as, They are expressed in the phased slot case. Once compiled, the called function can be, for example, a library function or the like. At a later time, another function ("calling function") can be generated to cause the member to call the called call $. During compilation of the call function, the compiler can access the dependencies associated with the called function and can identify their dependencies. Based on the dependencies of the called function, the compiler can make a decision as to whether to vectorize the call function. Alternatively or additionally, the compiler may decide to vectorize only one of the call functions, part 1 of the function, which would otherwise be vectorized, and the visibility provided by the use of dependency rights may allow the compiler to vectorize a higher percentage of the letter. formula. For example, the implementation of a dependency file allows vectorization of functions that include non-leaf loops (ie, loops that call external functions that are not visible to the original code) because most software functions today include one or more Non-leaf loops, so such systems and methods can increase the amount of conformability applicable to any application. In another non-limiting embodiment, the compiler can generate a function from a single-original code description. Both scalar and vector versions. The scalar version of the function uses a scalar interface as originally specified by the original code. At the same time, the inward version of the function can be implemented into the vector interface of the function, accepting vector numbers and generating vector return values. 158751.doc 201224933 For example, the vector interface can be exposed in a dependency structure with a function. For example, the existence of the alternative vector interface allows the vector to be called from a vectorized loop. Rather than performing multiple serialized scalar functions in the loop of the warp vector, various combinations of techniques disclosed herein allow vectorization to not contain loops: the function 'this case with recognized wisdom Rather, it provides a number of advantages. In particular, these techniques can increase the total vectorization in a software application. [Embodiment] Although susceptible to various modifications and alternatives, this description is greedy: a specific embodiment of the discussion The drawings are intended to be illustrative, and are to be considered in the (4) All modifications, equivalents and alternatives to the spirit and scope of the present invention. Introduction + The following description first discusses an illustrative computer system or device. The compiler can be configured to execute and/or generate executable code for the computer. Next, the specification presents several techniques for realizing non-leaf loops and full-function vectorization. Illustrative computer system according to some embodiments operable to implement the mt θ ^ directional technology for software applications. Non-limiting examples φ , ^ Ν Ν ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' The network interface 14 of the O interface 130 and the storage interface 丨5. The storage interface 15 connects the external storage device 155 to the 1/〇 interface 13. In addition, the network interface 14 connects the system 100 to the network ( Not shown in the figure) or connected - to another computer system (not shown) - In some implementations, the computer system 100 can be a single processor system including only one processor 110a. In other embodiments , the computer system can include two or more processors] 1处理器all〇n. The processor]1〇&_〇ll〇n may include any processor capable of executing instructions. For example, the processor 110a-llOn may be any suitable for a general purpose or immersive processor. An instruction set architecture (ISA), such as x86, p〇werPCTM, spARCTM, or mipsTM ISA. In an embodiment, the processor nm plus may include the giants described in U.S. Patent No. 7,617,496 and U.S. Patent No. 7,395,419. Various features of a Macroscalar processor are provided. System memory 120 can be configured to store heart 7 and data that can be accessed by processor u〇a_u〇n. For example, system memory 12G can be static random access memory (SRAM), synchronous (four) RAM (SDRAM), non-volatile/flash type memory, or any other suitable type of memory technology. The portion of the program instructions and/or data that implements the desired functions or applications described in detail below may be shown stored in system memory 120. Alternatively or in addition, a portion of the program instructions and/or data may be stored in the storage device 155, stored in the cache of the one or more processors 110a-llOn or may be accessed via the network interface 14 The network gets it. The I/O interface 130 is operable to manage the processor ma_uGn, the system memory 15875I.doc 201224933 120, and any device in the system or attached to the system, including the network interface 140, the storage interface 150, or other peripheral interface. Information service. For example, the I/O interface 丨30 can convert data or control signals from one component to a format suitable for another component. For example, in some embodiments, I/O interface 130 can include attachment to various types of peripheral busses, such as peripheral component interconnect (PCI) busbars or universal serial busbars (USB). Device support. Again, in some embodiments, some or all of the functionality of the 1/〇 interface 13〇 may be incorporated into the processor 11〇a_11〇n. For example, network interface 140 is configured to allow data to be exchanged between a computer system and other devices attached to the network, such as other computer systems. For example, the network interface can support communication via a wired or wireless universal data network, a telecommunications/telephone network, a storage area network (such as a Fibre Channel SAN), and the like. The storage interface 150 is configured to allow the computer system 1 to interface with a storage device (e.g., storage device 155). The storage interface 15 can support a standard storage interface, such as one or more of the following: Advanced Technology Attachment Packet Interface (ATAPI) standard (which can also be referred to as integrated drive electronics (brain)), small Computer System Interface (SCSI) standard, Ε 1394 "such as ▲ (FireWire)" standard, deletion standard, or another standard or proprietary interface suitable for interconnecting a large capacity device with a computer system. For example, t, the storage device 155 can include magnetic, optical, or solid state media, which can be or can be pumped

Take it. The storage device 155 may also correspond to a hard disk drive or a disk drive array, a CD or DVD player, or a non-volatile memory (eg, flash) based device. 0 15875I.doc 201224933 Eight System Memory 丨20 and Storage device 155 represents an illustrative embodiment of a computer-accessible or computer-readable storage medium configured to store program instructions and data. In other embodiments, program instructions and/or materials may be received, transmitted or stored on different types of computer-accessible media. In general, an electrical access medium or storage medium may include any type of mass storage medium '^ or memory medium' such as magnetic or optical media. The computer-accessible medium or storage medium may also include any volatile or non-volatile media such as, for example, SDRAM, DDR sdram, rdram, sram 〇:), ROM or the like, regardless of whether it is such as system memory. Or another type of memory is included in the computer system. Program instructions and data stored via a computer-accessible medium may be transmitted by a transmission medium or signal (such as an electrical, electromagnetic or digital signal), such as a network, such as an electrical, electromagnetic or digital signal. And/or communication of the wireless communication medium, the communication medium, such as may be implemented via the network interface. Usually, the computer system can be in the form of a desktop or a laptop. However, as will be readily understood in accordance with the present invention, computer system 10A can be any suitable device capable of executing software. For example, computer system 100 can be a tablet computer, a telephone, or the like. Illustrative Compiler In general, a compiler may correspond to a program that is configured to translate or convert an original program code that can be represented by a high-level programming language (such as C, C++, or any other suitable programming language) into a destination program. The software application of the code (for example, one of the computer executable instructions or a plurality of modules to express the original code 5 can be called the original code language or simply called the original 158751.doc 201224933 initial language Typically, the field $t^^, σ is expressed in the form of instructions and tributes processed by the target computing architecture to represent the purpose code 'but in some embodiments, the generated code may be executed _ ± ±仃 Additional processing (eg, linking) to convert the destination code to machine executable a 1 1 ° In various embodiments, this additional may be performed by a compiler or by a separate application. It may be in machine readable form (eg, _ Carry form), in a human readable form that may require additional processing to produce a machine readable program (eg, a combination of 5 or 8) or human readable "ff彡12 1J*· 〇7 And a combination of machine readable forms to indicate that the "target architecture of the program code for the cross-referenced program can be the same as the ISA implemented by the processor UOa_l KM compiler to execute on it". The compiler can be configured to generate a destination code (compiler) that is different from the one in which the compiler is executing. Figure 22 is an illustrative compiler that produces executable code when executed by a computer system or another suitable computer system in accordance with some embodiments. The editor 200 includes a terminal 220 and a back end 230, which in turn may include an optimizer 240 and a code generator 250. As shown, the front end 22 receives the original code 210 and the back end 230 generates the destination code, such as the scalar destination code 260, the vectorized destination code 27, or a combination thereof. Compiler 200 can also generate dependency database 280 associated with one or more of destination code 260 and/or 270. Although the original code 2 is typically written in a higher level programming language, the original code 210 may alternatively correspond to a machine level language such as a combined language. For example, in addition to the program written in a higher-order programming language 158751.doc •10·201224933 code, the compiler 200 can be configured to also apply its optimization techniques to the combined language code. Also, the compiler 2 can include a plurality of different execution entities of the front end 22, each configured to process the original code 210 written in a different language and produce a similar intermediate representation for the back end 23〇 deal with. In such embodiments, compiler 200 can effectively act as a multi-language translator. In an embodiment, the front end 220 can be configured to perform preliminary processing of the original code 21 to determine if the original code is lexical and/or grammatically correct, and the execution is adapted to prepare the original code 210 for later use. End 23 is any further processing of the transition. For example, the front end 22A can be configured to process any compiler pointers present within the original code 210, such as conditionalities that can cause portions of the original code 210 to be included in the compilation process to exclude other portions. Compile the indicator. The front end 22〇 can also be configured differently to convert the original code 210 into tokens (eg, based on blank characters and/or other delimiters defined by the original language) to determine whether the original code 21 is included. Any character or token that is not allowed in the original language, and whether the resulting stream of the token conforms to the grammatical rules that define the correct expression in the original language. In various situations, the front end 22A can be configured to perform different combinations of such processing activities, some of the actions described above can be omitted, or different actions can be included, depending on the implementation of the front end 220 and the front end 22 The original language of the target. For example, if the original language does not provide a syntax for defining a compiler directive, the front end 220 may omit the processing action including scanning the original code 21 0 for searching for compiler pointers. If front end 220 encounters an error during processing of source code 210, it may abort processing and report an error (e.g., 'by writing error information to the log) 158751.doc 201224933

In other words, the intermediate representation may include a control flow diagram that explicitly identifies the control relationships between different blocks or segments of the original code 21〇. This control flow information can be used by the back end 230 to determine, for example, the manner in which the functional portion of the original code 2 10 can be reconfigured (e.g., by the optimizer 240) to improve performance while retaining the original code 210. The necessary execution of the sort relationship. The back end 230 can be generally configured to convert the intermediate representation to one or more of a scalar code 260, a vectorized code 270, or a combination of the two. In particular, in the illustrated embodiment, optimizer 240 can be configured to transition intermediate representations in an attempt to improve some aspects of the resulting scalar code 26〇 or vectorized code 270. For example, the optimizer 24 can be configured to analyze intermediate representations to identify memory or data dependencies. In some embodiments, the optimizer 24 can be configured to perform a variety of k-type code optimizations, such as vectorization, loop optimization (eg, loop fusion, loop expansion, etc.) Data stream optimization (for example, common sub-operations)

158751.doc 201224933 (constant folding), etc. or any other suitable optimization technique. Optimizer 240 can also be configured to generate dependency database 280. As described in more detail below, the dependency database 280 can express an indication of the memory and/or data dependencies within the original code 21〇. Alternatively or additionally, in conjunction with the vectorization of the original code 210, the dependency database 28 may expose the vector interface associated with the vectorized code 270. The code generator 250 can be configured to process an intermediate representation as transformed by the optimizer 2〇6 to generate a scalar code 26〇, a vectorized program code 270, or two types of code. combination. For example, the code generator 250 can be configured to generate a warp vector defined by the ISA of the target architecture.

The machine instructions are implemented such that execution of instructions generated by the original code 21 can be implemented by execution of instructions generated by a processor (e.g., one of the processors 110a-110n or a different processor) implementing the target architecture Sexual behavior. In an embodiment, the code generator 25A can also be configured to generate an operation corresponding to the original code 210 that may not be inherently but can be added by the optimizer 24 during the optimization process. instruction. In other embodiments, the compiler 2 can be partitioned into more or fewer components than the components shown, or components different from the components shown. For example, 'compiler 200 can include a connector (not shown) that is configured to take - or multiple destinations (four) or libraries as input, and combine the one or more destination slots or The library is used to generate a single-usually executable standard. Or the 'connector' can be an entity separate from the compiler. As mentioned above, any of the W-pieces and the methods or techniques performed thereby (including the methods or techniques described below with respect to Figures 3-6) 158751.doc -13- 201224933 The software code stored in a suitable computer-accessible storage medium may be implemented partially or completely. The original code 21〇 can represent, for example, a soft body function or an algorithm. The resulting object code 26G and/or 27G can be, for example, a program library or an external function that can be called by other functions. The illustrative techniques used by the compiler 2 during the operation and (in detail) during its vectorization operations are discussed in more detail below. Vectorization of non-leaf loops Many modern computers have one of the computational workloads by performing two or more different operations at the same time. The ability to process 1 in parallel. For example, a super-scalar processor can allow a computer to attempt to execute multiple independent calendars simultaneously. Another technique, generally referred to as "vector" and "quota", which can be viewed as a special case of side-by-side calculations, allows a computer to attempt to execute a single-instruction that operates on multiple data items simultaneously. Various examples of vector calculations can be found in the single-instruction multi-material (8) help instruction set that is now available for various negation, including, for example, IBM's AkiVeeTM and SPETM extended instruction sets for PowerPCTM-processors &Intel2MMXTM&; ssETM extended instruction set (4). These S-details are examples of vector instructions that can be used by vectorized orchestration, but other types of vector instructions or operations (including variable length vector operations, predictive vector operations, pair vectors, and scalar/immediate values (immediate) The combination of the vector operations of the operations) is also possible and expected. In general, the process of converting the original code into a vectorized destination code can be referred to as "vectorization." #When using the compiler to execute (in contrast to, for example, vectorizing the source code by hand), vectorization can be called 158751.doc -14- 201224933 is called "automatic vectorization". A specific type of automatic vectorization is automatically vectorized for loops. Loop auto-vectorization converts the programmed loops over multiple data items into separate functionalities that can be handled in separate processing units (eg, processor 110a_110n of computer system 100 in Figure 1, or processor'). A program/code that processes multiple data items simultaneously in a unit). For example, to add two arrays of values ^" and five", a procedural loop can repeatedly pass through the arrays, thereby adding a pair of array elements during each iteration. When compiling this loop, the vectorization compiler can use the target processor to implement the fact that vector operations that can handle a fixed or variable number of vector elements simultaneously. For example, the compiler can automatically vectorize the arrays to add loops so that the arrays and the multiple elements are added at the same time, thereby reducing the number of iterations needed to complete the addition. Typical procedures spend a significant amount of their execution time in these loops. Thus, automatic vectorization of the loop can result in performance improvements without the intervention of a programmer. In some embodiments, the compiler auto-vectorization is limited to leaf loops, i.e., loops that do not call other functions. The vectorization of non-leaf loops (that is, calling loops of other functions) is generally very difficult, because the side effects of external functions are usually opaque, especially when their original code is not available for inter-program analysis. When, such as the status of the library. For the purpose of illustration, consider the following loop: f〇r(x=〇; x<si2e. ++x) A[x]=x; foo (x) 158751.doc 201224933 To vectorize this loop, compile The device 200 can determine whether the function /〇〇f; interacts with the array 々j (eg, reads or writes). Here, there are three possible () functions / 〇〇 0 does not interact with, (2) the function does interact with; or (3) the function / 〇〇 may interact with ( (for example, depending on the stage of compilation or Execution phase conditions, ^^ may or may not interact with W). The function of the function / 0 can be used to interact with the 乂/7 to present a problem similar to the state of the function and the situation of the dynamism. in-. In the absence of interaction with the sister, the following vectorizable code is equivalent to the above loop: for (x=〇; x<si2e; ++χ) A[x] = χ; f:〇(( xX): 〇; X<SiZe; ++χ) This example shows that in the vectorized non-leaf loop handler, the compiler 200 will benefit from the knowledge of the memory and/or memory of the function access. Whether to read and / or write X. Since most loops usually contain a function call within it, in order to achieve a high degree of vectorization, it is preferred to vectorize the non-leaf loop and the function called by it. In order to achieve this level of vectorization, various embodiments of the techniques and systems incorporate compile-stage visibility across the dependencies and potential dependencies of previously compiled libraries and core groups. For example, the genius 4 π y ° 3 can be used to compile the call function independently of when (or where) the library or module was originally created. ^, some of the techniques described in this article build an illustrative compiler architecture to produce this degree' and explore the types of vectorization implemented by it. Dependency database may need to determine the external function when compiling the code of the call external function 158751.doc 201224933 Ο Ο interface (for example, the number and / or type of parameters used by the external function, = / or its return The number and/or type of results). For example, this interface π can be used to determine if the calling code has correctly implemented an external function. External callable functions typically expose their interface definitions in the header slot. However, such header files may not expose to the calling function details that are not part of the interface of the external function but still affect the vectorization of the code. In other words, in the loop described above, the vectorization of the for loop can depend on the function/mail and the matrix; the way of interaction. However, because (4) does not treat cents as a parameter', this dependency may not be adequately indicated corresponding to the header. 0 The dependency database, also referred to as the “Performance Dependency Database”, describes the dependencies of external callable functions in the library. That is, the dependency database can expose various dependencies of the called function to the calling function that are not necessarily apparent from the interface of the called function. This library can be accessed when compiling the function of the call library. In general, the dependency data continuously stores an indication of the dependencies of the callable code, such that the dependency spans: the translator is visible. For example, in some embodiments, the phase: sex database can be implemented as a dependency archive (similar to a header file) that includes human readable and/or machine readable content indicative of various dependencies. In other embodiments, other techniques may be used to implement the dependency database, such as by using a table-based relational database, semi-structured material (eg, using Extensible Markup Language (XML) formatted) Or any other suitable technique for a simplified explanation, the following discussion refers to an embodiment using a dependency file. However, it should be noted that this is only a non-limiting example of the dependency database. 158751.doc -17- 201224933 Example 0 In the embodiment, the compiler 200 includes the corresponding header slot (eg, w secret./〇) That is, since (4) accesses the dependent case (if it exists). This mechanism allows the vectorized compiler (such as the macro scalar compiler) to compile the existing code without modification, and has the dependency of the external library. The advantage of sex. The compiler can then automatically generate dependencies when compiling the library. The information contained in the dependency file can form the Application Compiler Interface (ACI), which provides the compiler 2 to understand Information about the constraints of the function. Specifically, the dependency file can express information about variables that are not normally in the mouth of the call function. For example, the variables expressed in the dependency broadcast can include not being called. The data item of the parameter (that is, these variables may not be defined by the programming interface of the beer function as the parameter of the called function). For example, by using the dependency file, the call function It can be appreciated whether the called function reads or writes a function static or archive static variable. The dependency file can also allow the compiler to distinguish between variables that share the same name but have different categories. As a non-limiting example, When compiling a library, the compiler will typically only generate the destination file. By using the techniques described herein, the compiler 200 can also generate dependency files, for example, during the compilation phase. Dependency file exposure and office The memory dependencies associated with the defined public function, including other programs from the original code, can trigger the compiler 200 to search for the associated dependency file in the corresponding location. This dependency file can be used with the blade. 158751.doc -18- 201224933 分散·Distraction and installation. In one implementation, the lack of dependency files will mean that no additional information about the library is available. This situation can be the default state of the old library and will not Will cause any compilation errors. The dependency database can be exposed by the compiler 200 when the code of the call library function is compiled. The data dependency property of the compiled library function (or any function in the program) is used to implement the non-leaf loop. This information can be made without revealing the source code of the library. In some embodiments, dependency information may be generated in a program segment of the library. For example, for each function compiled, the compiler 200 may write down the static variables of the function, the static variables of the file, The global variable and/or the type of access passed to the indicator in the function being compiled. The compiler 200 can then record which symbols have been read or written, and can be compiled with other code that can be referenced in the library. This information is sent in the form of a phase access and usage dependency file. Another non-limiting example 'If the function (10) U is defined in the file / (4) and its interface is defined in the standard 'is compiled At the stage, the memory/dependency characteristics of the function/W can be stored in the dependent case/heart 2. (It should be noted that any suitable naming convention for dependency files can be used). The call function using the function can include a header file, but cannot access the file. . When the reference function is compiled during the compilation of the call function, 'Compile II2GG can automatically search for the dependency file plus (4) to see if it exists. Since the dependency criterion is optional, the lack of this file may imply that the dependency relationship of the function defined in the file/〇"158751.doc -19- 201224933 is unknown. Therefore, it is recommended that the compiler 200 be vectorized. When you call the function, you should make a pessimistic meal. However, if the dependency file exists, compiler 2 (10) can use the dependency information in the slot to make more accurate and redundant assumptions during the vectorized call function using the phase-only characteristics of the dependency blanket. Referring to Figure 3, a flow diagram is depicted depicting a method of expressing dependencies in a dependency archive in accordance with some embodiments. In the block, the editor 2 is connected to the function to be compiled. For example, the compiler 2 can receive the function when processing the original code for authoring, such as during compilation of a library including the function. In block 310, the compiler 2 analyzes the function and identifies the expressed dependencies within the function. This expressed dependency may be, for example, a memory or data dependency associated with a data item that is not a parameter of the called function. More importantly, the dependence of the expression of a function on a particular data item can indicate that the function is to read only the specific data item and only to write the special data item, or to read the specific data item and write the specific data item. By. In various implementations, the analysis of functions may include activities such as the implementation of a method of clarification, § my law, and/or semantic analysis. The analysis may also include generating any other suitable data structure or representation of the parse tree, the symbol table, the intermediate code representation, and/or some of the aspects of the operations and/or data references that indicate the code being compiled. In block 320, compiler 200 stores the indicated indication of dependencies in a dependency database associated with the function. For example, during analysis of the function, compiler 200 can identify variables used by the function that are not necessarily region or private for the function and can therefore be read or written by code external to the function. . These variables may be examples of compiler 2's identifiable dependencies expressed 158751.doc -20-201224933, and compiler 200 may store the indications of such variables in the dependency database. (It should be noted that in some embodiments, compiler 200 may also identify and indicate dependencies for the region for local or private use). In various embodiments, the indication of the expressed dependencies may include information identifying the expressed dependencies, such as the name of the variable to which it depends. The indication may also include information that characterizes the expressed dependencies, such as information about whether the function retrieves or writes variables, and/or data types or categories of variables (eg, whether the variable is global, private, static) Information). As will be readily apparent from the present invention, the dependency file can be generated or updated in any suitable format, such as Extensible Markup Language (XML) or the like. Moreover, in some embodiments, instead of or in addition to the positive mode, the dependency may also be indicated in a negative manner. For example, the dependency file may also explicitly indicate that the given variable does not depend on the external code, in addition to or in addition to the expressed dependencies that indicate the presence of the indication. For example, consider the following example, where c: int A[1000] will be compiled; // global array a int F[1000]; //global_column F ^include <fool.h> int funcl(int b) { int x,c; c = 0; for (x=0; x<100; ++x) c = c + fool(x) + A[x+b]; F[x] = c } return(c ); 158751.doc -21 - 201224933 In this case, /(10)c7.c calls the external function fool.c shown below: II - broadcast fool.c---int fool(int d) { static int e = 0; e = e + d; return(e); } The original code of the called function/〇〇7 is reproduced for the purpose of illustration only. It should be understood that as long as there is a dependency database (in this example, a dependency file) for /〇〇, the original code is not required to be available during compilation of the call function > In this example, the expressed dependency information stored in the dependency file that has been generated when compiling the title is expressed as the function static variable "e" is read and written. The fact that the corresponding dependency slot case is shown below - non-limiting example: file foo 1 .hd ---function fool(void) read e; write e; } In the compilation phase of the file Aw/.c, including the header Archive/〇〇7』 allows the compiler 20G to read the dependency (10). This information informs the compiler of the expressed dependencies of the called function: that is, the static variable "e" is read and written. In. This also allows the compiler 2 to detect the following situation: even if the domain variables "A" and "F" are used in the call function, the global variables "A" and "F" are still not called by the function. reference. This knowledge allows the 15875l.doc •22-201224933 compiler 2GG vectorization function to add back to the circle, which is because it can determine that the parallelism will not cause incorrect operation. In this case, the loop in each element in the vector being processed will call fool () - nine. If the function/deportation is entered into the global "A", then the compiler can not be vectorized / thank you ", the loop in the ' can use Shaw information to only part of the vectorization function. In this example, the compiler can, for example, serialize the pair function

/ Relying on the call and the reference to the memory of "A", while allowing the remaining part of the loop to be executed in parallel. Referring to Figure 4, a flow diagram depicting an embodiment of a method of representing a vectorization function is depicted. In the block, the editorial function is compiled. In a non-limiting embodiment, the 'call function' may include a non-leaf loop, in which case the call function may include a call to an external or called function. Referring to the code example just given, the compiler program can process the original code, and recognize the /_ function as a call function, which includes the non-leaf/or loop of the call/call function. In block 410, the 'compiler 2' may attempt to access the dependent lean library associated with the called function. In some examples, the dependency database may be explicitly indicated to the compiler 200, for example, via command line parameters, compiler directives embedded within the original code, or via another suitable technique (eg, a dependency broadcast) ). In other examples, the compiler may attempt to infer the name of the dependency file from other data based on the naming convention. For example, if the header file is included in the original code, the compiler 2 can search for a dependency reference derived from the name of the header file. In some embodiments, compiler 2〇〇 158751.doc -23- 201224933 may search for dependency files based on the name of the called function. If the dependency data is in stock, then it can indicate the dependent dependencies within the called function. This expressed dependency may be, for example, a memory or data dependency associated with a data item that is not a parameter of the called function, as discussed above. In some examples, compiler 200 can examine several different naming conventions to determine if a dependency file exists. In block 420, compiler 200 then determines whether the call function interacts with the called function based, at least in part, on the expressed dependencies (or lack of dependencies). For example, after accessing the dependency file associated with the function, the compiler 200 can determine that the variable "e" is determined instead of the variable "A" 5 "F". a 'Compiler 2' can determine that, at least with respect to the variable "e", the call function does interact with the called function. In block 430, compiler 200 may determine whether to vectorize at least a portion of the call function, depending on whether the call function is interacting with the called function. For example, based on the expressed dependency information discussed above, compiler 200 may attempt to generate a vector program that repeatedly operates on multiple data items (eg, array elements) and/or multiple loops simultaneously. The code is used to vectorize the call function / (10). ‘In various embodiments, the dependency database can express various types of information useful to the compiler in determining whether a vectorization function is useful. Examples include tracking the reading and writing of data objects, indicators, pointing to f objects ((4) to Object), pointing to known displacements in the object (〇ffs 〃 the unknown displacement in the object to the object (which can effectively Forming a reference to the entire object), both the object and the data object, which can be used in the variable displacement of the t-piece (referring to the calculation of the dependence of the variable 158751.doc -24-201224933), and Known displacement in an object with unknown displacement to a higher level object (eg, when referring to an unknown number of known displacements but remaining unreferenced to other displacements). Known displacement information allows the compiler to be able to generate Vectorization is performed with additional dependency check instructions, and variable displacement information can be used to generate dependency check instructions that analyze variable dependencies during the execution phase, which can allow for increased direction; t-parallelism while still maintaining program correctness As explained above, the dependency database can express information about the called function that is useful in vectorizing call functions. Library store information such as the type of memory access type and / or the additional qualifier.

Translator 200 Addressing Modes As such, in some embodiments, the 6-reserved access by the function is generally of the following two types: read and write. In the body of the genus, the thousands of exhibitions, as shown in the example above, can not be recorded in the catalogue (4) _ take or write instructions. #目疋No According to the "selling 〇 ^ access call function check the function of the Μ Μ U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U Some embodiments may define three kinds of definitions and unknowns, but alternative embodiments are possible and expected 1/3 variable translations. "Don't judge by the following situation. · Addressing can be made by the calling function t by the calling function in the execution stage. Or by the called function in the execution phase. In addition, _U is defined by the two orthogonal qualifiers of the call: public and 2 to define whether the addressed model variable is visible to the external module. Relevant according to the difference; 丨i Example 'constant addressing description can be compiled at the compile stage I58751.doc -25- 201224933 The address of the parsing m includes the naming variables and naming structures that can be parsed at the compile stage A reference to a named structural element or array index. For example, 'Μ naming variables', ~ (named structure elements within a named structure), w (an array of indices indexed by constants), and Qiu 7/ι (indexed by constants) Examples of naming structural elements within a named array of structures represent instances of constant addressing. Such instances may represent static or global variables. (Automated library areas are usually temporary 'eg' are assigned after entering the module and The allocation is deallocated after the module exits, and is therefore largely invisible outside the module. The following example illustrates the dependency of a function that uses constant addressing: function foo(void) write public h[5]; read public g In some embodiments, the variable address map 31 is not constant but is not addressed by the modified function of the called function. _, which can be evaluated by the call function during the execution phase. Examples include pointing objects and observing functions. Reference to the array of addresses. Consider the following function: static int A[1000]; //archive-static variable, not void assign assign((int g, int x) A[g] = A[x]; }; The following dependencies are exported to the dependency file, so that the function is written and read, both of which are arrays of variable addressing: void assignA(g,x) { write private A[g]; read private A[ x]; }; 158751.doc -26- 201224933 In this example, if only the call function is repeated once per call loop, then the dependency check (which may also be called hazard checking) may It is unnecessary. The called function Mirror Kagawa can determine whether 茗 and X overlap 'and ) Using macro segmentation techniques scalar quantity corresponding to the outer case to consider the loop repeatedly call each of the two square:. For (x = ...) {

assignA (gl,x); assignA (g2,y); Although a crisis can exist between W or x or 2 pairs, these dependencies are related to a single call to the function. In this particular example, the call loop can check for potential hazards only between the public 7 pairs of information identified in its self-consistent profile and between right and wrong. In some embodiments, the unknown addressing is similar to the variable foot address as described above, but is typically applied to the execution phase addressing that cannot be evaluated by the call function. This occurs, for example, in the called function. The case uses the information from the dependent f-file to modify the value of the address variable in a way that is invisible. The extra qualifiers "Public" and "Private" specify whether the linker symbol is allowed to allow variables to be tested by the call function. For example, the reference in the penultimate example given above is referred to as "private", because 々7 is declared not to be remitted to the call (4) Type of broadcast static variable. In this example, 'Compiler 2' can determine the value of (4) coffee (10) function ^ 々 7 in the self-dependency information, but may not be able to produce the value of 158751.doc -27- 201224933 The code. Full-featured vectorization As described above, compiler automatic vectorization can be used to generate vectorized code from unnormalized primitives in a manner that may be transparent to the programmer or other user. This compiler auto-vectorization enables the original code to take advantage of the performance improvements provided by vector computing hardware with little or no programmer intervention. However, if the non-leaf function (that is, the function of calling other functions) is to be effectively vectorized, it may be necessary to provide a scalar interface that exposes the vector interface rather than the original code to the call function. The version of the called function. In addition, application developers may wish to use a variety of computing platforms, not all computing platforms can provide vector resources. For example, the mobile version of the processor family can omit vector operations to reduce die size and power consumption. The desktop version of the processing (4) column can be developed to emphasize processing power over power consumption. In this case, in order to execute 'applications on action processing $, it may be necessary to compile with a pure-quantity function, and when executed on a desktop processor, the application can use a scalar or vector function'. 'Automatic vectorization as described above needs to allow the program to execute efficiently on vector and non-vector platforms, reducing or eliminating programmer intervention during the month. ° Therefore, when vectorizing a function, it is compiled according to the example described in the example—from the single U(four) code. This function can be, for example, a library function 'but more 158751.doc -28- 201224933, which can correspond to any callable program or method. In some embodiments, the scalar version of the function may be, for example, the pure interface originally specified by the original code. The vector version of the 'function can be implemented to the vector interface of the function to accept vector parameters and/or generate The vector returns the value. By generating both a scalar version and a vector version of the function, the compiler can make the code more or less active during the compile or execution phase. In addition,

The vectorization of the call function can be facilitated by generating a vectorized version of the called function and exposing the resulting vector interface to the call function compiler, thereby propagating the opportunity for vectorization from the leaf function. Databases (such as dependencies Consider the following functional shells, which can be expressed, for example, in a dependency trough associated with a function). For example, the internal details of the function have been omitted: int foo(int A) int B; //the code is return(B); the scalar interface of this function can be expressed as (for example, in the dependency slot) In the case) int f〇〇(int A) This represents the result. According to this version, /O〇 uses a scalar parameter and returns the scalar vectorized to perform the same operation on multiple data items at the same time (for example) can become:

Vector foo(Vector A)

Vector B; //Function code return(B); 1587Sl.doc -29- 201224933 Thus, the vector interface of this function can be 矣+ "回J衣不( (for example, in the dependency file):

Vector foo(Vector A) is different from the pre-S representation, which indicates χ; this version uses vector parameters and returns vector results. Referring to Figure 5, a flow diagram depicting an embodiment of a full function vectorization method is depicted. In block 500, the compiler receives the function to be programmed. In block 51, the compiler can compile the scalar version of the function. In block 52, the compiler 2GG can compile the vector version of the function^ and in block 53, the compiled II 200 can express the vector interface associated with the vector version of the function in the dependency f library. . The existence of this alternative vector interface allows compiler 2 (10) to perform vector function calls from the vectorized loop instead of performing multiple serialized scalar calls within the vectorized loop. For example, let's consider the following loop in the call function of the call external function/〇〇: f〇r(x=〇; χ<5 12; ++χ) C[x]=D[x]; foo (c); If the province has a scalar interface, the chance of vectorizing this loop is limited; 4 such as the vectorization of the ice pie. However, the vector version of the /〇〇〇 vector is added to the vectorization of the loop. ^ J * version is too "example, the above loop is vectorized: 1 using the vector parameter / / and accepting the vector As a result, from :: more concurrent execution and reduced tandemization within the loop. In addition; month, J method 'this technique allows vectorization of functions that do not contain loops. This, 158751.d〇, -30 - 201224933 The shape can increase the total vectorization of the application β Ο Ο , which can be returned to the two versions of the function. In general, the "horizontal" vectorization can refer to the repetition of the loop. The vectorized type that maps to the corresponding element of the vector. "Vertical" vectorization can refer to the following vectorization type: the inverse nature of the m-loop (ie, as opposed to mapping to the 70-state in horizontal vectorization), but replacing the scalar variable with a vector variable to make Compared to the scalar version of the code, each iteration also operates on more data. You can use the S set scalar technique to horizontally vectorize the loops in the vector version of the function that vectorizes the function horizontally or vertically. This situation increases the chances of vectorization in the application. In addition to the performance and efficiency benefits of vectorization = callback, this technique can also increase the number of loops that are vertically vectorized in the application, thus reducing the extra overhead caused by horizontally quantizing the loop. See Figure 6 for a flow chart of an embodiment of a method of reading a vectorized function. In the F Λ Λ . circle in the q block _, the compiler 2 〇〇 recognizes the call by the beer function 2^ function. For example, a squeaking function can include a callback of a precompiled function within %. In block 610, compiler 200 accesses a dependency database associated with the called function. In block 6 TM check the dependency database to change the vector of the called function: No is available. In the implementation - when the vector version is available, the block 630 'compiles 1^200 to compile the call function to take advantage of the vector variant of the called function. If the vector version is not available, the compiler compiles the call function to use the pure version (for example, by repeatedly calling the scalar version of the function). For example, consider the following loop again: 158751.doc 31 201224933 f〇r(x=〇; χ<512; ++χ) C[x]=D[x]; )f〇° (C); f When vectoring this loop, compile 11 can examine the dependency database associated with X) to determine if the associated vector interface exists. If the vector interface does not exist, the compiler 2 can only partially:: loop back by, for example, vectorizing the assignment while keeping the function call in a scalar format. In another aspect, if there is a vectorized interface expressed in its dependency database, then in some examples, the compiler (10) can collectively vectorize the loop (eg, 'by assigning and calling two functions) Replace or otherwise transform into vector operations). When the compiler checks the /0 dependency database to determine if there is a vectorized interface to the called function, the compiler can additionally or alternatively check any memory associated with the called function. Dependency, = - associated with - (or another) dependency database. , and expressed in some implementations, the location of each _ dimension of the column can be independently pursued to minimize uncertainty. In general, this concept can be applied to material types (such as structure and arrays, and poorly done). The compilers such as compiler 200 (for example) can use dependency database information. To implement vectorization and to replace the scalar version when possible, use the vector version of the function (note that 'in other embodiments' can use the dependency database independently of the existence of the decision vector function 1 and can The vector function interface is used independently of determining whether the dependency library exists. 158751.doc -32· 201224933 typedef struct { int a; int b; int c; int *ptr; } myStruct; myStruct g; int bar ( myStruct &p, int j) { p.ptr[p.b+j] = 0; return(pb >j); }

Void foo(int i) { for (int x=i; x<i+200; ++x) if (bar(g,x)); ++ga; } In this example, the function will be exported Sex (for example, via a dependency archive generated by compiler 200 at the time of compiling the function, as discussed above), thereby instructing it to be written to, and reading and reading: typedef struct { int a; int b; Int c; int *ptr; } myStruct; int bar(myStruct *p, int j) { read pb; read p.ptr; write p.ptr[p.b+j]; }; It should be noted that in this particular situation Under the circumstance, it may not be necessary to identify the parameter 158751.doc •33- 201224933 as “public” and “private”. Again, it may not be necessary to declare the function to read from ρ or y, since at least in this example the 'assumable function' uses its own parameters. The type definition can be included in the dependency database to expose it to the call function, but may not be exposed to the definition by the header structure. During compilation, the compiler 2 can compile the function... without vectorizing the function, because there is no loop to vectorize. In this step, a scalar version with the following interface can be generated: int bar(myStruct *p, int j) In this example, a single execution individual and a single integer pointing to the indicator of the structure can be used as parameters, and Return a single integer as a result. Therefore, the input and output of this version of △ are scalar. However, compiler 200 can also compile vector functions with the following interfaces that can also be exported in the dependency database:

Vector bar(Vector p, Vector j, Vector pred) In this example, the predicate vector prd specifies which vector elements should be processed by this function. For example, assuming that a vector includes a defined number of elements, the predicate vector may contain a vector having the same defined number of bits, each bit corresponding to a respective element. Each element can act as a Bulin predicate, and it is determined whether the corresponding vector element should be processed (for example, if the term bit is "1", "Yes", and if the term bit is "0", then "No", or "Yes" if the term bit is "〇", and "No" if the term bit is "1". The predicate allows the call function to make a conditional call, and if it does not end at the vector length boundary, note the end of the loop. Note 158751.doc • 34· 201224933 means that other embodiments may use different types of predicate formats (such as non-bringal predicates). Also, in this example, the vector is a vector pointing to the index of the structure, but in this example t these indicators all point to the same execution individual. The vector 乂 is a simple integer 篁. The compiler can infer this type of information from a scalar function declaration. One of the possible vector variants of the function is for each element of the input vector and writes the result to the appropriate array index. The Ο 函 function-possible vector variant also returns the result vector based on the comparison of the household field. In this particular example, the compiler vertically vectorizes the function. That is, because 'the _ does not contain a loop, there is no loop repeat to be converted into a vector element (as in the case of horizontal vectorization). The vectorized version of (4) can operate on different elements of the vector input at the same time. During compilation of /^, the compiler can read dependency information about the function ^^ (which may not necessarily be in the same source) and determine that the called function (4) does not have dependency on μ even if the call The function passes the indicator to the structure (4). Because of this information, the compiler can horizontally vectorize the loop in function (4). In addition, compiler 200 may make a single function call for a vector variant of each of the processed vector pairs (four) instead of calling a scalar variant in each of the loops. Finally, the compiler can generate a vector variant of (4) with a vector interface. In this particular case, vertical vectorization cannot be applied because X-dependence of the full range cannot be analyzed. The horizontal vectorization of the loop can be applied and is repeated in a circle of (4) over the vector element passed to the function/call vector variant. 158751.doc -35 - 201224933 Under these assumptions, the function /00〇 can reproduce the following dependencies: void foo(int j) { readwrite public ga; read public gb; read public g.ptr; write public g. Ptr[@]; }; "(® symbol table is not unknown addressing). Because the function heart (7) reconciles the dependency "wnte p suppression />" +"", the compiler 2 can inform the structural elements Write as a function of X. Therefore, the compiler 2 can report to the caller of the caller that the index to the writer is unknown 'this is because the index cannot be determined by the caller of /〇叩. Additional Implementation Techniques This section describes non-restrictive compiler techniques that can be used to implement non-pen Aαl θ well tea vectorization and full function vectorization. The following is based on the macro scalar compiler technology, but the general knowledge of this technology is too happy. It will be appreciated that the present invention will recognize that other compiler techniques can be used. As long as the expression is not covered, this is generally the case when the lookup table is used for calculations to other previous examples. The addressing can include both mathematical and functional calls and only call functions. This can include indirect addressing, such as when indexing in an array. Funeral Use ~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

It shape. Consider the following example static int A[100] = {...}; return(B[A[i]]); ' 158751.d〇i -36 - 201224933 void bar(void) { for (x=〇; x&lt ;100; ++x) { t = B[x]; B[t] = foo(x); The dependencies generated for /0〇 may depend on whether the compiler and linker are configured to be used in a common manner It is different from exporting static symbols. In the following example oo, the first dependency file expresses a private static variable and the second dependency file expresses a public static variable: int foo(int i) { read private A[i]; read public B[@]; ; int foo(int i) { static int A[100]; read public A[i]; read public B[A[x]]; }; It should be noted that the type declaration of A can be exported in a public manner. It is necessary in the dependency file. When the static variable is private, the address of 5/7 is unknown. This is because the location of s" cannot be determined from the function. Since the hazard check is impossible, the vectorization of the loop in the middle cannot be performed. However, when the tool is configured to export static variables in a common manner, the compiler can issue instructions to read the contents and check for the danger between the β plant and the ^^77, thus implementing vectorization of the loop. 158751.doc •37· 201224933 Naturally, 丨,, A 03 V» When the field is remitted by A and externally located static variables, see the opportunity of name conflict. A. To help avoid such conflicts, static variables can be renamed by functions and files of the static variables. 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危 危° Ten counts may be different. In order to support the vectorization of calls involving a conditionally dependent function, a mechanism can be provided to express the way the condition affects the dependencies. For example, consider the following code: if (A[x] < C) d = B[x]; This code can be expressed in the dependency database as: read public A[x]; read public c ; containing b]< c ? read public B[x]; A[x] < c ? write public d; The conditional expression can also exist in the calculation of the address. For example, consider the following code: if (A[x] < c) d == B [x]; else e = B[x+C]; This code can be expressed in the dependency database as Read public A[x]; read public c; A[x] < c ? write public d : write public e; A[x] < c ? read public B[x] : read public B[x+c Alternatively, the latter conditional expression can be expressed as: read public B[ A[x] < c ? x : x+c ]; 158751.doc -38- 201224933 In some cases, the unknown can be Gradually generated in the dependency expression. In this case, an illustrative example can be: A[x] < c ? read public B[xJ : read public B[@]; This expression can notify the compiler that the condition is true. The specific dependence of B, and if the condition is false, inform the compiler of the unknown phase of 6. Dependency. Unknown items that are gradually produced in the conditional expression can cause unconditional dependencies that appear to be true and false. For example: OA[x] < B[@] ? read public f : read public g; can be expressed as: read public f; read public g; and: read public A[ x > @ ? x : x+ y]; can be expressed as: read public A[x]; read public A[x+y]; 0 Since the call function usually cannot evaluate unknown conditions, the call function can make access to two of j/7 A conservative hypothesis of possible indexes. "In some implementations, it is also possible to express cyclic dependencies in a dependency database. For example, consider the following or: if (A[x] > b) b = A[x] In an implementation, This function can be expressed as: read public A[x]; read public b; A[x] > b ? write public b; 158751.doc -39- 201224933 Passing the indicator or reference to the function (also known as In the case where the factory is passed by reference, the function may modify its call parameters. This situation is different from the modification of the parameters passed by the value, for example because the modification of the parameters passed by reference can affect the operation of the call function. Modifications to the parameters passed by reference can be recorded in the same manner as recording static and global storage modifications. The modification of the parameter passed by the value can be considered as a modification of the regional automatic storage area. In some instances, the modifications may not be recorded because the modification of the number passed by the value is not visible to the call function. - The function of conforming to a set of criteria can be speculatively invoked in a situation where the software speculates that a vectorized call loop will be necessary. Therefore, 7 expresses the speculative security indicator in the dependency file, and the speculative security indicator can predict the manner in which the corresponding code can be safely called. In a non-limiting example, a vector function that can be called in a speculative manner can belong to one of two categories: Type A and Type B. Type A Functions Cox has the vector function of the regular vector interface described in this article. For example. You can speculatively call the function when the type A function meets the following criteria without harmful side effects. First, the function does not access any memory except for the area auto-non-cardinal. Second, the function is not called any other function of the type A function. The real form of the type A function is the transcendental function or other repeated convergence algorithm. An example may return a predicate vector indicating which elements are processed, in addition to any return value specified by the original program. The criteria for calling the type B function in a speculative manner in the real two can be as follows: & The first 158751.doc •40· 201224933 any read using the first function is not written to the non-regional non-calling neither the type first 'self-non-region storage area or area array storage area failure (flrst_faulting) read instruction, Domain storage area or static area storage area. Third, the function of the letter A is not any function of the type B function. The circle beer called type A function can be similar to the beer called non-speculative function. When the type A function is called in a speculative manner, no special action is necessary in terms of the beer callback. However, the Call, 7 function can require the call loop to check the return vector to determine the processing Ο Ο to adjust the behavior of the call loop. And as a response compiler (such as compiler 200), you can choose to have all callers of the type Β vector function adjust their behavior to accommodate several elements that have actually been processed, regardless of whether the software push is used for callback. In the circle. Alternatively, the lesson (10) can generate two vector functions with the -type ; function; a speculative vector function and a non-speculative vector function. The criteria for the type of loops can be generally designed to ensure that the loops defined are small and small, and the effect of the code size of the method is negligible. According to the declaration in the Dependency Database, the lack of the dark type and the type β vector function of the specifier can be identified by the report, as shown below. In an implementation command, the function can be called in a speculative manner.

Int funcl(int a) : A

Read public b; / / region - static write public c; / / region - static state int func2 (int a) : B 158751.doc • 41- 201224933 jead public d; / / non-region: in the vectorization compiler Confusion can sometimes be analyzed to solve the problem TM = the second rule, the knife $, which limits the benefits of a wider vector. . Confusion of 卩 or static money can affect the traversal of the function call. In the ~, 纟 implementation, perform the compile phase confusion analysis and will confuse the remittance to the dependency file. The + ^ and ° methods can be used to classify confusing events into two categories, such as = confusion and outgoing confusion. From the point of view of the function being called, the address in the obfuscated function (such as the address passed into the parameter as input), the reading from the external variable, or the address of the external variable by the function Calculated address. At the same time, the clarification of the function can be referred to the pheromone of the function. These can be a return letter, the value of the function is also written to the external variable or the value in the reference indicator. In addition, at least two types of confusion can be tracked. “Replica Confusion” may refer to a copy of the “marked as another” indicator and may confuse anything that the indicator may confuse. Point Confusion can indicate that the indicator is likely to affect another variable. The confusing information in the dependency file is a confusing representation of possible affirmation. For example, when the compiler simply attributed to the lack of obfuscated information and could not tell whether two indicators refer to the same memory, the information is not needed. The declaration of confusion of variables can be similar to the declaration of confusion of returning values. For example, consider the following function: 158751.doc •42· 201224933 static int s; static void *ptr, *ptr2; static void *A[1000]; void foo(int x, int y) { A[x] = (void*) s; A[y] = (void*) &s; ptrl = &A[s]; ptr2 = A[s]; . } In an implementation, this function can express the following dependencies Sex: void foo(int x, int y) { G read public s; write public A[x] copies s; write public A[y] points s; write public ptrl points A[s]; read public A[s] ; write public ptr2 copies Afsl· }; For clarity, 'the above distinctions between points and replicas, but it is possible to combine these two concepts in alternative grammars. As with other dependency information, confusing information is usually propagated up through the call function chain. The value returned by Q by the function can also be confusing, for example, by passing back the value itself or by modifying the information returned by the variable passed by the reference. Returning values and information can also be traced in the dependency file. For example, consider the following formula: static float gVar; int *foo(fl〇at *ptrl,float **ptr2) *ptr2 = &gVar;return((int*)ptrl); } In one implementation 'This function can reproduce the following dependencies: 158751.doc •43- 201224933 int *foo(float *ptrl, float **ptr2) write *ptr2 points gVar; return copies ptr 1; }; Dependency declaration can notify the call The indicator returned by /oo〇 can be a copy of the indicator passed in. This situation allows the call loop to take action to ensure proper operation of the loop, regardless of confusion. In addition, this knowledge allows the compiler to better utilize ANSI obfuscation rules in the face of ANSI-C-compliant code. As another consideration, the cast of indicators can affect address calculations. For example, consider the following function: void ZeroInt(char *ptr, int x) *((int*)ptr + x) = 0; In one implementation, this function can rectify the following dependencies: void ZeroInt( Char *ptr, int X) write *((int*)ptr+x);

The situation allows the compiler to treat these functions as a reflection of the uncertainty of the scalar function of the dependency of unknown dependencies. In an implementation, the versioning scheme allows for the best time to perform (4) the best way to express dependencies. For example, an implementation may permit backwards compatibility with dependent files generated by older translators, while another embodiment may permit older compilers to also be read by newer totals. The two-way compatibility of the files generated by the interpreter i. In the case where the backward compatibility is only required, the version specification of the dependency file is used to notify the older code (4) that the reference is specified and should be ignored. It is said that bidirectional compatibility can be implemented as follows. For example, suppose the compiler version 1

The calculation of the array index is not supported, but compiler version 2 supports the calculation of the array index. The version of the noisy W can be expressed by the version i compiler as: #1 int foo(int x, int y) write public B[@]; }; On the other hand, the version 2 compiler can additionally use version 2 The syntax returns the same function: #2 int foo(int x, int y) write public B[x+y]; }; , by this method, not only the version 2 compiler can read the version file, but also allow Version 2 is declared to replace the version 丨 announcement. The version 丨 compiler will know that any announcements that are slightly larger than version 1 will be given, giving a much-needed dependency-bein. This is a significant capability as compiler technology matures. In general, if a developer is required to change the software to achieve vectorization, relatively few code codes can be vectorized. To address this issue, the techniques described herein provide the ability to perform large-scale vectorization without requiring developers to modify their original code. 158751.doc -45- 201224933 Although the above embodiment has been described in considerable detail, it is becoming apparent that those who are familiar with the technology will become more apparent after fully explaining the monthly book. It is intended that the following claims be interpreted as including all such changes and modifications. BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram illustrating a computer system operable to implement techniques for implementing generalized vectorization of a software application, in accordance with some embodiments. 2 is a block diagram illustrating a compiler that can generate executable code when executed by a computer system in accordance with some embodiments. 3 shows a flow diagram illustrating a method of expressing dependencies in a dependency database, in accordance with some embodiments. 4 shows a flow diagram illustrating a method of vectorizing a function in accordance with some embodiments. Figure 5 does not illustrate a flow diagram of a full function vectorization method in accordance with some embodiments. 6 shows a flow diagram illustrating a method of using a vectorized function, in accordance with some embodiments. [Main component symbol description] 100 Computer system 110a Processor 110b Processing 11 On Processor 120 System memory 130 I/O interface 15875I.doc -46 - 201224933 140 Network interface 150 Storage interface 155 Storage device 200 Compiler 210 Original program玛 220 Front End 230 Back End 240 Optimizer Ο 250 Code Generator 260 Quantitative Purpose Code 270 Vectorized Destination Code 280 Dependency Database 158 158751.doc -47-

Claims (1)

201224933 VII. Patent application scope: ι· A method comprising: performing the following steps by one or more computers: a function called 'the calling function includes a call to a call 3 ο access and the call One of the functions associated with the continuous dependency data deduction 'where the persistent dependency database indicates the dependence of the called function on the expression', wherein the expressed dependency indicates that the formula is a read-only item , whether to write the data item, or read the data item and write the data item, and 2. (4) based on the expressed dependence to generate whether the call function and the called function are Interactive - judgment. 1:: Method of item 1 wherein the call to the called function occurs; one of the call functions is within the loop. 3. The method of claim 1, wherein the performing further comprises: ο determining, from the persistent dependency database, that the vector version exists for the heart call function; and in the call function, A call to a scalar version of the called function transitions to one of the vector versions of the called function. 4·=The method of claim 1, wherein the performing the step comprises: determining, based on the __ or more of the subordinate items, the __ or more of the subordinate items: no vectorizing the calling function At least - part: whether the variable is read or written by the beer: function; whether the variable is for the public function of the calling function; or the addressing mode associated with the variable. 5. The method of claim 1, wherein the executing further comprises: compiling the original code corresponding to a function; during compilation, identifying the function that is expressed by one of the data items: Dependence of Γ expression indicates that the function reads only one of the data items only, or reads both the data item and the data item; and, one of the expressed dependencies In the library. The method of claim 5 in which the continuous dependency depends on the item 5, wherein storing the expressed phase includes the name other than storing the variable, and storing the indication in the following = the indication is stored in the continuous dependency In the sex database, whether the =: is one; or the method associated with the variable. 7. The method of claim 5, wherein the function of the -vector interface is - to /. Include a method with a -_ quantity version, and the knowledge of the vector interface is not stored in the persistent dependency database. 9. 8. = method of item 5 wherein the execution further includes generating the persistence dependency data during the compile phase Library. The method of seeking = wherein the storing the indication comprises expressing a following address pattern: a certain limit associated with the data item in the function; the public item associated with the data item in the formula Private:, associated with this function—speculative safety indicator i. • Two = This: The obscured indicator associated with the item. ^ The method in which the indication is stored includes one or more of the following 158751.doc 201224933: whether the function reads or writes to - indicates the known displacement in the object, whether the function reads An indication of the displacement of a variable that is taken or written into an object; or whether the function reads or writes to an unknown displacement within an object. n. 12. Ο 13. 14. 15. Ο 16. If the method of claim 1 or the method of claim 5 is specified, the data item in I is not passed to the function through the program interface of the function— parameter. The method of claim 1, wherein the performing further comprises: vectorizing the code within the call function based at least in part on the determining. 3 Finding the side of item 12, wherein vectorizing the code progress in the call function includes: at least part of the public id? j-λ j.. P knife based on the determination to vectorize a loop in the call function . The method of claim 12, wherein vectorizing the code in the call function further comprises: modifying the call to refer to the vector version of the beer function. The method of claim 1, wherein the step of performing comprises: determining, based on the call function, whether the fly is interacting with the break call function, based at least in part on the dependency of the expression Whether to vectorize at least a portion of the call function; and in response to determining to vectorize at least a portion of the ^4 function, the peak A is bound to cause a vector code for the persistent-vector operation. The item is the method of claim 15, wherein the called function contains the function in the pre-compiled private code, and the original code is not available, and the code compiled by _ is used. But the decision operation determines to vectorize at least a portion of the call function 158751.doc 201224933, such as a method of requesting an item, wherein the "function" includes a non-leaf loop, the non-leaf loop including the called letter 18. The method of claim 17, wherein the performing further comprises: vectorizing the first portion of the non-leaf back; and serializing the second portion of the non-leaf loop. Reading the storage medium, the program is stored in the order, and the program instructions are executed in response to the execution of the system by means of the knowledge of the brain system - ♦ * l * The request item 丨 to 丨8. The operation of the method of any one of the items 20. The system includes: an inter-storage instruction; and a memory from the 1st home | system execution implementation such as requesting one or more memories , at one or more of the operating periods A processor that fetches instructions during execution and executes the instructions to cause operation of the method of any of 1 to 18. 158751.doc