[QUOTE=kladner;310054]
EDIT: If an FFT is specified, why does CL go through the Auto routine anyway?[/QUOTE]

Just because the user said to do something doesn't mean it will work.

I'll run a Linux test later today.

[QUOTE=Dubslow;310055]Just because the user said to do something doesn't mean it will work.

I'll run a Linux test later today.[/QUOTE]

OK, thanks.

One further note, I did try a DC but got the same kind of result, so it would not seem that the exponent itself is the problem.

FWIW, I got my display running on the GTX 570 and ran OCCT on it for about 15 minutes. No errors reported. However, here is yet another -r run which craps out at the end.
[CODE]E:\CUDA>CUDALucas-2.04-Beta-3.2-sm_13-x64 -r

(ALL RESIDUE CORRECT RESPONSES REMOVED TO COMPLY WITH POSTING LIMITS)

Starting M2976221 fft length = 160K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 160K
Starting M2976221 fft length = 192K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 192K
Starting M2976221 fft length = 240K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.49900 >= 0.35, increasing n from 240K
Starting M2976221 fft length = 256K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration 100, average error = 0.00000, max error = 0.00000
Iteration = 144 < 1000 && err = 0.50000 >= 0.35, increasing n from 256K
Starting M2976221 fft length = 288K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 48 < 1000 && err = 0.50000 >= 0.35, increasing n from 288K
Starting M2976221 fft length = 320K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 320K
Starting M2976221 fft length = 384K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 384K
Starting M2976221 fft length = 480K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 480K
Starting M2976221 fft length = 512K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 512K
Starting M2976221 fft length = 576K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 576K
Starting M2976221 fft length = 640K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 640K
Starting M2976221 fft length = 768K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 768K
Starting M2976221 fft length = 864K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 864K
Starting M2976221 fft length = 960K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 960K
Starting M2976221 fft length = 1024K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1024K
Starting M2976221 fft length = 1152K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1152K
Starting M2976221 fft length = 1280K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1280K
Starting M2976221 fft length = 1440K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1440K
Starting M2976221 fft length = 1536K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1536K
Starting M2976221 fft length = 1600K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1600K
Starting M2976221 fft length = 1728K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1728K
Starting M2976221 fft length = 1920K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 1920K
Starting M2976221 fft length = 2048K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2048K
Starting M2976221 fft length = 2304K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2304K
Starting M2976221 fft length = 2400K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2400K
Starting M2976221 fft length = 2560K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2560K
Starting M2976221 fft length = 2880K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2880K
Starting M2976221 fft length = 3072K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3072K
Starting M2976221 fft length = 3200K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3200K
Starting M2976221 fft length = 3456K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3456K
Starting M2976221 fft length = 3840K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.49709 >= 0.35, increasing n from 3840K
Starting M2976221 fft length = 4000K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration 100, average error = 0.00000, max error = 0.00000
Iteration 200, average error = 0.01625, max error = 0.25000
Iteration 300, average error = 0.01083, max error = 0.00000
Iteration 400, average error = 0.00813, max error = 0.00000
Iteration 500, average error = 0.00650, max error = 0.00000
Iteration 600, average error = 0.00542, max error = 0.00000
Iteration 700, average error = 0.00464, max error = 0.00000
Iteration 800, average error = 0.00406, max error = 0.00000
Iteration = 848 < 1000 && err = 0.50000 >= 0.35, increasing n from 4000K
Starting M2976221 fft length = 4096K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration 100, average error = 0.04760, max error = 0.31731
Iteration = 144 < 1000 && err = 0.50000 >= 0.35, increasing n from 4096K
Starting M2976221 fft length = 4608K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration 100, average error = 0.04683, max error = 0.22884
Iteration 200, average error = 0.04091, max error = 0.25000
Iteration 300, average error = 0.02728, max error = 0.00000
Iteration 400, average error = 0.02046, max error = 0.00000
Iteration 500, average error = 0.01637, max error = 0.00000
Iteration 600, average error = 0.01364, max error = 0.00000
Iteration 700, average error = 0.01169, max error = 0.00000
Iteration 800, average error = 0.01023, max error = 0.00000
Iteration 900, average error = 0.00909, max error = 0.00000
Iteration 1000, average error = 0.00819 < 0.25 (max error = 0.00000), continuing test.
Iteration = 1887 >= 1000 && err = 0.5 >= 0.35, fft length = 4608K, writing checkpoint file (because -t is enabled) and exiting.
[/CODE]

