Microfacet surface rendering

[0001] Three-dimensional graphics processing involves rendering three-dimensional scenes by converting models specified in a three-dimensional coordinate system to pixel colors for an output image. Improvements to three-dimensional graphics processing are constantly being made.

[0010] A technique for rendering is provided. The technique includes obtaining one or more samples for a pixel, the samples obtained for a microfacet surface from a spherical cap cut off by a lower plane positioned to exclude reflected rays that are occluded by the microfacet surface; obtaining one or more contributions corresponding to the one or more samples; determining a color for the pixel based on the one or more contributions, for rendering is provided.

[0011] FIG. 1 is a block diagram of an example computing device 100 in which one or more features of the disclosure can be implemented. In various examples, the computing device 100 is one of, but is not limited to, for example, a computer, a gaming device, a handheld device, a set-top box, a television, a mobile phone, a tablet computer, or other computing device. The device 100 includes, without limitation, one or more processors 102, a memory 104, one or more auxiliary devices 106, and a storage 108. An interconnect 112, which can be a bus, a combination of buses, and/or any other communication component, communicatively links the one or more processors 102, the memory 104, the one or more auxiliary devices 106, and the storage 108.

[0012] In various alternatives, the one or more processors 102 include a central processing unit (CPU), a graphics processing unit (GPU), a CPU and GPU located on the same die, or one or more processor cores, wherein each processor core can be a CPU, a GPU, or a neural processor. In various alternatives, at least part of the memory 104 is located on the same die as one or more of the one or more processors 102, such as on the same chip or in an interposer arrangement, and/or at least part of the memory 104 is located separately from the one or more processors 102. The memory 104 includes a volatile or non-volatile memory, for example, random access memory (RAM), dynamic RAM, or a cache.

[0013] The storage 108 includes a fixed or removable storage, for example, without limitation, a hard disk drive, a solid state drive, an optical disk, or a flash drive. The one or more auxiliary devices 106 include, without limitation, one or more auxiliary processors 114, and/or one or more input/output (“IO”) devices. The auxiliary processors 114 include, without limitation, a processing unit capable of executing instructions, such as a central processing unit, graphics processing unit, parallel processing unit capable of performing compute shader operations in a single-instruction-multiple-data form, multimedia accelerators such as video encoding or decoding accelerators, or any other processor. Any auxiliary processor 114 is implementable as a programmable processor that executes instructions, a fixed function processor that processes data according to fixed hardware circuitry, a combination thereof, or any other type of processor.

[0014] The one or more auxiliary devices 106 includes an accelerated processing device (“APD”) 116. The APD 116 may be coupled to a display device, which, in some examples, is a physical display device or a simulated device that uses a remote display protocol to show output. The APD 116 is configured to accept compute commands and/or graphics rendering commands from processor 102, to process those compute and graphics rendering commands, and, in some implementations, to provide pixel output to a display device for display. As described in further detail below, the APD 116 includes one or more parallel processing units configured to perform computations in accordance with a single-instruction-multiple-data (“SIMD”) paradigm. Thus, although various functionality is described herein as being performed by or in conjunction with the APD 116, in various alternatives, the functionality described as being performed by the APD 116 is additionally or alternatively performed by other computing devices having similar capabilities that are not driven by a host processor (e.g., processor 102) and, optionally, configured to provide graphical output to a display device. For example, it is contemplated that any processing system that performs processing tasks in accordance with a SIMD paradigm may be configured to perform the functionality described herein. Alternatively, it is contemplated that computing systems that do not perform processing tasks in accordance with a SIMD paradigm perform the functionality described herein.

[0015] The one or more IO devices 117 include one or more input devices, such as a keyboard, a keypad, a touch screen, a touch pad, a detector, a microphone, an accelerometer, a gyroscope, a biometric scanner, or a network connection (e.g., a wireless local area network card for transmission and/or reception of wireless IEEE 802 signals), and/or one or more output devices such as a display device, a speaker, a printer, a haptic feedback device, one or more lights, an antenna, or a network connection (e.g., a wireless local area network card for transmission and/or reception of wireless IEEE 802 signals).

[0016] FIG. 2 illustrates details of the device 100 and the APD 116, according to an example. The processor 102 (FIG. 1) executes an operating system 120, a driver 122 (“APD driver 122”), and applications 126, and may also execute other software alternatively or additionally. The operating system 120 controls various aspects of the device 100, such as managing hardware resources, processing service requests, scheduling and controlling process execution, and performing other operations. The APD driver 122 controls operation of the APD 116, sending tasks such as graphics rendering tasks or other work to the APD 116 for processing. The APD driver 122 also includes a just-in-time compiler that compiles programs for execution by processing components (such as the SIMD units 138 discussed in further detail below) of the APD 116.

