_mat_

It's easy to distinguish an invalid result from a valid one. Whatever the dialog says, the hexadecimal digits for 1B will always be 5895585A0. If it's not then something went wrong. It might be difficult to moderate, so we could add something to help it. For example set the font of the run red or add a watermark. We could also go back to the way SuperPI does it an make the result dialog modal. Nico, there is no easy way to check for a valid result during the run. The errors are normally very small, no mathematical boundaries are hit (like division by zero) and the results of each batch are influenced by multiple input parameters like the batch size.

Press Alt+C, it should always come up.

Seems to work as excepted. What's the problem exactly? Is the CPU not listed in the settings dialog? What happens when you start the calculation?

It should be listed as OpenCL CPU device then. Select it and start the bench. If it's not listed neither ignored, you have not installed the Intel OpenCL drivers yet. Have a look at the FAQ, you'll find a link for the download there.

Good double precision helps, but choosing the right weapon - currently R9 290 - and overclocking it to the maximum is key in this benchmark. So FirePro and Quadro won't have a chance to fetch the cups, if they can't be overclocked. Some of the is already using WIN32's WCHAR, but not all of it. Why, seen any problems with English yet? Anyways, I have no intention to translate it.

First official release version is here! Just a few minor bugfixes, no changes on the GPU code and the results. I recommend to use this version for benching though. Changelog Explicit device selection for SLI, Crossfire und systems with multiple sockets and CPUs, implemented for CUDA as well as OpenCL. Important: The sort order of the devices depends on the driver and therefor the vendor implementation. In my tests this is same order in which GPU-Z sorts its devices. Some overclocking tools might order them in their own way. Bugfix: The previously selected CUDA graphics card was not correctly preselected in the settings dialog The final message box after the calculations is now exactly shown as in SuperPI Download: GPUPI 1.4 (723 KB)

Was a bit busy with an overclocking show the last few days. If anybody wants the see some pictures, have a look here. First off, thanks for the nice scaling diagram. It clearly shows that GPUPI is not bandwidth limited in any way. The millions or even billions of parallely calculated values always stay in the graphics memory, never have to be copied to the host. That's because I've implemented not only the pure calculation on the GPU, there is also a two-stage memory reduction done right afterwards using shared memory inside the workgroups. Only two doubles have to be transfered afterwards to the host to accumulate the final sum of each series (there are four of them). Regarding your suggestions, when writing the bench I initially wanted to use the original font. But it has a lot of kerning and I was not able to put in all the information without resizing the window to a strange and not SuperPi-like proportion. As I don't like the original font that much, I thought I'll better choose something more readable. Additionally I also implemented the text as an editable control in WIN32, because I wanted the text to be selectable for copying information, something I also missed in SuperPI. That comes with the sacrifice to control the spacing of the text itself. SuperPI uses GDI draw calls, where you can state a pixel coordinates to place the text. I've also but some thought in the cancel button before calculation, it's not a bug. I thought it was a good idea to be able to cancel it. You know how it is benching with ln2. You open the bench, press calculate and wait for the message box to start. Now focus is back on the temperature, pouring ln2 to the maximum of the component. When ready, press Ok. But sometimes things are not ready or you've forgot something. Now you have a choice to go back, quit the application and do it. But guys, if you want it to be more nostalgic, I can try. I've just wanted to let you know, that I put some thought into it and didn't change things for nothing.

It would be an honour! I promise to support the benchmark actively in the foreseeable future. Btw: Next stop is multi gpu support. I just got supported by ASUS with a couple of GTX 980s for an overclocking show in Vienna today. I will use them wisely.

Thanks Nico, very much appreciated! I will change the message box, good idea. I really wanted to implement it as close to SuperPi as possible, but changed what I felt was outdated or not well done in the orginial benchmark. For example the window can be moved after the message box for a successful calculation is shown. The screenshot weirdos will thank me for this - yeah, I am one of those. It was also important for me to have an options file, that rembers what was set last time. Regarding the default bench settings for ranking, I let you guys decide. I will update the bench to show it as default too.

