quic envsim: radiative heat transfer in vegetative and...

QUIC EnvSim: Radiative Heat Transfer in Vegetative and UrbanEnvironments with NVIDIA OptiX

Matthew Overby1

Scot Halverson2, Brian Bailey3, Pete Willemsen1, Rob Stoll3, Eric Pardyjak3

1Department of Computer Science University of Minnesota Duluth, Duluth, MN, USA

2Los Alamos National Laboratory Los Alamos, NM, USA

3Department of Mechanical Engineering University of Utah, Salt Lake City, UT, USA

March 27, 2014GTC 2014, San Jose CA

This material is based upon work supported by the National Science Foundation under Grants No. 1133590, 0828206, CBET-PDM 113458, EPS 1208732, and AGS 1255662.Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National ScienceFoundation.

NVIDIA OptiX Ray Tracing Engine

NVIDIA OptiX:

GPU-accelerated raytracing engine

Versitile and flexible

Ray Tracing: Tracking a ray through a virtualenvironment by using ray surface intersections tests

2/31 Matt Overby - Urban Radiation Transfer with OptiX

QUIC EnvSim and the GEnUSiS Project

Our goal is to understand the complexinteractions between the environment and

urban form

QUIC EnvSim is a part of the Green Environmental Urban Simulations for Sustainability(GEnUSiS) project: http://d.umn.edu/∼sivelab/project/genusis


http://d.umn.edu/~sivelab/project/genusis

Introduction

Radiation in Urban Domains

Multi-GPU Considerations


Radiation Transferis a driving force of urban climate


Material Interactions


Radiation Equation for Urban Domains

Rnet = R↓PAR + R↓

NIR + R↓` − R↑

` Instead of visible light, we model:

RPAR : Photosynthetically active radiation

RNIR : Near-infrared radiation

