inline uint32_t uint32_rol(uint32_t _a, int _sa)
{
    return ( _a << _sa) | (_a >> (32-_sa) );
}

inline uint32_t uint32_ror(uint32_t _a, int _sa)
{
    return ( _a >> _sa) | (_a << (32-_sa) );
}

E.g., for Clang on x64:

uint32_do_ror(unsigned int, int):
    mov     ecx, esi
    ror     edi, cl
    mov     eax, edi
    ret

uint32_do_rol(unsigned int, int):
    mov     ecx, esi
    rol     edi, cl
    mov     eax, edi
    ret

When inlined into a loop, the rotate was not generated by clang, although it was by gcc. I presume that’s because some other optimisation pass had moved code around enough to stop the rotate pattern being matched. The full example is here on Godbolt. Code courtesy of Mike Acton’s uint32_t header.

The post C++ Compilers Generating Rotate Instructions appeared first on Andrew Cox.

The post Vulkan 1.0 Released appeared first on Andrew Cox.

The post Official SPIR-V assembler, binary module parser, disassembler, and validator released on GitHub appeared first on Andrew Cox.

Alon Or-bach of Samsung gave this presentation on the Vulkan Window System Integration at SIGGRAPH 2015. WSI is the mechanism by which images rendered with Vulkan appear on a screen. We can get a fair bit of information about how the system works from this talk. I am posting it a bit late but it is the latest WSI information available and I have added my notes on it below.

Vulkan WSI has a notion of a platform, and the intention of it is to abstract you from the particular operating system or windowing system your app is running on. Vulkan physical devices advertise properties of their queues, and with the WSI extension, a property of those queues is the ability to present images to the presentation engine. The presentation engine is an abstraction for the system compositor or whatever process gets rendered pixels to a screen. A presentable image is a standard VkImage from the point of view of a Vulkan app, but created by the platform (probably by the presentation engine). Being presentable means that it can be fed into the presentation engine via WSI to eventually be displayed, as well as being a target for rendering within a Vulkan app. A set of presentable images is formed into a swapchain for reuse, where each image in the chain is either under control of the app or the presentation engine at any given moment, with explicit synchronization via a semaphore to control the handover of images between app and WSI.

Allocation of presentable VkImages is done up-front ahead of time. The system thus knows all the images which can ever be presented to it. The application asks for a minimum number of images and the presentation engine will return at least that number. There is also a mechanism to tell the application that it needs to recreate a swap chain. This comes into effect when the window is resized for example.

Presentable images are either under the control of the presentation engine or of the application and it is an error for the application to attempt to draw to an image that is being displayed. Acquiring the next image from the presentation engine for the application to rendered into and presenting a complete image from the application to the presentation engine are two separate operations. This separation allows the acquire to occur at the point in the app’s render loop after it has done side work like dynamic command buffer generation and just before it wants to submit its first drawing commands, and allows the present to be at the end of it. This separation should allow the CPU to do other useful things after a present before it has to enter a potentially blocking acquire during the next iteration of its display loop.

Update 2015-10-29:

Tobias Hector of Imagination has spoken about this a little in a newer video.

The post Vulkan Window System Integration Talk at SIGGRAPH 2015 appeared first on Andrew Cox.

Video  1, One API for all platforms

• Blog post: http://blog.imgtec.com/powervr/vulkan-one-api-for-all-platforms

Video 2, High efficiency on mobile

• Blog post: http://blog.imgtec.com/powervr/vulkan-high-efficiency-on-mobile
• My notes on the video: http://ahcox.com/vulkan/vulkan-notes/#high-efficiency-on-mobile

Video 3, Scaling to multiple threads

Video 4, Explicit operation and consistent frame times

Video 5, Architecture positive: how the Vulkan API works for PowerVR GPUs

The post Imagination to Deliver 5 Webinars on Vulkan appeared first on Andrew Cox.

Tobias Hector

This week I’ll begin by talking about what it means for Vulkan to be one API designed for all platforms

The post Tobias Hector of Imagination Technology Writes About Capabilities, Limits, Extensions, and Profiles for Vulkan appeared first on Andrew Cox.

The post Showing the Size of a Class in the C++ Compiler Output appeared first on Andrew Cox.

LunarG are preparing a Vulkan driver and tools as part of a SDK sponsored by Valve. They advertise Linux, Android, and windows support in the video above. Sign up for updates here.

The post Vulkan SDK From LunarG appeared first on Andrew Cox.

Highlights

• 0:015:00 Graham Sellers does a walk-through of a complete application, explaining bits of Vulkan API along the way.
• 0:35:45 John Kessenich Goes through the SPIR-V shader and kernel binary intermediate representation.

If you have some suggestions of highlights and key points, let me know in the comments below.

The post Vulkan Overview and Demos at GDC 2015 [Video] appeared first on Andrew Cox.