Hmm.... does this happen for 2.03?

And this doesn't happen for the 460|2.04?

(Edit: Perchance, could you try disabling -t/CheckRoundoffAllIterations? It might not make any difference at all, but if it does...)

Ok, at this point we have (using latest 2.04 beta):

- 4.0 | 2.0 and 3.2 | 1.3 do the same thing
- Self test (-r) fails at M2976221 on both versions
- Your memtestG80 passes
- Your OCCT passes
- Sometimes your M46069867 run works sometimes not
- A DC did the same thing
- Starting with different FFT lengths doesn't really help
- Don't know yet if the 460 works or not with CuLu
- Don't know yet if 2.03 works with the 460 or 570

I'm sure I missed something, so please fill in the gaps, as necessary.

I'm suspecting drivers, maybe? Does anyone have any ideas besides drivers?

@klander: Can you give some background for the driver probelm? Are you able to completely uninstall ALL nVidia software, restart and then reinstall the newest drivers (not beta)?

[QUOTE]- Don't know yet if the 460 works or not with CuLu
- Don't know yet if 2.03 works with the 460 or 570 [/QUOTE]

The 460 does fine with 2.03 and 2.04. I swapped the tasks back again and ran -r, which completed successfully. (only tested with 3.2|1.3)

The 570 fails the self-test in 2.03 and 2.04. (only tested with 3.2|1.3 in 2.03)

You are largely complete in the rest of your list.

@Dubslow: I'll try disabling -t at some point. I have tended to suspect drivers as Jerry does.

[QUOTE]@klander: Can you give some background for the driver probelm? Are you able to completely uninstall ALL nVidia software, restart and then reinstall the newest drivers (not beta)? [/QUOTE]

When I added the 570 to the existing setup I had to reinstall drivers. Initially, I put 4x mfaktc on the 570 and started running CuLu on the 460. While watching things run I saw that mfaktc was being CPU starved.

I went on at more length in an earlier post, but through searching I found a utility called Process Explorer on an MS Technet site. It showed that as I started up instances of mfaktc, the CPU was being loaded by "Interrupts" from ~6-12%. This was also impacting Prime95 running P-1. After many attempts I found that really diligent uninstallation, registry cleaning, use of a program called Drive Fusion (cleans things out), working in Safe Mode, etc. etc.

In short, yes, I can wipe out drivers and get versions installed which don't have the crippling effect on mfaktc. CuLu seems to have called attention to other issues.

While blaming drivers is a more comforting thought, I have to admit that all this calls the hardware (570) into question, too.

Thanks for all your efforts, guys. I will pursue this again in a few hours. I'm committed to firing up some charcoal and doing brats and burgers.

[OT] For anyone in the Chicago area, you can't beat Paulina Meat Market. They have the finest fresh pork brats I've ever eaten, and their ground chuck beats anything you can get at a supermarket. [/OT]

[QUOTE=kladner;310067]I went on at more length in an earlier post, but through searching I found a utility called Process Explorer on an MS Technet site. It showed that as I started up instances of mfaktc, the CPU was being loaded by "Interrupts" from ~6-12%. This was also impacting Prime95 running P-1. After many attempts I found that really diligent uninstallation, registry cleaning, use of a program called Drive Fusion (cleans things out), working in Safe Mode, etc. etc.[/QUOTE]
I'm a bit confused about the "Interrupts". What exactly do you mean? mfaktc is suppopsed to use about 1 core per instance. The exact amount certainly depends on your GPU and CPU, among other things.

