OpenCL based GPU accelerated SPH fluid simulation library

libclsph

An OpenCL based GPU accelerated SPH fluid simulation library

Can I see it in action?

Demo #1
Demo #2

Why?

Libclsph was created to explore the possibilty of using the power of OpenCL to speed up the simulation of SPH fluid mechanics.

Smoothed particle hydrodynamics is a fluid simulation technique that can be used to produce realistic simulations for animation,CGI or videogames.

How ?

Libclsph uses C++11 and OpenCL to run simulations. Results are exported using industry standards and can then be used in programs like houdini. Simulation properties can be easily modified by the user.

Getting started

Be sure to visit the wiki for more information and detailed instructions on how to get started.

Libraries used

  • picojson is used to load simulation properties from files.
  • cereal is used for all serialization needs.
  • partio is used to import/export particle data.
  • tinyobjloader is used to load geometry in obj format.
Comments
  • Improve build system

    Improve build system

    Ideally, the build system would include the following:

    1. configure script
    2. separate Makefile for example
    3. conditional compilation of certain features (goes along point 1.)
  • Introduce an adaptable grid

    Introduce an adaptable grid

    The grid fitted to the particles must be adaptable, otherwise we would need to allocate an impossibly large amount of memory when dealing with a high amount of low mass particles.

  • Integrate Partio

    Integrate Partio

    Write files in bgeo format to save time.

    Example program that uses partio : https://gist.github.com/OlivierLi/9043673

    How to compile a program and link with partio :

    g++ test.cpp libpartio.a -lz

  • More input validation

    More input validation

    The user should be notified it he starts a simulation using suboptimal parameters.

    Optimal settings are detailed here : https://github.com/libclsph/libclsph/wiki/Getting-the-best-performance.

  • Partition work groups in a more efficient way.

    Partition work groups in a more efficient way.

    Local memory is declared as a kernel argument like so : kernel void myKernel(const int length, const int height, local float* LP,local float* LT,...)

    Then async_work_group_copy is used to copy the particles frome global memory to local memory.

    __kernel void test( __local float* local_data,__global float *global_data,int group_size) {
    
    .
    .
    .
    
      event_t e = async_work_group_copy(LF, global_data+group_id*group_size, group_size, 0);
      wait_group_events(1, &e);
    
      //Now calls are made using local memory only
    }
    
    
  • Use an adaptive time step

    Use an adaptive time step

    The largest time-step possible should be used to increase the speed of the simulation.

    This means the time step should have a reasonably high starting value, for example 0.1.

    Then during each frame we check if the CFL was broken.

    If it was then we need to simulate the frame again with a smaller time step.

  • Add OpenGL Output

    Add OpenGL Output

    Hi, I am playing with your lib on OSX, and I am curious if it will be possible to add a basic 3D rendering.

    I am translating the library into Javascript using WebCL, and a 3D output in WebGL will be really nice.

    What do you think ? Seems possible to add it ?

  • Simulation Parameters structure might be becoming too large

    Simulation Parameters structure might be becoming too large

    Encountered a bug where merely adding a member to the simulation parameters struct broke only parts of the simulation (collisions in this case). I suspect the struct might be becoming too large to be passed at that point in the sim and therefore suggest moving all parameters that aren't needed on the GPU directly to the sph_simulation class.

    More diagnostics would be required to try and pinpoint the exact cause of this issue.

A C++ GPU Computing Library for OpenCL

Boost.Compute Boost.Compute is a GPU/parallel-computing library for C++ based on OpenCL. The core library is a thin C++ wrapper over the OpenCL API an

Aug 7, 2022
VexCL is a C++ vector expression template library for OpenCL/CUDA/OpenMP

VexCL VexCL is a vector expression template library for OpenCL/CUDA. It has been created for ease of GPGPU development with C++. VexCL strives to redu

Aug 4, 2022
A small C OpenCL wrapper

oclkit, plain and stupid OpenCL helper oclkit is a small set of C functions, to avoid writing the same OpenCL boiler plate over and over again, yet ke

