UPDATE: This post is just plain wrong. See correction HERE. Thanks to various people on twitter, especially Graham Sellers and Daniel Koch for pointing this out.
Just venting some frustration here. One of the annoying things in Khronos standards is the lack of required minimum capabilities, which makes writing portable code that much harder. The minimum guarantees are very lax. Just as an example, take work-group sizes in both OpenCL and OpenGL compute shaders. In both of these, you have to query to find out the maximum work group size supported which may turn out to be just 1.
Similarly, in OpenGL (and ES) compute shaders, there is no minimum guaranteed amount of local memory per workgroup. You have to query to ask how much shared memory per workgroup is supported, and the implementation can just say zero because there is no minimum mandated in the specification.
edit: Contrast this with DirectCompute where you have mandated specifications for both the amount of local memory and the work-group sizes which makes life so much simpler.
UPDATE (24th May, 10.20pm EST): Corrected some errors below.
I was looking at how to integrate custom OpenGL content inside a Qt Quick 2 application. Qt Quick 2 has several solutions, and settled on a custom OpenGL underlay. However, one stumbling block was that I wanted to use OpenGL 4.3 core profile. On my test machine, the driver supports OpenGL 4.4 and I discovered that by default Qt Quick 2 created a 4.4 compatibility profile context.
After much searching, I finally found the solution I was looking for. I am not sure if it is the only way or the optimal way, but it worked for me. You can specify the OpenGL propeties including the desired profile by creating a QSurfaceFormat object and passing it to QQuickWindow object using setFormat before Qt Quick’s scene graph begins rendering, i.e. before you invoke QQuickWindow::show either in C++, or before you set “visible” property of the window to true in QML.
The next question was, how to get to the window. Here is how to do so in some scenarios:
- If you have a handle to any QQuickItem inside the window, then simply call the “window” method.
- If you have created your application using Qt Quick Controls ApplicationWindow, and are using QQmlApplicationEngine to load the QML, make sure “visible” property of the ApplicationWindow is set to false in the QML. Then, simply get the first root object from the engine using something like
engine->rootObjects().first(). This is your window object and you can simply cast it to QQuickWindow.
- If you have created your application using QQuickView, well then your are in luck because QQuickView is a QQuickWindow so just call setFormat on the QQuickView.
Once you have done setFormat, you are then free to call “show” on the QQuickWindow and it will make your window visible.
Geekbench 3 is one of the better benchmarks out there for comparing mobile CPU performance. It contains a variety of tests and reports a cumulated single-core score, and a multi-core score. One way of analyzing processors is to get an idea of per-cycle performance. For this, I took the single-core scores for various processors and divided by the reported clock frequency to obtain the following metric: Geekbench 3 Single-core score/ GHz.
I report the results in the table below. There can be many implementations of a given ARM core in different chipsets, and the same chipset can also perform slightly differently in different devices. I report the device from which I got the scores. Even so, computations are very approximate and based on rough averages of geekbench 3 scores from different users as reported on the Geekbench browser.
Here it is:
||Galaxy S2 X (T989D)
||Galaxy S2 (i9100)
||HTC One S, Xperia ZL
||Nexus 5, LG G2
|Apple A7 (32-bit)
|Apple A7 (64-bit)
Note that for Scorpion, reported frequency was 1.5GHz but I have never seen it go above 1.242 GHz on some devices I used previously so I used 1.242GHz as the frequency.
I had previously noted that I installed Qt Creator 3.0 and it automatically detected compiler toolchains, CMake etc. At that time I was running VS 2010 Professional. I recently moved to VS 2013 Express. I opened up a new CMake project in Qt Creator and noticed that suddenly it no longer gave me the option for the proper NMake generator and started failing. After much mucking about, I have finally discovered the solution and just documenting it here in case someone else comes across the same issue.
The solution is simple. Simply install the newly released Qt Creator 3.1. Qt Creator 3.1 has inbuilt support for detecting and using VS 2013 compilers with CMake. Qt Creator 3.0 detects the compilers succesfully but was not really passing the right arguments to CMake or something. Anyway, after updating to 3.1, all my CMake projects work now.
Just a random thought. I was wondering how many active Linux desktop users are there. Turns out, we can do simple back-of-envelope calculation for this. Some estimates put the number of active desktops at around 1.4 billion. Linux desktop marketshare (from various stats such as netmarketshare and steam) appears to be around 1.5%. That leads us to around 21m active Linux desktop users.
Just some thoughts from MS announcements so far:
- Universal apps: WinRT now available on WP 8.1 is very big news. A lot of the code can now be shared between Windows Store and Windows Phone Store apps and VS project system has also been evolved to make it easier. “Universal apps” are not really a single package. You still generate and upload different packages for say Phone and Windows Store but that is just an implementation detail. Code sharing and unified API is the big news.
- Direct3D 12: Still very few details, particularly for compute. I do hope they have substantial new DirectCompute features, particularly so that C++ AMP can evolve, but no announcements so far. MS has not committed on exact OS support yet but looks very likely that Windows 8.1+ will definitely be supported. Windows 7 is “under consideration”.
- Sandboxing and third-party JITs and interpreters: I think the situation here is unchanged. Third-party Store apps still don’t have access to appropriate memory APIs for security reasons so third-party JITs are still not possible. AFAIK interpreters exposed to users are still not allowed in Store either. So forget being able to distribute Python as a Windows Store app. I guess I am a niche here, but as a compiler writer and programmer this still bums me out. As far as developer tools are concerned, Desktop apps is still the way to go.