[0017] The APD 116 executes commands and programs for selected functions, such as graphics operations and non-graphics operations that may be suited for parallel processing. The APD 116 can be used for executing graphics pipeline operations such as pixel operations, geometric computations, and rendering an image to a display device based on commands received from the processor 102. The APD 116 also executes compute processing operations that are not directly related to graphics operations, such as operations related to video, physics simulations, computational fluid dynamics, or other tasks, based on commands received from the processor 102.

[0018] The APD 116 includes compute units 132 that include one or more SIMD units 138 that are configured to perform operations at the request of the processor 102 (or another unit) in a parallel manner according to a SIMD paradigm. The SIMD paradigm is one in which multiple processing elements share a single program control flow unit and program counter and thus execute the same program but are able to execute that program with different data. In one example, each SIMD unit 138 includes sixteen lanes, where each lane executes the same instruction at the same time as the other lanes in the SIMD unit 138 but can execute that instruction with different data. Lanes can be switched off with predication if not all lanes need to execute a given instruction. Predication can also be used to execute programs with divergent control flow. More specifically, for programs with conditional branches or other instructions where control flow is based on calculations performed by an individual lane, predication of lanes corresponding to control flow paths not currently being executed, and serial execution of different control flow paths allows for arbitrary control flow.

[0019] The basic unit of execution in compute units 132 is a work-item. Each work-item represents a single instantiation of a program that is to be executed in parallel in a particular lane. Work-items can be executed simultaneously (or partially simultaneously and partially sequentially) as a “wavefront” on a single SIMD processing unit 138. One or more wavefronts are included in a “work group,” which includes a collection of work-items designated to execute the same program. A work group can be executed by executing each of the wavefronts that make up the work group. In alternatives, the wavefronts are executed on a single SIMD unit 138 or on different SIMD units 138. Wavefronts can be thought of as the largest collection of work-items that can be executed simultaneously (or pseudo-simultaneously) on a single SIMD unit 138. “Pseudo-simultaneous” execution occurs in the case of a wavefront that is larger than the number of lanes in a SIMD unit 138. In such a situation, wavefronts are executed over multiple cycles, with different collections of the work-items being executed in different cycles. A command processor 136 is configured to perform operations related to scheduling various workgroups and wavefronts on compute units 132 and SIMD units 138.

[0020] The parallelism afforded by the compute units 132 is suitable for graphics related operations such as pixel value calculations, vertex transformations, and other graphics operations. Thus in some instances, a graphics pipeline 134, which accepts graphics processing commands from the processor 102, provides computation tasks to the compute units 132 for execution in parallel.

[0021] The compute units 132 are also used to perform computation tasks not related to graphics or not performed as part of the “normal” operation of a graphics pipeline 134 (e.g., custom operations performed to supplement processing performed for operation of the graphics pipeline 134). An application 126 or other software executing on the processor 102 transmits programs that define such computation tasks to the APD 116 for execution.

[0022] FIG. 3 is a block diagram showing additional details of the graphics processing pipeline 134 illustrated in FIG. 2. The graphics processing pipeline 134 includes stages that each performs specific functionality of the graphics processing pipeline 134. Each stage is implemented partially or fully as shader programs executing in the programmable compute units 132, or partially or fully as fixed-function, non-programmable hardware external to the compute units 132.

[0023] The input assembler stage 302 reads primitive data from user-filled buffers (e.g., buffers filled at the request of software executed by the processor 102, such as an application 126) and assembles the data into primitives for use by the remainder of the pipeline. The input assembler stage 302 can generate different types of primitives based on the primitive data included in the user-filled buffers. The input assembler stage 302 formats the assembled primitives for use by the rest of the pipeline.

[0024] The vertex shader stage 304 processes vertices of the primitives assembled by the input assembler stage 302. The vertex shader stage 304 performs various per-vertex operations such as transformations, skinning, morphing, and per-vertex lighting. Transformation operations include various operations to transform the coordinates of the vertices. These operations include one or more of modeling transformations, viewing transformations, projection transformations, perspective division, and viewport transformations, which modify vertex coordinates, and other operations that modify non-coordinate attributes.

