3D Fluid Simulation Sample

Transcription

1 Intel OpenCL SDK Sample Documentation Copyright Intel Corporation All Rights Reserved Document Number: US Revision: 1.3 World Wide Web: Document Number: US

2 Legal Information INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR. Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information. The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request. Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order. Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling , or go to Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. Go to: Software and workloads used in performance tests may have been optimized for performance only on Intel microprocessors. Performance tests, such as SYSmark and MobileMark, are measured using specific computer systems, components, software, operations and functions. Any change to any of those factors may cause the results to vary. You should consult other information and performance tests to assist you in fully evaluating your contemplated purchases, including the performance of that product when combined with other products. Intel, Intel logo, Intel Core, VTune, Xeon are trademarks of Intel Corporation in the U.S. and other countries. * Other names and brands may be claimed as the property of others. OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission by Khronos. Microsoft product screen shot(s) reprinted with permission from Microsoft Corporation. Copyright Intel Corporation. All rights reserved. 2 Document Number: US

3 Optimization Notice Intel s compilers may or may not optimize to the same degree for non-intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision # Intel OpenCL SDK Sample Documentation 3

4 Contents About Shallow Water Sample... 5 Path... 6 Introduction... 6 Motivation... 6 Algorithm... 7 Implementation details... 8 OpenCL Implementation Understanding OpenCL Performance Characteristics Benefits of Implicit Compiler Vectorization Work-group Size Considerations Limitations Future Work and Enhancements Project Structure Reference (Native) Implementation Additional requiremments APIs Used Controlling the Sample References Document Number: US

5 About Shallow Water Sample Shallow Water sample demonstrates shallow water modeling to visualize a water surface and uses the flux splitting method for solving Navier-Stokes approximation equations [2]. This sample demonstrates how to use shallow water solver in OpenCL. This implementation optimizes calculation process using implicit Single Instruction Multiple Data (SIMD) code vectorization performed by build-in OpenCL compiler vectorizer. Data level parallelism of the underlying algorithm gives additional performance gain. The algorithm receives current 2D maps of velocity and height, calculates updated maps for the next time step, and uses the updated maps for visualization. The sample improves the flux splitting method's performance due to SIMD code vectorization and data level parallelism and it also allows additional extensions, such as particle physics and middle scale wind waves synthesis. Intel OpenCL SDK Sample Documentation 5

6 Path Location Executable <INSTALL_DIR>samples\ShallowWater Win32\Release\ShallowWater.exe 32-bit executable x64\release\shallowwater.exe 64-bit executable Win32\Debug\ShallowWater.exe 32-bit debug executable x64\debug\shallowwater.exe 64- bit debug executable Introduction In the real world, there are various observable fluid effects. Such effects include water flow in a river, waves on a water surface, splash from a stone dropped in the pond, smoke, fire, and many more. Physical behavior and dynamics of such fluid effects are described by a system of Navier-Stokes equations. Obtaining an exact solution of these equations is a very complex and challenging task. Usually, some assumptions are made to simplify such systems and obtain a solution for a narrower class of fluid effects. In the sample, we describe a more physically accurate solution for a shallow water surface that includes random medium scale wind waves generation and buoyancy effects. Finally, a set of visual effects are used to emulate small ripples, flow effects on water surface, and reflection. Motivation A physically accurate water surface requires an approximate solution of complex nonlinear Navier-Stokes equations. In the shallow water model, a system of linear difference derivative equations is used, so that the problem can be solved in a reasonable amount of time. Calculation times scale linearly with the size of the grid, larger size water surface simulations, such as a sea or an ocean, require a larger number of calculations. From the equation solution, we obtain more physically accurate height and velocity maps that can be used as input for visualization and for 6 Document Number: US

