How does the patent application US 2011/0037768 “System for Emulating Graphics Operations” filed by Apple (filing date Oct 15, 2010) differ from Microsoft's DirectX/DirectDraw HEL (Hardware Emulation Layer) which has been around for a couple of decades? Issued patent US8040353.

Here are the first few claims:

1. A method of creating an image, the method comprising:

  • receiving a request to render a polygon having a plurality of pixels, the polygon represented by a programmable graphics processing unit (GPU) fragment program, the programmable GPU program comprising a plurality of programmable GPU fragment programs;
  • converting the programmable GPU program to a central processing unit (CPU) program;
  • unrolling a loop in the CPU program such that the unrolled loop will process N of the plurality of pixels;
  • executing, by a CPU, the unrolled loop a variable number of times; and
  • rendering the N pixels in groups of L pixels, by executing, by the CPU, the unrolled loop L/N times.

2. The method of claim 1 wherein the act of rendering comprises performing texture lookups for each group of L pixels before rendering any of the L pixels.

3. The method of claim 1 further comprising:

  • dividing the polygon into sections;
  • selecting a first section for rendering; and
  • selecting a first scan line in the first section for rendering.

1 Answer 1


This application relates to shading languages like Cg, GLSL, and HLSL. In particular, it's about executing fragment programs on a CPU rather than a GPU, which is not even vaguely novel. Shading languages have been around for decades, and can run on both CPUs and GPUs. The bullet points simply describe the obvious, straightforward approach to executing the program on a CPU, and is precisely how most implementations do it (though some modern implementations are a bit fancier, using SIMD units to execute several instances of the program at once).

Notice something very sneaky they've done in the claims: they speak about a "GPU fragment program", implying that the program was written for a GPU, and they're doing something novel by executing it on a CPU instead. That is false. The whole point of high level shading languages is to be hardware independent. There is no such thing as a "GPU fragment program." There are only "fragment programs" that are hardware independent and can be executed on any type of processor you have available.

Regarding more specific prior art:

The first widely used shading language was Renderman, developed in the 1980's. It ran on CPUs, since there were no programming GPUs back in those days. The first system I know of with programmable shading units was Pixel Planes 5. GLSL was developed starting in 2001, and included both CPU and GPU implementations from almost the very beginning. For example, a CPU implementation appeared in Mesa 4.1, released on Oct. 29, 2002, well before the priority date for this application.

  • The patent is on a specific optimization for converting a GPU-specific program to a CPU program, rather than just the idea of executing shaders on CPU. It seems they want to compensate for the lack of massive parallelism in CPUs that GPUs provide by re-compiling the fragment code for CPU-specific performance optimizations, taking advantage of e.g. instruction-level parallelism in superscalar architectures. The optimization this claim covers is simple loop unrolling. While that is an extremely common optimization, they probably think it's non-obvious for their GPU-to-CPU JIT'ing use case.
    – kinkfisher
    Commented Oct 17, 2012 at 22:08
  • @kinkfisher: I think it's worth adding, however, by that by 2002 loop unrolling was a common enough optimization that it almost certainly happened with Mesa, even if the people working on Mesa did nothing to cause it (i.e., anybody compiling with gcc at high optimization probably got unrolled loops, even if they didn't realize it). Commented Oct 17, 2012 at 22:17
  • @JerryCoffin Agreed. Loop unrolling has been a very standard optimization for a very long time, so unless the other elements are rather limiting, I'd guess obviousness is a big concern as the claim stands.
    – kinkfisher
    Commented Oct 17, 2012 at 22:34
  • The claims don't say anything about superscalar architectures, JITs, or anything like that. They just say "loop unrolling", so that's all something needs to do to count as prior art. And, as Jerry Coffin pointed out, that's such a standard optimization that the compiler will do it for you if you don't do it yourself.
    – peastman
    Commented Oct 18, 2012 at 0:26
  • @peastman Right, the claims don't mention superscalar processors, JIT, etc. (although the spec does) because you typically want to claim the broadest scope you can that avoids the prior art found. But they could get it issued without bringing in details like CPU architecture into the claims, so introducing those would have been sub-optimal, as they would only limit the scope. Seems the examiner found the combination of all elements (converting GPU-specific code to CPU code + loop unrolling etc.) to be novel and non-obvious enough to be allowed.
    – kinkfisher
    Commented Oct 18, 2012 at 1:24

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .