NVIDIA DRIVE OS Linux API Reference

5.1.3.0 Release

 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
EGL_EXT_buffer_age
Name

    EXT_buffer_age

Name Strings

    EGL_EXT_buffer_age

Notice

    Copyright 2011,2012 Intel Cooperation

IP Status

    No known IP claims.

Contributors

    Robert Bragg
    Neil Roberts
    Tapani Pälli
    Kristian Høgsberg
    Acorn Pooley
    James Jones

Contacts

    Robert Bragg, Intel (robert.bragg 'at' intel.com)

Status

    Complete.

Version

    12 - June 13, 2013

Number

    EGL Extension #52

Dependencies

    Requires EGL 1.4

    This extension is written against the wording of the EGL 1.4 
    Specification.

Overview

    The aim of this extension is to expose enough information to
    applications about how the driver manages the set of front and
    back buffers associated with a given surface to allow applications
    to re-use the contents of old frames and minimize how much must be
    redrawn for the next frame.

    There are lots of different ways for a driver to manage these
    buffers, from double buffering, different styles of triple
    buffering and even n-buffering or simply single buffer rendering.
    We also need to consider that power management events or memory
    pressure events might also result in some of the buffers not
    currently in-use being freed.

    This extension lets applications query the age of the back buffer
    contents for an EGL surface as the number of frames elapsed since
    the contents were most recently defined. The back buffer can
    either be reported as invalid (has an age of 0) or it may be
    reported to contain the contents from n frames prior to the
    current frame.

    Once the application has queried the buffer age, the age of
    contents remains valid until the end of the frame for all pixels
    that continue to pass the pixel ownership test.

    For many use-cases this extension can provide an efficient
    alternative to using the EGL_BUFFER_PRESERVED swap behaviour. The
    EGL_BUFFER_PRESERVED swap behaviour adds a direct dependency for
    any frame n on frame n - 1 which can affect the pipelining of
    multiple frames but also implies a costly copy-back of data to
    initialize the back-buffer at the start of each frame.

    For example if you consider a double buffered application drawing
    a small spinning icon, but everything else in the scene is static.
    If we know that 2 buffers are continuously being recycled each
    time eglSwapBuffers is called then even though 100s of frames may
    need to be drawn to animate the icon it can be seen that the two
    buffers are remaining unchanged except within the bounds of the
    icon. In this scenario ideally the application would simply
    perform an incremental update of the old buffer instead of
    redundantly redrawing all the static parts of the scene. The
    problem up until now though has been that EGL doesn't report how
    buffers may be recycled so it wasn't safe for applications to try
    and reuse their contents. Now applications can keep track of all
    the regions that have changed over the last n frames and by
    knowing the age of the buffer they know how to efficiently repair
    buffers that are re-cycled instead of redrawing the entire scene.

New Procedures and Functions

    None

New Tokens

    EGL_BUFFER_AGE_EXT    0x313D

Additions to Section 2.2 of the EGL 1.4 Specification (Rendering
Contexts and drawing surfaces)

    Add the following text to a new subsection titled "Pixel
    Ownership Test" after the subsection titled "Interaction With
    Native Rendering":

            A fragment produced by a client api through rasterization
        with windows coordinates (x, y) only modifies the pixel in the
        rendering surface at that location if it passes the pixel
        ownership test defined by the native window system.

        The pixel ownership test determines if the pixel at location
        (x, y) in a rendering surface is currently owned by the client
        api (more precisely, by this its context). If it is not, the
        native window system decides the fate of the incoming
        fragment. Possible results are that the fragment is discarded
        or that some subset of the subsequent per-fragment operations
        are applied to the fragment. This test allows the window
        system to control the client api behavior, for instance, when
        a window surface is obscured.

        The pixel ownership test can only fail for window surfaces,
        not for pixmap surfaces or pbuffer surfaces.

        Most native window systems will be able to guarantee that no
        fragment will ever fail the pixel ownership test, but a
        notable exception to this is the X11 window system where,
        depending on the driver, the pixel ownership test may fail
        when portions of a window are obscured.

Additions to Section 3.5 of the EGL 1.4 Specification (Rendering Surfaces)

    Add the following to the table of "Queryable surface attributes
    and types":

      +----------------------+---------+-----------------------------+
      | Attribute            | Type    | Description                 |
      +----------------------+---------+-----------------------------+
      | EGL_BUFFER_AGE_EXT   | Integer | Age of back-buffer contents |
      +----------------------+---------+-----------------------------+
        Table aaa: Queryable surface attributes and types.


    Add the following text to the subsection titled "Surface
    Attributes" in the description for eglQuerySurface

            Querying EGL_BUFFER_AGE_EXT returns the age of the color
        contents of the current back-buffer as the number of frames
        elapsed since it was most recently defined. Applications can,
        under certain conditions described below, use this age to
        safely rely on the contents of old back- buffers to
        potentially reduce the amount of redrawing they do each frame.
        A frame is the period between calls to any of the functions in
        table 3.X, hereafter referred to as "frame boundaries."

        Function name
        --------------------
        eglSwapBuffers

        Table 3.X, Frame Boundary Functions

        Buffers' ages are initialized to 0 at buffer creation time.
        When a frame boundary is reached, the following occurs before
        any exchanging or copying of color buffers:

            * The current back buffer's age is set to 1.
            * Any other color buffers' ages are incremented by 1 if
              their age was previously greater than 0.

        For the purposes of buffer age tracking, a buffer's content
        is considered defined when its age is a value greater than 0.

        For example, with a double buffered surface and an
        implementation that swaps via buffer exchanges, the age would
        usually be 2. With a triple buffered surface the age would
        usually be 3. An age of 1 means the previous swap was
        implemented as a copy. An age of 0 means the buffer has only
        just been initialized and the contents are undefined. Single
        buffered surfaces have no frame boundaries and therefore
        always have an age of 0.

        Frame boundaries are the only events that can set a buffer's
        age to a positive value. Once EGL_BACK_BUFFER_AGE_EXT has been
        queried then it can be assumed that the age will remain valid
        until the next frame boundary. EGL implementations are
        permitted, but not required, to reset the buffer age in
        response to pixel ownership test changes for any pixels within
        the drawable, or if new pixels are added to or removed from
        the drawable, i.e., the drawable is resized. A reset of this
        nature does not affect the age of content for pixels that pass
        the pixel ownership test before and after the event that
        caused the reset.  In other words, applications can assume
        that no event will invalidate the content of pixels that
        continuously pass the pixel ownership test between when the
        buffer age was queried and the following frame boundary.

        It is up to applications to track pixel ownership using data
        collected from relevant window system events, such as
        configuration and expose events on X11.

        If the EGL implementation decides to free un-used back-buffers
        when the system is under memory pressure or in response to
        power-management events then EGL will return an age of 0 when
        it allocates a new buffer at the start of a new frame.

        If the EGL_BUFFER_PRESERVED swap behaviour is in use then
        it can be assumed that the age will always be 1. It is
        recommended where possible though that the
        EGL_BUFFER_PRESERVED swap behaviour not be used since it can
        have severe performance consequences. Keeping track of the
        buffer age and the regions that have changed over the last 2
        or 3 frames instead can often replace the need for using
        EGL_BUFFER_PRESERVED.

        EGL_BUFFER_AGE_EXT state is a property of the EGL surface that
        owns the buffers and lives in the address space of the
        application.  That is, if an EGL surface has been created from
        a native window or pixmap that may be shared between
        processes, the buffer age is not guaranteed to be synchronized
        across the processes. Binding and unbinding a surface to and
        from one or more contexts in the same address space will not
        affect the ages of any buffers in that surface.

    Add the following text to last paragraph of the subsection titled
    "Surface Attributes" in the description for eglQuerySurface
    errors.
        
        If querying EGL_BUFFER_AGE_EXT and <surface> is not bound as
        the draw surface to the calling threads current context
        an EGL_BAD_SURFACE error is generated.

Dependencies on OpenGL ES

    None

Dependencies on OpenVG

    None

Issues

    1) What are the semantics if EGL_BUFFER_PRESERVED is in use

        RESOLVED: The age will always be 1 in this case. More
        clarification about this was added along with the
        recommendation to use the buffer age to reuse buffers instead
        of EGL_BUFFER_PRESERVED when possible to avoid the
        in-efficiencies of introducing a dependency for each frame on
        the previous frame.

    2) How can an application know that all pixels of a re-usable
       buffer were originally owned by the current context?

        RESOLVED: It is up to the application to track pixel ownership
        using existing window system specific events, such as X11
        expose or configure notify events.

    3) What are the semantics if the buffer age attribute is queried for
       a surface that isn't bound to the calling thread's context as the
       draw surface?
       
        RESOLVED: we report an EGL_BAD_SURFACE error as is similarly
        done when calling eglSwapBuffers for such a surface.

    4) What is the buffer age of a single buffered surface?

        RESOLVED: 0.  This falls out implicitly from the buffer age
        calculations, which dictate that a buffer's age starts at 0,
        and is only incremented by frame boundaries.  Since frame
        boundary functions do not affect single buffered surfaces,
        their age will always be 0.

    5) What guarantees are provided after querying the buffer age?

        RESOLVED: The buffer age of pixels which continue to pass the
        pixel ownership test must remain valid until the next frame
        boundary otherwise applications can't be absolutely sure of
        the consistency of their rendered content.  Implementations
        may reset the queryable age of the buffer when pixel ownership
        changes occur.  This is further clarified in section 3.5

Revision History

    Version 1, 25/07/2011
      - First draft
    Version 2, 03/08/2011
      - Clarified semantics for using EGL_BUFFER_PRESERVED
    Version 3, 01/09/2011
      - Fixed a prototype inconsistency
    Version 4, 03/11/2011
      - Split out the buffer age parts from EGL_INTEL_start_frame
    Version 5, 20/03/2012
      - Document that once the age is queried it remains valid until
        the end of the frame so we can remove the need for a separate
        EGL_EXT_start_frame extension.
    Version 6, 20/03/2012
      - Clarify that only buffers who's contents were fully owned by
        the context are tracked.
    Version 7, 20/03/2012
      - Document that an error will be generated if querying the age
        for a surface not bound to the current context.
    Version 8, 25/08/2012
      - Update in line with changes made to the GLX_EXT_buffer_age draft spec
        including more relaxed pixel ownership requirements and explicit
        clarification of the buffer age calculation.
    Version 9 20/09/2012
      - Update in line with changes made to the EGL_EXT_buffer age
        draft space
    Version 10 29/11/2012
      - Add pixel ownership test section and other minor
        clarifications
    Version 11 13/12/2012
      - Allocated enumerant and marked complete.
    Version 12, 13/06/2013, Chad Versace <chad.versace@intel.com>
      - Remove the "all rights reserved" clause from the copyright notice. The
        removal does not change the copyright notice's semantics, since the
        clause is already implied by any unadorned copyright notice. But, the
        removal does diminish the likelihood of unwarranted caution in readers
        of the spec.
      - Add "IP Status" section to explicitly state that this extension has no
        knonw IP claims.