[0025] The vertex shader stage 304 is implemented partially or fully as vertex shader programs to be executed on one or more compute units 132. The vertex shader programs are provided by the processor 102 and are based on programs that are pre-written by a computer programmer. The driver 122 compiles such computer programs to generate the vertex shader programs having a format suitable for execution within the compute units 132.

[0026] The hull shader stage 306, tessellator stage 308, and domain shader stage 310 work together to implement tessellation, which converts simple primitives into more complex primitives by subdividing the primitives. The hull shader stage 306 generates a patch for the tessellation based on an input primitive. The tessellator stage 308 generates a set of samples for the patch. The domain shader stage 310 calculates vertex positions for the vertices corresponding to the samples for the patch. The hull shader stage 306 and domain shader stage 310 can be implemented as shader programs to be executed on the compute units 132, that are compiled by the driver 122 as with the vertex shader stage 304.

[0027] The geometry shader stage 312 performs vertex operations on a primitive-by-primitive basis. A variety of different types of operations can be performed by the geometry shader stage 312, including operations such as point sprite expansion, dynamic particle system operations, fur-fin generation, shadow volume generation, single pass render-to-cubemap, per-primitive material swapping, and per-primitive material setup. In some instances, a geometry shader program that is compiled by the driver 122 and that executes on the compute units 132 performs operations for the geometry shader stage 312.

[0028] The rasterizer stage 314 accepts and rasterizes simple primitives (triangles) generated upstream from the rasterizer stage 314. Rasterization consists of determining which screen pixels (or sub-pixel samples) are covered by a particular primitive. Rasterization is performed by fixed function hardware.

[0029] The pixel shader stage 316 calculates output values for screen pixels based on the primitives generated upstream and the results of rasterization. The pixel shader stage 316 may apply textures from texture memory. Operations for the pixel shader stage 316 are performed by a pixel shader program that is compiled by the driver 122 and that executes on the compute units 132.

[0030] The output merger stage 318 accepts output from the pixel shader stage 316 and merges those outputs into a frame buffer, performing operations such as z-testing and alpha blending to determine the final color for the screen pixels.

[0031] During rendering, a compute unit 132 executes a shader program to determine the colors for pixels of an image. In many circumstances, such execution involves evaluating a surface material for a surface. Surface materials can affect the appearance of surfaces, and a wide variety of surface materials exist.

[0032] A class of surface materials referred to as “GGX surfaces” is a type of surface that has a roughness parameter that specifies how simulated light rays are reflected from the surface. A GGX surface is modeled as a probability distribution of random microfacet normals. The microfacet model represents a large number of tiny bumps or “facets” as the “GGX” distribution function (where “GGX” stands for “ground glass unknown”). The GGX distribution is equal to the distribution of normals on an ellipsoid as follows:

[0033] $D\left(m\right)=\frac{\chi \left(m_z\right)}{\pi a_x{a_y\left(\frac{m_x^2}{a_x^2}+\frac{m_y^2}{a_y^2}+m_z^2\right)}^2}$
where m=[m_x,m_y,m_z] is the microfacet normal vector, [α_x,α_y] is the roughness parameter to represent the ellipsoid whose semiaxes are

[0034] $\left[\frac{1}{{\alpha }_x},\frac{1}{{\alpha }_y},1\right],$
and χ is the Heaviside function, where the function is equal to 0 when the argument is negative and 1 when the argument is positive. Rendering such a surface involves sampling from a representative set of locations on such a surface. Performing such sampling in a “correct” or aesthetically pleasing manner involves sampling from a sampling distribution that correctly accounts for the “importance” of different regions on the surface. The sampling problem is relatively difficult due to the relatively non-regular, “bumpy” nature of the surface. For example, if a camera is viewing the surface at an angle, certain positions can never be viewed by that camera. In addition, to produce high quality results, it is important to have an appropriate sample distribution that does not inaccurately skew towards certain geometric features of the surface.

[0035] Thus, a sampling technique is provided herein for sampling microfacet material surfaces. In general, the sampling technique involves sampling uniformly from a spherical surface that is cut by a lower plane. This shape represents all of the possible reflected directions, where the reflected directions represent the direction of reflection of rays (cast from the point of view of a camera) incident on the microfacet surface. As the surface is, again, represented by a distribution of microfacets, the direction of reflection varies a great deal. The position of the lower plane excludes a large portion of light rays that would not visibly contribute to the final image. More specifically, some directions could be impossible due to being on the far side of a bump from the point of view of the camera. Other directions will be occluded by the microfacet surface itself (for example, a ray could be reflected by a bump towards another part of the microfacet surface itself). Excluding many or most of these non-visible rays would improve the rendering process by requiring less work to obtain a properly representative set of samples. It is possible that not all such directions are excluded, but excluded at least some of the directions that are occluded by the microfacet surface improves the appearance by reducing noise.

