What if Pascal Quadro cards run RTX?

[Jurrunio]

Spoiler

Nvidia claims that Pascal Geforce is much worse than Turing Geforce in raytracing because it can only brute force it with single precision ALUs while Turing has extra stuff doing the heavy work, but what if Pascal Quadro is used? Quadro (and Tesla cards on that) are significantly faster than Geforce in floating point ops, what if Quadro can put that into use when it comes to brute forcing raytracing? Not expecting it to beat Turing tbh, but at least it shouldn't be as bad as PAscal Geforce cards right?

[Mira Yurizaki]

21 minutes ago, Jurrunio said:

  Reveal hidden contents

Nvidia claims that Pascal Geforce is much worse than Turing Geforce in raytracing because it can only brute force it with single precision ALUs while Turing has extra stuff doing the heavy work, but what if Pascal Quadro is used? Quadro (and Tesla cards on that) are significantly faster than Geforce in floating point ops, what if Quadro can put that into use when it comes to brute forcing raytracing? Not expecting it to beat Turing tbh, but at least it shouldn't be as bad as PAscal Geforce cards right?

Qaudros aren't any different than GeForce GPUs, save for FP64 performance in the higher end models. However, that doesn't really matter anyway since it's likely FP64 isn't being used.

[Wh0_Am_1]

19 minutes ago, Jurrunio said:

  Reveal hidden contents

Nvidia claims that Pascal Geforce is much worse than Turing Geforce in raytracing because it can only brute force it with single precision ALUs while Turing has extra stuff doing the heavy work, but what if Pascal Quadro is used? Quadro (and Tesla cards on that) are significantly faster than Geforce in floating point ops, what if Quadro can put that into use when it comes to brute forcing raytracing? Not expecting it to beat Turing tbh, but at least it shouldn't be as bad as PAscal Geforce cards right?

Pascal cards still lack tensor cores, and as the Pascal Quadro cards use the same basic GPUs with more VRAM and compatibility for a few more compute workloads, I would expect the Pascal Quadro cards to perform much like unto their mainstream brethren. 

[Jurrunio]

@Mira Yurizaki @Wh0_Am_1 I know Geforce and Quadro are the same when they come out from the fab, it's the software that makes them different in number crunching. what if the same "optimization" hack more performance out?

[Mira Yurizaki]

21 minutes ago, Jurrunio said:

@Mira Yurizaki @Wh0_Am_1 I know Geforce and Quadro are the same when they come out from the fab, it's the software that makes them different in number crunching. what if the same "optimization" hack more performance out?

The optimizations that Quadros have over GeForce cards is typically for rasterized graphics. The thing with ray tracing is it's a very simple algorithm. This code:

#include <stdlib.h>   // card > aek.ppm
#include <stdio.h>
#include <math.h>
typedef int i;
typedef float f;
struct v {
    f x,y,z;
    v operator+(v r) {
        return v(x+r.x
                 ,y+r.y,z+r.z);
    } v operator*(f r) {
        return
            v(x*r,y*r,z*r);
    } f operator%(v r) {
        return
            x*r.x+y*r.y+z*r.z;
    } v() {} v operator^(v r
                        ) {
        return v(y*r.z-z*r.y,z*r.x-x*r.z,x*r.
                 y-y*r.x);
    } v(f a,f b,f c) {
        x=a;
        y=b;
        z=c;
    } v
    operator!() {
        return*this*(1/sqrt(*this%*
                            this));
    }
};
i G[]= {247570,280596,280600,
        249748,18578,18577,231184,16,16
       };
f R() {
    return(f)rand()/RAND_MAX;
}
i T(v o,v d,f
    &t,v&n) {
    t=1e9;
    i m=0;
    f p=-o.z/d.z;
    if(.01
            <p)t=p,n=v(0,0,1),m=1;
    for(i k=19; k--;)
        for(i j=9; j--;)if(G[j]&1<<k) {
                v p=o+v(-k
                        ,0,-j-4);
                f b=p%d,c=p%p-1,q=b*b-c;
                if(q>0
                  ) {
                    f s=-b-sqrt(q);
                    if(s<t&&s>.01)t=s,n=!(
                                                p+d*t),m=2;
                }
            }
    return m;
}
v S(v o,v d) {
    f t
    ;
    v n;
    i m=T(o,d,t,n);
    if(!m)return v(.7,
                       .6,1)*pow(1-d.z,4);
    v h=o+d*t,l=!(v(9+R(
                    ),9+R(),16)+h*-1),r=d+n*(n%d*-2);
    f b=l%
        n;
    if(b<0||T(h,l,t,n))b=0;
    f p=pow(l%r*(b
                 >0),99);
    if(m&1) {
        h=h*.2;
        return((i)(ceil(
                       h.x)+ceil(h.y))&1?v(3,1,1):v(3,3,3))*(b
                               *.2+.1);
    }
    return v(p,p,p)+S(h,r)*.5;
} i
main() {
    printf("P6 512 512 255 ");
    v g=!v
        (-6,-16,0),a=!(v(0,0,1)^g)*.002,b=!(g^a
                                           )*.002,c=(a+b)*-256+g;
    for(i y=512; y--;)
        for(i x=512; x--;) {
            v p(13,13,13);
            for(i r
                    =64; r--;) {
                v t=a*(R()-.5)*99+b*(R()-.5)*
                    99;
                p=S(v(17,16,8)+t,!(t*-1+(a*(R()+x)+b
                                         *(y+R())+c)*16))*3.5+p;
            }
            printf("%c%c%c"
                   ,(i)p.x,(i)p.y,(i)p.z);
        }
}

Produces this image:

 

The problem with ray tracing is simply how many data points you have to sample. The only way to "optimize" ray tracing is to dump data points.

 

EDIT: Code and image came from https://fabiensanglard.net/rayTracing_back_of_business_card/

Edited April 18, 2019 by Mira Yurizaki
Pretiified the C code

[Jurrunio]

19 minutes ago, Mira Yurizaki said:

The only way to "optimize" ray tracing is to dump data points.

that's why even Turing cards need denoiser for the results and at the process cause artifacts when it's not optimized enough?

[Mira Yurizaki]

14 minutes ago, Jurrunio said:

that's why even Turing cards need denoiser for the results and at the process cause artifacts when it's not optimized enough?

Yes, because it's not sampling enough rays to make a clean enough image. Let's take example an image on Wikipedia:

 

Starting from the top left, only one ray per pixel is sampled. It doubles as you go on. If you want to call the third to the last image as the minimum for not seeing an appreciable amount of noise, this is around 8000 samples per pixel. The RTX 2080 Ti is capable of 10 GR/sec. So if you want the quality of the 8000 sample image at 60 FPS with the performance the RTX 2080 Ti, the image resolution is capped at about 160x120. If you went with the 8th image (2nd row, 4th column), you only need 128 samples per pixel, and you could reasonably clean that up to something acceptable.

 

I don't know what really goes on under the hood, but this is the quantity of work you have to deal with.

[Jurrunio]

10 hours ago, Mira Yurizaki said:

I don't know what really goes on under the hood, but this is the quantity of work you have to deal with.

so that's why older graphics are all different means of faking physics...