7 adding additional effects, such as particle physics. The implemented shallow water model is fully interactive and accurately models water. In the game industry, water simulation effects are usually synthesized, scripted and not fully interactive because of the complexity of physically accurate models and the large number of calculations required from current GPUs and CPUs. The sample implementation minimizes grid data accesses and uses data-level parallelism. As a result, the sample has more accurate results when compared to applications that use the fluid effects optimized for traditional GPU architectures. This sample demonstrates a CPU-optimized implementation of the shallow water fluid effects and shows how to perform the following: Implement calculation kernels using OpenCL C99 Parallelize these kernels by running several work-groups in parallel Organize host-device data exchange Visualize results using pixel and vertex shaders (Microsoft* DirectX* 10). Algorithm Shallow water equations are the basis for describing waves in seas, rivers in a large domain, and gravity waves in a smaller scale domain [1]. These equations also describe other types of water motion, such as the advance of tsunami waves, waves near a shoreline, and water flow in pipe culverts [3]. A natural looking water surface, with light refractions and reflections, is widely used for special effects in movies. Game developers also give special attention to water surface modeling and also to objects interacting with water. Effective real-time implementation of water-modeling is very important, because time constraints often dictate development schedules. To achieve a natural looking water surface, we solve approximation of Navier-Stokes based equations which describe fluid physics. The solution of such a set of equations is necessary to achieve a more physically correct model of various types of fluids, such as smoke, fire, and water. Many approaches are used to solve Navier-Stokes derived equations, but not all approaches are applicable to real-time fluid modeling because of their computational complexity. For shallow water, where wave length is greater than water depth, we can effectively apply the method of flux vector splitting for solving Navier-Stokes approximation equations. This method is used for gas dynamic modeling and can also be effectively applied to shallow water modeling. Intel OpenCL SDK Sample Documentation 7

8 Solving these equations produces 2D maps of velocity and water surface height on a 2D grid, which can then be used to create a physically correct and natural looking water surface. This model also supports applying force to various parts of the water surface for more realistic results. The following figure shows water surface modeling for the sample: Implementation details The sample contains OpenCL, SSE/SSE2 and scalar C implementations of physically correct shallow water modeling. The OpenCL implementation is on by default. Height and velocity maps are calculated on the rectangular grid during each simulation time step. Velocity and height values in the current node and in the neighboring nodes are used for calculating the new height and velocity values in the node for the next time step. If the velocity directions and values in 4 sequential nodes are similar, these sequential nodes will be processed simultaneously using SIMD vector instructions. Atomic algorithm iteration calculates 4 velocity and height values in 4 sequential nodes in this case. This optimization meets only native versions of solver. One or more grid lines are assigned as a task for each working thread. The flux splitting method for the Navier-Stokes approximation equations solution is implemented. You can find details of this algorithm in reference [3]. 8 Document Number: US

9 The set of shallow water equations, including the continuity momentum equations, are: where H is the fluid depth, w is the fluid velocity vector, g is the gravitational constant, and d is the fluid depth, measured from the still-water surface. For numerically solving the set of equations (1), well-known gas dynamics solution methods are used [2]. If d is a constant (flat bottom), then equations (1) are equal to gas dynamics equations for isentropic flows with an adiabatic index of γ=2. On the other hand, prototypes of gas-dynamic density (ρ) and pressure (p) are defined by the equalities ρ=н, and (1b) Another important fact is that the gas-dynamics equation set satisfies energy conservation. If we insert density and pressure, as described above, into the energy equation, we get the following result: In equation (2), the total energy is as follows:. This is a sound velocity prototype in gas dynamics, calculated as: Where p is as 1b, ρ is density and γ is adiabat coefficient. Equation (2) is a consequence of (1) and is implicitly executed. Intel OpenCL SDK Sample Documentation 9

10 For the gas-dynamics equation, a vector fluid splitting layout is created [2]. The main advantage of this formalism is its energy conservatism: various difference equations reflect mass conservation, impulse, and energy laws, which are expressed by the reference differential equation on the computational mesh. While implementing this set of equations we use a specific property of gas dynamics equations, which is not true for shallow water equations. However, if you expand the system of shallow water equations by including the energy equation (2), this property will be true for the extended system. Then you can build the scheme of flux vector splitting, as is done for the gas dynamics equations, and skip the "energy" equation. For example, consider only the one dimensional case. (For the two dimensional case, the generalization is done automatically). We assume that d=const and that we have a homogeneous system (1), because the right part of the second equation in system (1) has insignificant contributions and so can be ignored. Rewriting the system, by component, where u is one dimensional velocity and is one dimensional coordinate, we get: Now we introduce a new independent variable M==Hu, which is a specific flux of mass; let p be an unknown vector, let F be a flux vector. This gives the following: Calculate the Jacobian matrix: For the gas-dynamics equations, the elements of the corresponding Jacobian matrix are homogeneous functions of their arguments. Accounting for Euler s theorem about homogeneous functions, we get the following equality that is a basis for all further calculations: 10 Document Number: US

11 Ap=F, (4) As you can see, the equality (4) is not true for our set of equations. Create an extended equation set adding the equation (2) to the system (3). Let s generate extended vectors p and F, where Create the Jacobian matrix: The elements of this matrix are homogeneous functions of their arguments and, therefore, the key equality is performed (4). Write the final extended Jacobian matrix Intel OpenCL SDK Sample Documentation 11