[0036] FIG. 4 illustrates a system 400 for rendering an image based on scene geometry that includes a microfacet material, according to an example. The system 400 includes a shader 402 that accepts geometry and material information and camera information, processes that information, and generates shaded pixels. In various examples, the shader 402 is a pixel shader program of a pixel shader stage 316, is a material shader of a ray tracing system, or is any other entity capable of rendering a surface having a microfacet material. In various examples, the shader 402 is software executing on a processor, hardware (e.g., circuitry, such as a processor, including a programmable processor, fixed function processor, microcontroller, configurable logic network, field programmable gate array, or any other processor, or hard-wired circuitry), or a combination of software and hardware. Although operations are described as being performed by a “shader 402” herein, it should be understood that any system could perform the steps. Such a system could include a processor that performs the operations of the shader 402 and a memory storing instructions for the processor and/or storing any or all of the data processed by or generated by the processor.

[0037] In some examples, to render a pixel, the shader 402 samples the surface a number of times, where sampling the surface includes at least obtaining a reflected direction of the ray cast from the camera. The reflected direction varies by position due to the geometry of the microfacets. The shader 402 then shades the pixel using these reflected directions. In various examples, the shader 402 determines a light contribution from objects in the direction of the reflections, and integrates those light contributions as the color for the pixel. A surface roughness parameter varies the roughness of the surface, which increases or decreases the size of the microfacets. A higher roughness means more light scattering, with a resulting visual effect (e.g., the surface produces less coherent reflections), since the sampled surface normals vary to a greater degree.

[0038] FIG. 5 illustrates examples of reflected rays that are associated with sampling a microfacet surface material 502, according to an example. More specifically, as described above, rendering a pixel for a microfacet surface involves sampling the surface one or more times. Each sample results in a selection of a ray that is reflected in a particular direction, where that direction is dependent on the shape of the microfacet surface. In an example, the shader performs sampling of this microfacet surface material 502 by randomly selecting one or more reflected directions. In other words, the shader 402 selects, from a distribution of possible reflected directions, one reflected direction for each sample. The chance for any particular reflected direction being selected is dictated by a probability distribution. Thus it can be said that the shader 402 samples from the probability distribution to select a ray. The shader 402 uses the selected ray according to any technically feasible means such as by determining a light contribution to the pixel based on what object (if any) is found at the end of the reflected ray.

[0039] In the example of FIG. 5, multiple incident rays 504 are shown incident on the microfacet surface material 502. A first incident ray 504(1) has a reflected ray 506(1) with a low angle dictated by the angle of the microfacet surface 502 at the point of contact. A second incident ray 504(2) has a reflected ray 506(2) with a steep reflected angle. A third incident ray 504(3) has a reflected ray 506(3) that propagates in a reverse direction.

[0040] Performing sampling is not straightforward. One challenge is the need to sample from different locations on the microfacet surface to obtain an appropriately representative set of rays. To overcome this challenge, a sampling technique first uniformly samples a reflection direction within a spherical cap in a stretched space whose roughness parameter is stretched to 1, and then transforms the reflected ray to the original space whose roughness parameter is the given material's roughness parameter. The spherical cap has a planar limit, as described with respect to FIG. 6. More specifically, FIG. 6 illustrates a spherical sampling distribution 600, according to an example. This distribution represents a set of possible reflected ray directions. The sampling distribution 600 is limited by a planar boundary 602. The planar boundary 602 defines an included zone 604 above the planar boundary 602 and an excluded zone 606 below the planar boundary 602. To perform sampling, the shader 402 samples uniformly from the from included zone 604. More specifically, the sampling randomly selects, with equal probability, one of the points on the spherical surface within the included zone 604. The sampled reflected vector is thus defined as a vector between the center 608 of the sphere and the selected point on the spherical surface within the included zone 604. Note that the sampling does not sample from the excluded zone 606. Once the reflected vector is sampled, the shader 402 “works backwards” to find the direction of the incident ray and/or the point on the microfacet surface 502 hit by that ray.

