I think we did upgrade the RAM not too long ago. But yes, a shiny new server with some SSDs would be lovely. When I bitch everyone out monday (for breaking everything and letting me know at 2am this tuesday), i'll be sure to bring it up.

And I was just finally making some progress with DNA@Home. :P

Geez, I don't think Heidi even told me about that grant. :P But I think when a grant is awarded it takes some time before we actually get the money. Chances are some of it will be used for upgrades whenever it comes in.

Well it was posted almost a month ago. I guess you better talk to her soon ;)
A resonable 5 to 6k$ would get you finally some nice server and headrome to operate MW properly.

Our big problem is really with MYSQL keeping up (especially if we upgrade the ATI application ever). I think we need some kind of distributed database.

Geez, I don't think Heidi even told me about that grant. :P But I think when a grant is awarded it takes some time before we actually get the money. Chances are some of it will be used for upgrades whenever it comes in.

At some point after I get the new ATI application ready things will start breaking for old stuff.

Is it already known if the new ATI application will have the same requirements as the old one i.e. will it run on all ATI GPUs listed in the GPU Requirements Thread?

Yes, it should.

except for the fact that OpenCL runs only on HD 4xxx and higher (so no more 3xxx)...
In addition, if you use any OpenCL 1.1 instruction, then only HD 5xxx and above will work...

This is not THE big news; we are still finalizing details so I can't say anything more.

-Matthew

what is the treshold temperature for 6950? is it safe to run this card 7/24 at 80-88 celcius / 175-190 Fahrenheit? so far no problem but is there any risk?

did i missed something?

It's still coming. I was going to put up something to test with a few weeks ago but then I got sidetracked with lots of other things.

Thanks. I downloaded, unzipped and ran the program. It appears I need some instructions on how to use it. I found a txt file called stderr. Here is what is reports from my last attempted run.

I bet the database problems have something to do with this....

Probably... the last stats export is dated 25-Jan-2011 00:10

Anyway, i find i hard to believe that either repairing the team table or reimporting it from the the "boinc wide teams" can take that long...