For example, I can run 6 instances of mfaktc (.19) on my 580, which leaves enough overhead to run a P-1 and still be able to use the computer. The P-1 slows down quite a bit when I run mfaktc, but I don't mind because TF is the main goal.

Anyway, are you trying to make mfaktc not us the CPU, or is it something else?

Edit: Can you do something for me?

- Uninstall ALL nVidia software
- Make sure mfaktc won't run upon reboot
- Download the newest (non-beta) nVidia drivers
- Shutdown and remove the 460
- Make sure the 570 is in the primary PCI-e slot
- Reboot into Windows
- Let Windows install the video card (reboot if it asks)
- Reboot if you didn't already here ^^^
- Install nVidia's drivers, leave everything default
- Reboot again
- Try a clean CUDALucas self-test run and let us know the results.

(The fact that the 460 works fine concerns me, but let's narrow down the drivers issue first)

[QUOTE=flashjh;310077]I'm a bit confused about the "Interrupts".
...............
Anyway, are you trying to make mfaktc not us the CPU, or is it something else?

Edit: Can you do something for me?

- Uninstall ALL nVidia software
- Make sure mfaktc won't run upon reboot
- Download the newest (non-beta) nVidia drivers
- Shutdown and remove the 460
- Make sure the 570 is in the primary PCI-e slot
- Reboot into Windows
- Let Windows install the video card (reboot if it asks)
- Reboot if you didn't already here ^^^
- Install nVidia's drivers, leave everything default
- Reboot again
- Try a clean CUDALucas self-test run and let us know the results.

(The fact that the 460 works fine concerns me, but let's narrow down the drivers issue first)[/QUOTE]

To answer the second question first, you have outlined something I have been mulling over. The 570 has never seemed quite fully integrated. By itself, it shows full capability in GPUZ. In fact, now that it is driving the display it shows full capability. See the attached for both the Interrupt issue and for which card reports CUDA etc. Previously, the 570 had the boxes unchecked which the 460 now has unchecked. This is despite the fact that the 570 ran mfaktc just fine while saying no CUDA, and the 460 is running CuLu as I write.

I have Affinity set for each instance of mfaktc, one Phenom II core each. To begin to saturate the 570 takes 4 instances, and it helps to OC the CPU and throttle the GPU. However, heat issues this time of year lead to throttling everying.

One other thing I found is that the 2 3D nVidia drivers frequently glitch during install, with error messages, but not aborting. Also, after a recent install [U]with[/U] 3D drivers I had "nvstlink.exe" consuming as much CPU as a properly functioning mfaktc instance while performing no known function. Meanwhile, 2 mfaktc instances were running at about half their normal throughput. Uninstalling the 3D, and 3D Control drivers and rebooting put a stop to that. Since I don't game with 3D glasses, or much at all, I don't think I'll miss it.

I think you are correct in your prescription of getting one thing going at a time with a very clean driver install. I will use it as a reference. Thanks!

The Hardware Interrupt item shows in the Process Explorer capture, but at a fairly restrained level. On what I have taken to be "bad driver installs," that might be consuming more than 10% CPU instead of 1-2% or less with mfaktc running in 3-4 instances.

There's a lot of this I can't explain. I have observed some reproducible (on this machine) behavior. This includes things like the "Interrupt Load" going up and down as I started or stopped mfaktc instances during a "Bad Driver Episode". I am putting some things in quotes because that's just how I think of them. I cannot be sure what's really happening.

I'll post results when I have a chance to tear things down on the hardware and software fronts. I [I]have[/I] come to see that sometimes sequence, and overkill search and destroy in wiping out drivers, can make a difference. I've worked up quite a double checking routine. It's amazing how things with "nvidia" in the name can creep back in.

GTX 570 first attempt
 

I'll have another shot at it in the morning. This one still crapped out.

Latest attempt GTX 570
 

[QUOTE](Edit: Perchance, could you try disabling -t/CheckRoundoffAllIterations? It might not make any difference at all, but if it does...) [/QUOTE]The latest run is attached. -t is disabled in the ini, but the self-test seems to use it anyway.

This is following the cleaned out driver reinstall, with only the 570 installed. I'm going to have another go at it.

EDIT: This test run hung up on M859433 instead of the 29M which usually stops it.

Continued testing
 

This is immediately after a default install of 301.42. The self-test failed again, as did an attempt to just run CuLu. This is with Check Roundoff disabled in the ini. The last two lines below are ones I've not seen before. Would it be worth a go with Threads=512? I guess I'll find out.

[CODE]Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.

E:\CUDA\2.04-BETA>CUDALucas-2.04-Beta-3.2-sm_13-x64

mkdir: cannot create directory `savefiles': File exists
Starting M46069867 fft length = 2304K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2304K
Starting M46069867 fft length = 2400K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2400K
Starting M46069867 fft length = 2560K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2560K
Starting M46069867 fft length = 2880K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 2880K
Starting M46069867 fft length = 3072K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3072K
Starting M46069867 fft length = 3200K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3200K
Starting M46069867 fft length = 3456K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3456K
Starting M46069867 fft length = 3840K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 3840K
Starting M46069867 fft length = 4000K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 4000K
Starting M46069867 fft length = 4096K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 4096K
Starting M46069867 fft length = 4608K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 4608K
Starting M46069867 fft length = 4800K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 4800K
Starting M46069867 fft length = 5120K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 5120K
Starting M46069867 fft length = 5760K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 5760K
Starting M46069867 fft length = 6144K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 6144K
Starting M46069867 fft length = 6400K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 6400K
Starting M46069867 fft length = 6912K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 6912K
Starting M46069867 fft length = 7680K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 7680K
Starting M46069867 fft length = 8000K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 8000K
Starting M46069867 fft length = 8192K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 8192K
Starting M46069867 fft length = 9216K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 9216K
Starting M46069867 fft length = 9600K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 9600K
Starting M46069867 fft length = 10240K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 32 < 1000 && err = 0.50000 >= 0.35, increasing n from 10240K
Starting M46069867 fft length = 11520K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 11520K
Starting M46069867 fft length = 12288K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 12288K
Starting M46069867 fft length = 12800K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 12800K
Starting M46069867 fft length = 13824K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 13824K
Starting M46069867 fft length = 15360K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 15360K
Starting M46069867 fft length = 16000K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 16000K
over specifications Grid = 65536
try increasing threads (256) or decreasing FFT length (16384K)[/CODE]EDIT: No Joy.
[CODE]Iteration = 16 < 1000 && err = 0.50000 >= 0.35, increasing n from 32000K
over specifications Grid = 65536
try increasing threads (512) or decreasing FFT length (32768K)[/CODE]The tail end of another -r run, after another housecleaning and Safe mode reinstall of 301.42.[CODE]Starting M3021377 fft length = 4608K
Running careful round off test for 1000 iterations. If average error >= 0.25, the test will restart with a larger FFT length.
Iteration 100, average error = 0.00000, max error = 0.00000
Iteration 200, average error = 0.00000, max error = 0.00000
Iteration 300, average error = 0.00000, max error = 0.00000
Iteration 400, average error = 0.00000, max error = 0.00000
Iteration 500, average error = 0.00000, max error = 0.00000
Iteration 600, average error = 0.00000, max error = 0.00000
Iteration 700, average error = 0.00000, max error = 0.00000
Iteration 800, average error = 0.00000, max error = 0.00000
Iteration 900, average error = 0.00000, max error = 0.00000
Iteration 1000, average error = 0.00000 < 0.25 (max error = 0.00000), continuing test.
Iteration = 1960 >= 1000 && err = 0.5 >= 0.35, fft length = 4608K, writing checkpoint file (because -t is enabled) and exiting.[/CODE]

NOTE: This driver install qualifies as "Good" by the standard of running mfaktc without heavy CPU usage by Interrupts.