[0041] An example microfacet surface 610 is illustrated. For a given view angle 612, there exists reflected directions that are “beyond the horizon” of a microfacet bump (such as direction 614), reflected directions that result in a collision with the surface 610 itself (such as direction 616 or direction 618), and directions that are neither of those. The first two types are those that are excluded by the planar boundary 602 and the last type is of the type that is within the included zone 604. More specifically, the planar boundary 602 excludes at least some directions that are occluded by the microfacet surface 610 itself, where such directions are not already excluded by a planar boundary that excludes all rays that are beyond the horizon of a microfacet bump. In other words, it is possible to select a planar boundary that excludes all reflected directions that are beyond such a horizon. However, such a planar boundary would include some reflected directions that are not beyond the horizon but that are occluded by the microfacet surface 610. The planar boundary 602 provided herein is positioned to exclude both the reflected directions that are beyond the horizon as well as reflected directions that are not beyond the horizon but are occluded by the microfacet surface 610.

[0042] It should be understood that the normal of the planar boundary 602 is perpendicular to the “base surface” 503 which is a plane that characterizes the microfacet surface. In other words, the base surface 503 is a plane along with the microfacets of the microfacet surface are located.

[0043] It is possible to express the probability distribution function-which describes the probabilities for selecting particular reflected ray directions-mathematically. This expression is as follows:

[0044] $p=\frac{2D\left(m\right)\max \left(i·m,0\right)}{{\mathrm{ki}}_z+\sqrt{a_x^2{i}_x^2+a_y^2{i}_y^2+i_z^2}}\chi \left({\mathrm{ki}}_z^{\prime }+{o^{\prime }}_z\right)$

[0045] In this expression, D(m) is the GGX distribution function of microfacet normals and is equal to:

[0046] $\frac{\chi \left(m_z\right)}{\pi a_x{a_y\left(\frac{m_x^2}{a_x^2}+\frac{m_y^2}{a_y^2}+m_z^2\right)}^2}$

[0047] In these expressions, α_x,α_y is the roughness parameter, χ is the Heaviside function, where the function is equal to 0 when the argument is negative and 1 when the argument is positive. i′_z is the z component of the incoming direction in the stretched space and o′_z is the z component of the reflected direction in the stretched space. The stretched space is a modification to space that “normalizes” the coordinate space of the incoming and reflected vectors by an amount that would result in the microfacet surface having a roughness parameter of 1. The inverse of the roughness parameter includes stretching factors for x-axis and y-axis from the “normalized” space for the GGX microfacet surface. The stretching adjusts the incoming direction and microfacet normal by a proportionate amount to what is required to make the roughness parameter 1. m is an unstretched microfacet normal. Specifically, m is obtained as follows: (1) stretch the incoming direction i to i′:

[0048] $\frac{\left[a_x{i}_x,a_y{i}_y,i_z\right]}{a_x{i}_x,a_y{i}_y,i_z};$
(2) sample o′ on the spherical cap (the included zone 604); (3) compute the half vector m′=(i′+o′)/∥i′+o′∥; 4) compute the unstretched microfacet normal:

[0049] $m=\frac{\left[a_{x}m{\prime }_x,a_{y}m{\prime }_y,m{\prime }_z\right]}{a_{x}m{\prime }_x,a_{y}m{\prime }_y,m{\prime }_z}.$

[0050] In these expressions, max( ) is the maximum of the two parameters to the function (so maximum of i·m). i is a vector that represents the incoming direction (e.g., the view direction from the point of view of the camera), m is a vector that represents the microfacet normal direction, and the · symbol represents the dot product. k is equal to:

[0051] $\frac{\left(1-{\alpha }^2\right)s^2}{s^2+{\alpha }^2{i}_z^2}$

[0052] Where α=α_x=α_y if α_x=α_y. When α_x≠α_y, α=min (α_x,α_y,1) or in other words, the minimum of the roughness parameters (which specifies the roughness of the microfacet surface material, where the inverse of the roughness can be thought of as stretching factors for x-axis and y-axis of the microsurface), where s is equal to

[0053] $1+\mathrm{sgn}\left(1-\alpha \right)\sqrt{i_x^2+i_y^2}.$
In the case that α_x=α_y, it is said that the roughness of the microfacet surface is isotropic and if a_x is not equal to a_y, the roughness is anisotropic. As can be seen, k is based on the roughness parameter, meaning that the position of the plane is based on the roughness parameter. Here, sgn is the sign function that is −1 if its parameter is negative, +1 if positive, and 0 if zero. i_x and i_y are the x and y components, respectively, of the incoming vector direction.