12 substituting Н, М, and Q with the respective formulae, taking into account the equality c2=gh: The eigenvalues of matrix A are the following: Create matrix L out of left eigen vectors of matrix A, and reciprocal matrix L-1 Use direct verification to make sure that the following equality is correct: Split matrix A into parts corresponding to positive and negative eigenvalues. In this regard, introduce every proper number in the following form: If then matrix A is the following: 12 Document Number: US

13 Add representation (6) to (4) to split the flow vector F into two components as follows: Doing the multiplications, we get the following: Thereby, the equation set (5) is converted to the following form: Truncate the equation equal to (2) and consider it (7) as a two-equation system, where This system is equivalent to equations (3). Consider possible special cases of the fluid flow and determine how the splitting of flow vectors proceeds. а) Let u>c>0, then u-c>0, u+c>0, u>0 (supercritical flow). Taking into consideration the following equalities from (8) This yields: b) Let u<-c<0, then u-c<0, u+c<0, u<0 (supercritical flow directed to the opposite side, compared to case a). From (8) we get the following: Intel OpenCL SDK Sample Documentation 13

14 c) Let 0<u<c, then u-c<0, u+c>0, u>0 (subcritical flow). Assuming that we will get the following from (8): d) Let с<u<0, then u-c<0, u+c>0, u<0 (subcritical flow directed to the opposite side, in comparison with the case c). From (8) we get the following: Approximate equation (7) by the counterflow difference scheme: which is the scheme of flux vector splitting. The indexes without a slash indicate the backward difference derivative by the corresponding variable, and indexes with a slash indicate the forward derivative [3]. A sine wave generator sets up boundary conditions on one edge of the simulated water surface grid to produce waves. Wind waves are produced as superpositions of random cylindrical waves which are added as distortion to the base shallow water model calculation result. OpenCL Implementation In this implementation, ProcessTile OpenCL kernel of ShallowWater.cl file uses flux splitting method to perform calculations. Every input grid tile corresponds to a unique global ID which the kernel uses to identify it. The full shallow water solver 14 Document Number: US

15 sequence consists of OpenCL kernel call performed in CFlux2DMethodOpenCLScalar::Step () function of solver \CFlux2DMethod.h file. This algorithm implementation consists of the ProcessNode function s calls from ProcessTile kernel. ProcessNode implements flux splitting algorithm and contains several branches depending on velocity directions and values. Understanding OpenCL Performance Characteristics Benefits of Implicit Compiler Vectorization The kernel structure enables implicit vectorization performed by Intel OpenCL SDK Offline Compiler when work-group size is multiple of four. Work-group Size Considerations You can specify any work-group size for the kernel. However, OpenCL implementation of the shallow water achieves peak performance for 256x256 two-dimensional grid with work-group size one or four tiles while global work size (total number of grid tiles) is equal or 4x of hardware threads number. The large global work size (number of tiles) results in additional overhead due to tiles stitching. Limitations The current implementation of water surface simulation is limited by the shallow water model. The wavelength of modeled waves is similar or greater than their depth. Such a model is called "2.5 D". There are no real 3D effects, such as overturning waves or splashes. The particle physics sample extension is required for these effects simulations. The implemented model correctly emulates water interaction with sea shores or river banks for the top portion but fails to simulate the bouncing off effect simulation from tall vertical boundaries. Intel OpenCL SDK Sample Documentation 15

16 Future Work and Enhancements The following sample extensions are possible: Particle physics effects including splashes, foam and overturning waves Piece-wise linear conditions support for correct bounce off effect Simplified shallow water model for a flat bottom. Project Structure <sample>\host\cscenevisual.h - This file contains the high level visualization routines implementation and declaration for the scene visualization in the shader. <sample>\host\csky.h - This file contains the sky visualization routines declarations. <sample>\host\cvisual3dbottom.h - This file contains the bottom visualization routines declarations. <sample>\host\cvisual3dcommondata.h - This file contains the common visualization routines declarations. <sample>\host\cvisual3dgathered.h - This file contains the visualization routines declarations for the gathered visualization mode which includes several water visualization effects. <sample>\host\cvisual3dinterface.h - This file contains the visualization effects interface declarations. <sample>\host\cvisual3dsimple.h - This file contains the visualization routines declarations for the simple height map visualization mode. <sample>\host\cvisual3dtexadvection.h - This file contains the visualization routines declarations for texture advections effects (gathered visualization mode). <sample>\common\physics_3d_fluid_sim_common.h - This file contains common information to share between the host and OpenCL sides. <sample>\shaders\advect.fx - This file contains the advected textures algorithm implementation. <sample>\shaders\bottom.fx - This file contains the bottom visualization shaders implementation. <sample>\shaders\gathered_sky.fx - This file contains the gathered visualization shaders implementation. 16 Document Number: US