R`: Longwave radiation

Radiation is emitted from:

Sun

Sky (diffuse)

Surfaces and Vegetation


We need to compute the energy at all ground and building surfaces

[image: Incoming solar radiation of downtown Salt Lake City, Utah]


A Challenger Appears...

Vegetation:

Needed for a realistic urban domain

Grows in complex and irregularshapes

Thousands of different species in acity


Discretization of Vegetation

Vegetation is discretized into volumes of abitrary size

Branches and leaves are treated as homogenous cells

Can simulate other forms of participating media

Each volume can have unique physical properties

Mesh of cubes = fast intersections


Scattering Phase Function

Scattering Phase Function:

Determines direction of scattered energy

Dependent on:

Incoming ray angleRadiation wavelengthLeaf angle distributionTransmissivity, absorptivity, and reflectivity


Step 1: Absorption and Transmission

(1) Rays continue to transmit until they run out of energy

A fraction of the energy is absorbed and transmitted

Scattered is stored for later based on ray angle (”to-be-scattered energy”)

This allows energy to reach into dense canopies


Step 2: Scattering

(2) To-be-scattered energy is emitted from all volumes

Each ray’s energy is adjusted according to scattering phase function

Reduces computation by scattering all energy at once

Go back to (1), repeat until all energy has been absorbed somewhere


Introduction

Radiation in Urban Domains

Multi-GPU Considerations


Memory in OptiX

Buffers:

Temporary arrays for transferring data between host and device

Can be defined as INPUT, OUTPUT, or INPUT OUTPUT

In QUIC EnvSim:

Many input-output buffers to store absorbed energy

Both host and device need read and write access


Concurrent Writes

A common problem during absorption:

Multiple rays can hit the sameobjects at the same time

Atomic addition locks memorylocation

Ray Y must wait for Ray X to finishwriting to buffer index of Patch 1


Multiple GPUs

Default:RT BUFFER OUTPUT andRT BUFFER INPUT OUTPUTare stored on the host

Problems:

Atomics not guaranteed acrossmultiple GPUs

Slow read and write access


Flag Buffers with RT BUFFER GPU LOCAL

Note: You can only do this with INPUT OUTPUT buffers


Device Local Buffers

Benefits:Each device has local copy

Atomics guaranteed

Faster reads and writes

Caveats:Now have different copies of the same buffer

Host no longer has read access through OptiX

Must post-process with CUDA


Post-Process with CUDA

(A) Energy is seperately and atomically written to on each device(B) Copy all buffers to one device(C) Join (for absorption we sum) with CUDA(D) Distribute joined buffer to all devices, and deallocate copies


Settings:

2 × Tesla S2050

Red: Default buffersettings

Blue: GPU-local buffers


2 Million Vegetation Volumes


Typical Use Case of QUIC EnvSim: Diurnal Cycle

Measure net radiation from sun up to sun down

More energy during the day means morecomputational complexity


Settings:

Red: 1 × Tesla S2050

Green: 2 × Tesla S2050

Blue: 4 × Tesla S2050


QUIC EnvSim:Simulates the complex interactions between the environment andurban form

Designed to run on personal and professional workstations


NVIDIA OptiX:Can be used for more than computer graphics

Greatly simplifies GPU-accelerated ray tracing, but-

You still have to be careful with your data


Thanks for Attending!

Matthew [email protected]

Department of Computer ScienceUniversity of Minnesota Duluth, Duluth, MN, USA

This material is based upon work supported by the National Science Foundation under Grants No. 1133590, 0828206, CBET-PDM 113458, EPS 1208732, and AGS1255662. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views ofthe National Science Foundation.


Example Code: OptiX

int type = RT_BUFFER_OUPUT | RT_BUFFER_GPU_LOCAL;

optix::Buffer buffer = context->createBuffer( type );

...

optix::Buffer buffer = context[ "output" ]->getBuffer();

buffer->map();

void *buffer_device0 = 0; void *buffer_device1 = 0;

rtBufferGetDevicePointer( optixBuff->get(), 0, &buffer_device0 );

rtBufferGetDevicePointer( optixBuff->get(), 1, &buffer_device1 );

host_sum( n_elements, buffer_device0, buffer_device1 ); \\ Call CUDA Function

\\ Use cudaMemcpyDeviceToHost if you want to...

buffer->unmap();

Note: If rtBufferGetDevicePointer is not called on every GPU, OptiX will copy a buffer’s contents to otherbuffers on the next rtContextLaunch. This can be avoided with RT BUFFER COPY ON DIRTY.


Example Code: CUDA (post-processing)

void host_sum( int n_elements, void* buffer_device0, void *buffer_device1 ){

...

cudaSetDevice(0); \\ Do sum on device 0

float *gpu1_copy; \\ Need to copy device 1’s data to device 0

cudaMalloc( (void**) &gpu1_copy, 4*n_elements );

cudaMemcpyPeer( gpu1_copy, 0, buffer_device1, 1, 4*n_elements ); \\ (B)

device_sum<<< ... >>>( (float*)buffer_device0, gpu1_copy ); \\ (C)

cudaMemcpyPeer( buffer_device1, 1, buffer_device0, 0, 4*n_elements ); \\ (D)

cudaFree(gpu1_copy); \\ Remember to deallocate copies!

}

__global__ void device_sum( float *buffer_device0, float *buffer_device1 ){

...

float result = buffer_device0[index] + buffer_device1[index];

buffer_device0[index] = result;

}


Problem: Concurrent Writes

A Simple Solution:

Reduce concurrent writes byincreasing the size of the buffer

Alter the index by subsection

The number of subsections isthe scaling factor:

Minimize to save GPU memory

Optimal value varies with scene andsimulation


Empirical experiment:

8192 rays per meter2

NVIDIA Quadro 2000 (1GB)

Sun and Sky Viewfactors

Example Sun Viewfactor = 0.5


quic envsim: radiative heat transfer in vegetative and...

Documents