I'd guess someone's not considering it to be of any importance at all :(

Seems that something has gone on at MW.

The credit for de_separation_23_3s is 220.xx, instead of the 214 that has been the norm for some time.

Please admin, stop workflow if we do not get credit for task.
upload/download server online...

The credit is being awarded, just the info isn't being sent out to the stat sites.

I bet the database problems have something to do with this....

What is 'the opti app.'? I have just installed an ASUS GTX480 and all work ends up in calculation error.
Boinc shows: NVIDIA GPU 0: GeForce GTX 480 (driver version 26099, CUDA version 3020, compute capability 2.0, 1503MB, 778 GFLOPS peak)

int choose_cuda_13()
{
  //check for and find a CUDA 1.3 (double precision)
  //capable card
  int device_count;
  cutilSafeCall(cudaGetDeviceCount(&device_count));
  fprintf(stderr, "Found %d CUDA cards\n", device_count);
  if (device_count < 1)
    {
      fprintf(stderr, "No CUDA cards found, you cannot run the GPU version\n");
      exit(1);
    }
  int *eligable_devices = (int*)malloc(sizeof(int) * device_count);
  int eligable_device_idx = 0;
  int max_gflops = 0;
  int device;
  char *chosen_device = 0;
  for(int idx = 0;idx<device_count;++idx)
    {
      cudaDeviceProp deviceProp;
      cutilSafeCall(cudaGetDeviceProperties(&deviceProp, idx));
      fprintf(stderr, "Found a %s\n", deviceProp.name);
      if ((deviceProp.major == 1 && deviceProp.minor == 3) || deviceProp.major == 2)
	{
	  eligable_devices[eligable_device_idx++] = idx;
	  fprintf(stderr, "Device can be used it has double precision support\n");
	  //check how many gflops it has
	  int gflops = deviceProp.multiProcessorCount * deviceProp.clockRate;
	  if (gflops >= max_gflops)
	    {
	      max_gflops = gflops;
	      device = idx;
	      if (chosen_device)
		free(chosen_device);
	      chosen_device = (char*) malloc(sizeof(char) * strlen(deviceProp.name)+1);
	      strncpy(chosen_device, deviceProp.name, strlen(deviceProp.name));
	      chosen_device[strlen(deviceProp.name)] = '\0';
	    }
	}
      else
	{
	  fprintf(stderr, "Device cannot be used, it does not have double precision support\n");
	}
    }
  free(eligable_devices);
  if (eligable_device_idx < 1) {
    fprintf(stderr, "No compute capability 1.3 or 2.x cards have been found, exiting...\n");
    free(chosen_device);
    return -1;
  } else {
    fprintf(stderr, "Chose device %s\n", chosen_device);
    cutilSafeCall(cudaSetDevice(device));  
    free(chosen_device);
    return device;
  }
}

static inline __m128d _mm_fexp_poly_pd(__m128d x1) // precise,but slower than _mm_exp_pd
{
/*remez11_0_log2_sse*/
__m128i k1;
__m128d p1,a1;
__m128d xmm0, xmm1;

const __m128i offset = _mm_setr_epi32(1023, 1023, 0, 0);
x1 = _mm_min_pd(x1, _mm_set1_pd( 129.00000));
x1 = _mm_max_pd(x1, _mm_set1_pd(-126.99999));

        xmm0 = _mm_load_pd(log2e);
        xmm1 = _mm_setzero_pd();
        a1 = _mm_mul_pd(x1, xmm0);
        /* k = (int)floor(a); p = (float)k; */
        p1 = _mm_cmplt_pd(a1, xmm1);
        p1 = _mm_and_pd(p1, DONE);
        a1 = _mm_sub_pd(a1, p1);
        k1 = _mm_cvttpd_epi32(a1); // ipart
        p1 = _mm_cvtepi32_pd(k1);
        /* x -= p * log2; */
        xmm0 = _mm_load_pd(c1);
        xmm1 = _mm_load_pd(c2);
        a1 = _mm_mul_pd(p1, xmm0);
        x1 = _mm_sub_pd(x1, a1);
        a1 = _mm_mul_pd(p1, xmm1);
        x1 = _mm_sub_pd(x1, a1);
        /* Compute e^x using a polynomial approximation. */

		xmm0 = _mm_load_pd(w11);
        xmm1 = _mm_load_pd(w10);

		a1 = _mm_mul_pd(x1, xmm0);
        a1 = _mm_add_pd(a1, xmm1);
        xmm0 = _mm_load_pd(w9);
        xmm1 = _mm_load_pd(w8);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm1);

		xmm0 = _mm_load_pd(w7);
        xmm1 = _mm_load_pd(w6);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm1);

        xmm0 = _mm_load_pd(w5);
        xmm1 = _mm_load_pd(w4);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm1);

        xmm0 = _mm_load_pd(w3);
        xmm1 = _mm_load_pd(w2);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm1);

        xmm0 = _mm_load_pd(w1);
        xmm1 = _mm_load_pd(w0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm0);
        a1 = _mm_mul_pd(a1, x1);
        a1 = _mm_add_pd(a1, xmm1);
        /* p = 2^k; */
        k1 = _mm_add_epi32(k1, offset);
        k1 = _mm_slli_epi32(k1, 20);
        k1 = _mm_shuffle_epi32(k1, _MM_SHUFFLE(1,3,0,2));
        p1 = _mm_castsi128_pd(k1);
        /* a *= 2^k. */
        return  _mm_mul_pd(a1, p1);

}
  

You got it .... its the source of much frustration, however, structuring the code this way is the only real alternative if the original design philosophy of complete software independence from any other factor is to be achieved. Many argue that its too much to chew on and the original design criteria is too ambitious. I'll leave the resolution of that one to the gurus ... greater minds than mine as they say rofl :)

Regards
Zy

Please forgive a simple question from a set-and-forget user.

I see a lot of talk here about 0.21 applications, and nbody applications. I appear to be running MilkyWay 0.19 only. Is there any benefit to getting later versions, and if so, how is it done?

Is there room for more opt. of the new CPU app?

In general, the 0.4s should be ~30% faster than before (and it is on Linux / OS X). It's only Windows where the 0.4s are very, very slow (over 200% slower than on the same hardware in Linux). I've figured out the main reason through, and have a temporary fix which hasn't been put on the servers yet. It turns out the combination of standard math library functions from the MSVCRT and the ones replaced by MinGW are pretty terrible. Building the separation with crlibm (which should actually be slower, and it is in Linux/OS X, since crlibm has slower, more precise math functions) actually ends up being much faster on Windows. Built with crlibm, it runs only 33% slower than in Linux, so about the same speed that the old ones would be. I have to come up with a better solution with faster / less precise math on Windows to get closer to Linux.

Why the GPUs didn't need a new app?

They do. We do not have the source for the ATI application, which is a major problem so I'm working on replacing it.

Yeah, his account shows 0 credits now. Only thing left todo is remove the equal amount (27,635,131.00) from his team credits as well.

Already done. :)