17 <sample>\shaders\simple.fx - This file contains the simple visualization shaders implementation. <sample>\shaders\sky.fx - This file contains the sky visualization shaders implementation. <sample>\host\cscenevisual.cpp - This file contains the high level visualization routines implementation for the scene visualization in the shader. <sample>\host\csky.cpp - This file contains the sky visualization routines implementation. <sample>\host\cvisual3dbottom.cpp- This file contains the bottom visualization routines implementation. <sample>\host\cvisual3dcommondata.cpp - This file contains the common visualization routines implementation. <sample>\host\cvisual3dgathered.cpp - This file contains the visualization routines implementation for the gathered visualization mode which includes several water visualization effects. <sample>\host\cvisual3dsimple.cpp - This file contains the visualization routines implementation for a simple heightmap visualization mode. <sample>\host\cvisual3dtexadvection.cpp - This file contains the visualization routines implementation for a simple heightmap visualization mode. <sample>\host\fluidsimhost.cpp - This file contains the host application entry point as well as visualization and GUI entry points; Contains OpenCL context initialization/destroy and calls OpenCL side functions. <sample>\host\fluidsimhost.h - This file contains the host application entry point as well as visualization and GUI entry points declarations. <sample>\host\mainhost.cpp - This file contains the host application entry point. <sample>\host\scenes_creation.h - This file contains scenes creation class declarations. <sample>\host\scenes_creation.cpp - This file contains scenes creation class implementation. <sample>\common\flux\actions\cactionmanager.cpp - This file contains the IO routines implementation for boundary conditions storage/reading. <sample>\common\flux\actions\cactionmanager.h - This file contains the IO routines declaration for boundary conditions storage/reading. <sample>\common\util\cfilememory.cpp - This file contains the water surface data read from the (write in) file routines implementation. Intel OpenCL SDK Sample Documentation 17

18 <sample>\common\util\cfilememory.h - This file contains the water surface data read from the (write in) file routines declaration. <sample>\common\flux\actions\cflux2dbc_gen.cpp - This file contains the waves generation boundary conditions implementation. <sample>\common\flux\actions\cflux2dbc_gen.h -This file contains the waves generation boundary conditions routines declaration. <sample>\common\flux\actions\cflux2dbccopy.cpp - This file contains the basic boundary conditions implementation. <sample>\common\flux\actions\cflux2dbccopy.h - This file contains the basic boundary conditions declaration. <sample>\common\flux\actions\cflux2dbcreflectline.cpp - This file is reserved for piece-wise linear boundary conditions. <sample>\common\flux\actions\cflux2dbcreflectline.h - This file is reserved for piece-wise linear boundary conditions. <sample>\common\flux\cflux2dgrid.cpp- This file contains the routines implementation for water surface grid initialization and file IO. <sample>\common\flux\cflux2dgrid.h - This file contains the routines declaration for water surface grid initialization and file IO. <sample>\common\flux\cflux2dscene.cpp - This file contains the routines implementation for scene initialization and file IO. <sample>\common\flux\cflux2dscene.h - This file contains the routines declaration for scene initialization and file IO. <sample>\common\flux\cflux2dscenedef.h - This file contains the routines declaration for scene initialization and file IO. <sample>\common\util\memory.cpp - This file includes memory.h. <sample>\common\util\memory.h - This file contains the internal memory management routines. <sample>\host\utils\cdxmeshbase.cpp - This file contains the classes implementation for the DX based water surface visualization. <sample>\host\utils\cdxmeshbase.h - This file contains the classes declaration for the DX based water surface visualization. <sample>\host\utils\cdxquad.cpp - This file contains the classes implementation for the DX based water surface visualization. <sample>\host\utils\cdxquad.h - This file contains the classes declaration for the DX based water surface visualization. 18 Document Number: US