[0054] It can be seen that obtaining a reflected vector occurs by sampling the spherical cap (which is in the stretched space). The spherical cap is defined by a spherical surface cut off by a lower planar boundary 602. In the situation that i_z<0, the position of the lower plane is −i′_z. In the situation that i_z>=0, the position of the lower plane is −ki′_z, where k is as defined above, and where the coordinate system begins at the center of the spherical cap. Again, this lower plane is positioned to exclude both the rays that are beyond the horizon as well as rays that collide with the microfacet surface. As the spherical cap exists in the stretched space, to obtain the final reflected direction requires unstretching the sampled direction. Again, stretching and unstretching is based on the roughness parameters α_x and α_y.

[0055] FIG. 7 is a flow diagram of a method 700 for performing rendering for a microfacet surface, according to an example. Although described with respect to the system of FIGS. 1-6, those of skill in the art will understand that any system configured to perform the steps of the method 700 in any technically manner falls within the scope of the present disclosure.

[0056] At step 702, a shader 402 obtains one or more samples for a pixel. The one or more samples are for a pixel for which a microfacet surface is in view. A camera is directed towards the microfacet surface, and the view angle, relative to the normal of the microfacet surface, defines how the sampling occurs. The sampling obtains one or more reflection directions that define how light rays from the point of view of the camera reflect into the environment.

[0057] Sampling occurs by sampling uniformly (e.g., with equal probability) from a spherical cap cut off by a lower plane as described elsewhere herein. The lower plane is positioned to exclude rays that are past the horizon of the bumps as well as rays that will intersect the microfacet surface. As the spherical cap is in a stretched space in which the roughness parameter is 1, the resulting sampled direction is transformed by the shader 402.

[0058] At step 704, the shader 402 obtains one or more contributions corresponding to the one or more samples. The shader 402 performs this operation in any technically feasible manner. In some examples, the shader 402 finds an object or entity at the end of the sampled reflected direction and determines the contribution based on that object or entity. In an example, an object at the end of the reflected direction has a white color and contributes that color to the color of the pixel.

[0059] At step 706, the shader 402 determines a pixel color based on one or more of such contributions. In some examples, the shader 402 combines (e.g., adds, averages, or otherwise combines) all such contributions from all such samples to determine the color for the pixel.

[0060] It should be understood that many variations are possible based on the disclosure herein. Although features and elements are described above in particular combinations, each feature or element can be used alone without the other features and elements or in various combinations with or without other features and elements.

[0061] Each of the units illustrated in the figures represent hardware circuitry configured to perform the operations described herein, software configured to perform the operations described herein, or a combination of software and hardware configured to perform the steps described herein. For example, the processor 102, memory 104, any of the auxiliary devices 106, the storage 108, the command processor 136, compute units 132, SIMD units 138, input assembler stage 302, vertex shader stage 304, hull shader stage 306, tessellator stage 308, domain shader stage 310, geometry shader stage 312, rasterizer stage 314, pixel shader stage 316, or output merger stage 318, and shader 402 are implemented fully in hardware, fully in software executing on processing units, or as a combination thereof. In various examples, any of the hardware described herein includes any technically feasible form of electronic circuitry hardware, such as hard-wired circuitry, programmable digital or analog processors, configurable logic gates (such as would be present in a field programmable gate array), application-specific integrated circuits, or any other technically feasible type of hardware.

[0062] The methods provided can be implemented in a general purpose computer, a processor, or a processor core. Suitable processors include, by way of example, a general purpose processor, a special purpose processor, a conventional processor, a digital signal processor (DSP), a plurality of microprocessors, one or more microprocessors in association with a DSP core, a controller, a microcontroller, Application Specific Integrated Circuits (ASICs), Field Programmable Gate Arrays (FPGAs) circuits, any other type of integrated circuit (IC), and/or a state machine. Such processors can be manufactured by configuring a manufacturing process using the results of processed hardware description language (HDL) instructions and other intermediary data including netlists (such instructions capable of being stored on a computer readable media). The results of such processing can be maskworks that are then used in a semiconductor manufacturing process to manufacture a processor which implements aspects of the embodiments.

[0063] The methods or flow charts provided herein can be implemented in a computer program, software, or firmware incorporated in a non-transitory computer-readable storage medium for execution by a general purpose computer or a processor. Examples of non-transitory computer-readable storage mediums include a read only memory (ROM), a random access memory (RAM), a register, cache memory, semiconductor memory devices, magnetic media such as internal hard disks and removable disks, magneto-optical media, and optical media such as CD-ROM disks, and digital versatile disks (DVDs).