Yes, but that's not the reason for the good score. The 290s have exeptional integer performance. The implementation itself only accounts for als much as 4 percent in my first tests with the new CUDA version. I am a bit disappointed.

Very good result. AMD has an even bigger lead in 32B. My GTX 980@stock had to crunch for nearly 51 minutes.

I've just added "GPUPI - 32B" and "GPUPI for CPU - 1B" to the benchmarks. Let's hope you use it. Btw, I guess there should be a discussion if it's allowed to use CUDA for NVIDIA cards to compete in the rankings. Well, that's why I have so carefully implemented CUDA and OpenCL so close together. I think it would be fair, because any performance improvement is due to the vendor's implementation and optimization of kernel, which is basicly the same.

Guys, version 1.3 is here. The whole code was refactored and allows multiple APIs now, that are loaded when the system supports it. The new version also includes a standalone for OpenCL and CUDA. The main reason is that the OpenCL version will run on Windows XP, the CUDA version won't. The CUDA implementation was pretty easy and also uses less code to work. Especially the part to setup the application and prepare the calculation was a piece of cake compared to OpenCL. That said, I tried to be as fair as possible and implemented both APIs with each of their advantages, but still rely on the same algorithms and the same basic optimizations. I've also adjusted the OpenCL code a little bit to get them closer together, so the new version might differ a few milliseconds from the results of 1.2. Please use the new version as of now. As requested I added two more digits to reach: 20B and 32B. Smaller graphics cards and CPUs will have to crunch those for days. Karl would have loved it! Have a fun and let me know your results and what you think! Download: GPUPI Beta 1.3

I'm currently testing the CUDA implementation with 32B digits. Takes about 50 minutes on a GTX 980 with stock clocks. Long enough? I will release version 1.3 later today.

10B already takes about 15 minutes on my GTX 980. 20B would be possible without adapting the algorithm for higher precision. But I have to test. I am currently working on a CUDA implementation. Just curious to see how good the OpenCL implementation of NVIDIA really is.

Did you install the newest drivers? Are you sure they can handle OpenCL? If the device doesn't support double precision but can be detected on the system, it will get listed as ignored when starting the benchmark. I'm not sure about your cards, GTS 250 seems to have double support, I think. Detection is mostly a driver issue and has not much to with the benchmark itself.

Under 20 seconds with R9 290X. http://hwbot.org/submission/2673063_nata_58_gpupi___1b_radeon_r9_290x_19sec_690ms

No. It's pure OpenCL with C++. I used no libraries/APIs except pure WIN32, STL and of course OpenCL via the Intel SDK.

It should be easy. These DLLs are needed for every C++ application that's done in Visual Studio 2013. Just be sure to install the vcredist_x86.exe and run GPUPI.exe, the 32 bit version of the bench. Ignore the 64 bit version, even if you're on a 64 bit OS. It's not faster in any way.

Dinos, have you read the FAQ? What's the problem? Which graphics card are you using? No, it's not 1M, it's 1B. 1 BILLION! 1M is like 0.01 seconds or so.

I've seen no difference at all. High GPU core frequency is what counts, and of course choosing the best graphics card for the task. It seems like the R9 290 is the best choice so far, because it has a very good integer performance.

I renamed the bench to "GPUPI - 1B". And thanks! The first submissions are rolling in ... yeah! My GTX 980: http://hwbot.org/submission/2672629_

I've just found out that I can release the benchmark in a beta version myself. It's now listed in the Videocard benchmark list.

Yes. Target platform for compilation was Windows XP upwards. Please try it out, I didn't test it myself yet. But I wouldn't know of any advantage in doing that. Currently it seems like the newest drivers get the best results.

Thanks! I've already written Pieter on Facebook, but he seemed busy. He said that he will have a look tomorrow or so. The benchmark is already submitted to the HWBot application thingie.