19 <sample>\host\utils\cdxrendertarget.cpp - This file contains the classes implementation for the DX based water surface visualization (DX render target specific). <sample>\host\utils\cdxrendertarget.h - This file contains the classes declaration for the DX based water surface visualization (DX render target specific). <sample>\host\utils\cdxconstwrappers.h - This file contains useful wrappers for the DX based water surface visualization. <sample>\host\utils\cdxgridgenerator.cpp - This file contains the simple routines implementation to help grids visualization. <sample>\host\utils\cdxgridgenerator.h - This file contains the simple routines declaration to help grids visualization. <sample>\host\utils\vismodes.cpp - This file contains the visualization routines implementations for simple heightmap visualization mode. <sample>\host\utils\vismodes.h - This file contains the visualization routines implementations for simple heightmap visualization mode. <sample>\common\flux\cflux2daction.h - This file contains the boundary conditions routines declaration. <sample>\common\flux\cflux2dsurface.h - This file contains the routines for water surface initialization and file IO. <sample>\common\commondatastruct.h - This file contains the common data structures declaration. <sample>\common\macros.h - This file contains some useful macros. <sample>\solver\hybridmethod\boatlogic.h - This file contains the floating boat routines declaration. <sample>\solver\cflux2dmethod.h - This file contains a shallow water calculators declarations. <sample>\solver\cflux2do2scalarcalculator.h - This file contains a declaration of the simple shallow water surface calculator implemented using scalar instructions. <sample>\solver\cflux2dscalarcalculator.h - This file contains a declaration of the shallow water surface calculator implemented using scalar instructions. <sample>\solver\cflux2dssecalculator.h - This file contains a declaration of the shallow water surface calculator implemented using SSE instructions. <sample>\solver\hybridmethod\hybridmethod.h - This file contains the class declarations which unify shallow water simulation and interaction with the floating boat. Intel OpenCL SDK Sample Documentation 19

20 <sample>\solver\hybridmethod\boatlogic.cpp - This file contains the floating boat routines implementation. <sample>\solver\cflux2do2scalarcalculator.cpp - This file contains the implementation of a simple shallow water surface calculator using scalar instructions. <sample>\solver\cflux2dscalarcalculator.cpp - This file contains the implementation of the a shallow water surface calculator implemented using scalar instructions. <sample>\solver\cflux2dssecalculator.cpp - This file contains implementation of shallow water surface calculator implemented using SSE instructions. <sample>\solver\hybridmethod\hybridmethod.cpp - This file contains the class declarations which unify the shallow water simulation and interaction with the floating boat. <sample>\solver\shallow_water.cpp - This file contains the OpenCL side entry point. ShallowWater.sln - This file contains the Microsoft* Visual Studio* 2008 project solution file containing all required projects and dependencies. Reference (Native) Implementation Reference implementation is done in CFlux2DMethodSerial::Step() and CFlux2DMethodOpenMP::Step()routines of solver\cflux2dmethod.h file. Such routines are implemented for serial and parallel (OpenMP) implementations of scalar C and SSE shallow water native calculators. Additional requiremments To build and run shallow water sample you need to install Microsoft* DirectX* SDK (June 2010 or later) on your system. 20 Document Number: US

21 APIs Used This sample uses the following APIs: clkreatekernel clcreatecontextfromtype clgetcontextinfo clcreatecommandqueue clcreateprogramwithsource clbuildprogram clcreatebuffer clsetkernelarg clenqueuendrangekernel clenqueuereadbuffer clreleasememobject clreleasekernel clreleaseprogram clreleasecommandqueue clreleasecontext. Controlling the Sample Use the following controls to change settings to examine the sample's capabilities: Space key - simulation toggle Left mouse button - rotates the scene Mouse wheel - zooms in/out of the scene Right mouse button - sets up the boat movement direction Max depth slider changes the maximal depth for light refraction simulation F4 key - wireframe surface rendering mode toggle F5 key - chaotic waves (wind waves) toggle F6 key asynchronous processing mode toggle. In asynchronous mode renderer and solver works in separate threads. O key - changes the current solver version (OpenCL/Native) Intel OpenCL SDK Sample Documentation 21

22 Scene select Sea/River drop down list changes simulation scenario (Sea or River) C key - changes camera mode OCL relaxed math check box - relaxed math optimization mode for OpenCL solver toggle. For more information press F1. References [1] Stocker J., Waves in Water [Russian translation], IL, Moscow (1959) and Water waves: the mathematical theory with applications, John Wiley and Sons, Inc (1958) ISBN [2] Steger J. L., Warming R. F. Flux vector splitting of the in viscid gas dynamic equations with application to finite-difference methods. // J. Comput Phys Vol. 40, N 2, pp [3] Belyaev V., Computer graphics methods and algorithms for water. 22 Document Number: US