Jul 22, 2022
Sqrt OS is a simulation of an OS scheduler and memory manager using different scheduling algorithms including Highest Priority First (non-preemptive), Shortest Remaining Time Next, and Round Robin
Sqrt OS is a simulation of an OS scheduler and memory manager using different scheduling algorithms including Highest Priority First (non-preemptive), Shortest Remaining Time Next, and Round Robin

A CPU scheduler determines an order for the execution of its scheduled processes; it decides which process will run according to a certain data structure that keeps track of the processes in the system and their status.

Jul 14, 2021
Discrete-event simulation in C++20 using coroutines

SimCpp20 SimCpp20 is a discrete-event simulation framework for C++20. It is similar to SimPy and aims to be easy to set up and use. Processes are defi

Apr 29, 2022
KRATOS Multiphysics ("Kratos") is a framework for building parallel, multi-disciplinary simulation software
KRATOS Multiphysics (

KRATOS Multiphysics ("Kratos") is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.

Aug 10, 2022
ArrayFire: a general purpose GPU library.
ArrayFire: a general purpose GPU library.

ArrayFire is a general-purpose library that simplifies the process of developing software that targets parallel and massively-parallel architectures i

Aug 9, 2022
Patterns and behaviors for GPU computing

moderngpu 2.0 (c) 2016 Sean Baxter You can drop me a line here Full documentation with github wiki under heavy construction. Latest update: 2.12 2016

Aug 8, 2022
Optimized primitives for collective multi-GPU communication

NCCL Optimized primitives for inter-GPU communication. Introduction NCCL (pronounced "Nickel") is a stand-alone library of standard communication rout

Aug 12, 2022
stdgpu: Efficient STL-like Data Structures on the GPU
stdgpu: Efficient STL-like Data Structures on the GPU

stdgpu: Efficient STL-like Data Structures on the GPU Features | Examples | Documentation | Building | Integration | Contributing | License | Contact

Aug 8, 2022
ParallelComputingPlayground - Shows different programming techniques for parallel computing on CPU and GPU

ParallelComputingPlayground Shows different programming techniques for parallel computing on CPU and GPU. Purpose The idea here is to compute a Mandel

May 16, 2020
Termite-jobs - Fast, multiplatform fiber based job dispatcher based on Naughty Dogs' GDC2015 talk.

NOTE This library is obsolete and may contain bugs. For maintained version checkout sx library. until I rip it from there and make a proper single-hea

Jan 9, 2022
A library for enabling task-based multi-threading. It allows execution of task graphs with arbitrary dependencies.

Fiber Tasking Lib This is a library for enabling task-based multi-threading. It allows execution of task graphs with arbitrary dependencies. Dependenc

Aug 7, 2022
C++20 coroutines-based cooperative multitasking library

?? Coop Coop is a C++20 coroutines-based library to support cooperative multitasking in the context of a multithreaded application. The syntax will be

Aug 11, 2022
A C++20 coroutine library based off asyncio
A C++20 coroutine library based off asyncio

kuro A C++20 coroutine library, somewhat modelled on Python's asyncio Requirements Kuro requires a C++20 compliant compiler and a Linux OS. Tested on

Jul 19, 2022
C++20 Coroutine-Based Synchronous Parser Combinator Library

This library contains a monadic parser type and associated combinators that can be composed to create parsers using C++20 Coroutines.

Aug 7, 2022
A C++17 message passing library based on MPI

MPL - A message passing library MPL is a message passing library written in C++17 based on the Message Passing Interface (MPI) standard. Since the C++

Jul 13, 2022
DwThreadPool - A simple, header-only, dependency-free, C++ 11 based ThreadPool library.
DwThreadPool - A simple, header-only, dependency-free, C++ 11 based ThreadPool library.

dwThreadPool A simple, header-only, dependency-free, C++ 11 based ThreadPool library. Features C++ 11 Minimal Source Code Header-only No external depe

May 29, 2022
C++14 coroutine-based task library for games

SquidTasks Squid::Tasks is a header-only C++14 coroutine-based task library for games. Full project and source code available at https://github.com/we

Aug 16, 2022