From 71a678256d71d3942d040bbbe42d6a0270feb3cc Mon Sep 17 00:00:00 2001 From: Adrian Kummerlaender Date: Sun, 9 Jun 2019 23:57:04 +0200 Subject: First test of partially generated LBM kernel A kernel extracted from `lbn_codegen.ipynb` yields ~665 MLUPS compared to the ~600 MLUPS produced by a manually optimized kernel. Note that this new kernel currently doesn't handle boundary conditions (but dropping in a density condition doesn't impact performance). --- codegen_lbm.py | 221 +++++++ lbm_codegen.ipynb | 1557 ++++++++++++++++++++++++++------------------------ lid_driven_cavity.py | 14 - 3 files changed, 1041 insertions(+), 751 deletions(-) create mode 100644 codegen_lbm.py diff --git a/codegen_lbm.py b/codegen_lbm.py new file mode 100644 index 0000000..cd93649 --- /dev/null +++ b/codegen_lbm.py @@ -0,0 +1,221 @@ +import pyopencl as cl +mf = cl.mem_flags + +from string import Template + +import numpy +import matplotlib.pyplot as plt + +import time + +kernel = """ +unsigned int indexOfDirection(int i, int j) { + return (i+1) + 3*(1-j); +} + +unsigned int indexOfCell(int x, int y) +{ + return y * $nX + x; +} + +unsigned int idx(int x, int y, int i, int j) { + return indexOfDirection(i,j)*$nCells + indexOfCell(x,y); +} + +__global float f_i(__global __read_only float* f, int x, int y, int i, int j) { + return f[idx(x,y,i,j)]; +} + +__kernel void collide_and_stream(__global __write_only float* f_a, + __global __read_only float* f_b, + __global __write_only float* moments, + __global __read_only int* material) +{ + const unsigned int gid = indexOfCell(get_global_id(0), get_global_id(1)); + + const uint2 cell = (uint2)(get_global_id(0), get_global_id(1)); + + const int m = material[gid]; + + if ( m == 0 ) { + return; + } + + const float f_curr_0 = f_i(f_b, cell.x+1, cell.y-1, -1, 1); + const float f_curr_1 = f_i(f_b, cell.x , cell.y-1, 0, 1); + const float f_curr_2 = f_i(f_b, cell.x-1, cell.y-1, 1, 1); + const float f_curr_3 = f_i(f_b, cell.x+1, cell.y , -1, 0); + const float f_curr_4 = f_i(f_b, cell.x , cell.y , 0, 0); + const float f_curr_5 = f_i(f_b, cell.x-1, cell.y , 1, 0); + const float f_curr_6 = f_i(f_b, cell.x+1, cell.y+1, -1,-1); + const float f_curr_7 = f_i(f_b, cell.x , cell.y+1, 0,-1); + const float f_curr_8 = f_i(f_b, cell.x-1, cell.y+1, 1,-1); + + const float x0 = f_curr_0 + f_curr_1 + f_curr_2 + f_curr_3 + f_curr_4 + f_curr_5 + f_curr_6 + f_curr_7 + f_curr_8; + const float x1 = 2*f_curr_0; + const float x2 = 2*f_curr_8; + const float x3 = -f_curr_3 + f_curr_5; + const float x4 = pow(x0, -2); + const float x5 = 9*x4; + const float x6 = f_curr_0 - f_curr_8; + const float x7 = f_curr_1 - f_curr_7; + const float x8 = f_curr_2 - f_curr_6; + const float x9 = x6 + x7 + x8; + const float x10 = 6/x0; + const float x11 = x10*x9; + const float x12 = f_curr_3 - f_curr_5; + const float x13 = -f_curr_2 + f_curr_6 + x12 + x6; + const float x14 = pow(x13, 2); + const float x15 = 3*x4; + const float x16 = -x14*x15 + 2; + const float x17 = x11 + x16; + const float x18 = pow(x9, 2); + const float x19 = x15*x18; + const float x20 = -x19; + const float x21 = x10*x13; + const float x22 = x20 + x21; + const float x23 = 1.0/$tau; + const float x24 = (1.0/72.0)*x23; + const float x25 = 6*x4; + const float x26 = x18*x25; + const float x27 = (1.0/18.0)*x23; + const float x28 = x5*pow(2*f_curr_2 - 2*f_curr_6 + x3 + x7, 2); + const float x29 = x20 - x21; + const float x30 = x14*x25 + 2; + const float x31 = -f_curr_0 + f_curr_8 + x3 + x8; + const float x32 = x15*pow(x31, 2) - 2; + const float x33 = x19 + x32; + + f_a[0*$nCells + gid] = f_curr_0 - x24*(72*f_curr_0 - x0*(x17 + x22 + x5*pow(-f_curr_1 + f_curr_7 - x1 + x2 + x3, 2))); + f_a[1*$nCells + gid] = f_curr_1 - x27*(18*f_curr_1 - x0*(x17 + x26)); + f_a[2*$nCells + gid] = f_curr_2 - x24*(72*f_curr_2 - x0*(x17 + x28 + x29)); + f_a[3*$nCells + gid] = f_curr_3 - x27*(18*f_curr_3 - x0*(x22 + x30)); + f_a[4*$nCells + gid] = f_curr_4 - 1.0/9.0*x23*(9*f_curr_4 + 2*x0*x33); + f_a[5*$nCells + gid] = f_curr_5 - x27*(18*f_curr_5 - x0*(x29 + x30)); + f_a[6*$nCells + gid] = f_curr_6 - x24*(72*f_curr_6 + x0*(x10*x31 + x11 - x28 + x33)); + f_a[7*$nCells + gid] = f_curr_7 - x27*(18*f_curr_7 + x0*(x11 - x26 + x32)); + f_a[8*$nCells + gid] = f_curr_8 - x24*(72*f_curr_8 - x0*(-x11 + x16 + x29 + x5*pow(x1 + x12 - x2 + x7, 2))); + + moments[gid] = x0; +}""" + + +class D2Q9_BGK_Lattice: + def idx(self, x, y): + return y * self.nX + x; + + def __init__(self, nX, nY): + self.nX = nX + self.nY = nY + self.nCells = nX * nY + self.tick = True + + self.platform = cl.get_platforms()[0] + self.context = cl.Context(properties=[(cl.context_properties.PLATFORM, self.platform)]) + self.queue = cl.CommandQueue(self.context) + + self.np_pop_a = numpy.ndarray(shape=(9, self.nCells), dtype=numpy.float32) + self.np_pop_b = numpy.ndarray(shape=(9, self.nCells), dtype=numpy.float32) + + self.np_moments = numpy.ndarray(shape=(3, self.nCells), dtype=numpy.float32) + self.np_material = numpy.ndarray(shape=(self.nCells, 1), dtype=numpy.int32) + + self.setup_geometry() + + self.equilibrilize() + self.setup_anomaly() + + self.cl_pop_a = cl.Buffer(self.context, mf.READ_WRITE | mf.USE_HOST_PTR, hostbuf=self.np_pop_a) + self.cl_pop_b = cl.Buffer(self.context, mf.READ_WRITE | mf.USE_HOST_PTR, hostbuf=self.np_pop_b) + + self.cl_material = cl.Buffer(self.context, mf.READ_ONLY | mf.USE_HOST_PTR, hostbuf=self.np_material) + self.cl_moments = cl.Buffer(self.context, mf.READ_WRITE | mf.USE_HOST_PTR, hostbuf=self.np_moments) + + self.build_kernel() + + def setup_geometry(self): + self.np_material[:] = 0 + for x in range(1,self.nX-1): + for y in range(1,self.nY-1): + if x == 1 or y == 1 or x == self.nX-2 or y == self.nY-2: + self.np_material[self.idx(x,y)] = 2 + else: + self.np_material[self.idx(x,y)] = 1 + + def equilibrilize(self): + self.np_pop_a[(0,2,6,8),:] = 1./36. + self.np_pop_a[(1,3,5,7),:] = 1./9. + self.np_pop_a[4,:] = 4./9. + + self.np_pop_b[(0,2,6,8),:] = 1./36. + self.np_pop_b[(1,3,5,7),:] = 1./9. + self.np_pop_b[4,:] = 4./9. + + def setup_anomaly(self): + bubbles = [ [ self.nX//4, self.nY//4], + [ self.nX//4,self.nY-self.nY//4], + [self.nX-self.nX//4, self.nY//4], + [self.nX-self.nX//4,self.nY-self.nY//4] ] + + for x in range(0,self.nX-1): + for y in range(0,self.nY-1): + for [a,b] in bubbles: + if numpy.sqrt((x-a)*(x-a)+(y-b)*(y-b)) < self.nX//10: + self.np_pop_a[:,self.idx(x,y)] = 1./24. + self.np_pop_b[:,self.idx(x,y)] = 1./24. + + def build_kernel(self): + self.program = cl.Program(self.context, Template(kernel).substitute({ + 'nX' : self.nX, + 'nY' : self.nY, + 'nCells': self.nCells, + 'tau': '0.8f' + })).build() #'-cl-single-precision-constant -cl-fast-relaxed-math') + + def evolve(self): + if self.tick: + self.tick = False + self.program.collide_and_stream(self.queue, (self.nX,self.nY), (64,1), self.cl_pop_a, self.cl_pop_b, self.cl_moments, self.cl_material) + else: + self.tick = True + self.program.collide_and_stream(self.queue, (self.nX,self.nY), (64,1), self.cl_pop_b, self.cl_pop_a, self.cl_moments, self.cl_material) + + def sync(self): + self.queue.finish() + + def show(self, i): + cl.enqueue_copy(LBM.queue, LBM.np_moments, LBM.cl_moments).wait(); + + density = numpy.ndarray(shape=(self.nX-2, self.nY-2)) + for y in range(1,self.nY-1): + for x in range(1,self.nX-1): + density[y-1,x-1] = self.np_moments[0,self.idx(x,y)] + + plt.imshow(density, vmin=0.2, vmax=2.0, cmap=plt.get_cmap("seismic")) + plt.savefig("result/density_" + str(i) + ".png") + + +def MLUPS(cells, steps, time): + return cells * steps / time * 1e-6 + +nUpdates = 1000 +nStat = 100 + +print("Initializing simulation...\n") + +LBM = D2Q9_BGK_Lattice(1024, 1024) + +print("Starting simulation using %d cells...\n" % LBM.nCells) + +lastStat = time.time() + +for i in range(1,nUpdates+1): + if i % nStat == 0: + LBM.sync() + #LBM.show(i) + print("i = %4d; %3.0f MLUPS" % (i, MLUPS(LBM.nCells, nStat, time.time() - lastStat))) + lastStat = time.time() + + LBM.evolve() + +LBM.show(nUpdates) diff --git a/lbm_codegen.ipynb b/lbm_codegen.ipynb index efc1200..7d13f70 100644 --- a/lbm_codegen.ipynb +++ b/lbm_codegen.ipynb @@ -14,40 +14,39 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ - "c = [Matrix((x,)) for x in [(-1, 1), ( 0, 1), ( 1, 1), (-1, 0), ( 0, 0), ( 1, 0), (-1, 0), ( 0, -1), ( 1, -1)]]" + "c = [Matrix((x,)) for x in [(-1, 1), ( 0, 1), ( 1, 1), (-1, 0), ( 0, 0), ( 1, 0), (-1,-1), ( 0, -1), ( 1, -1)]]" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAABHNCSVQICAgIfAhkiAAAAHZJREFUKJFjYKACCGFgYJjMwMBwmIGB4RMDA8N/BgaGJYQ0XYAq/MzAwHCdWE2ODAwMqgwMDIwMDAwOuDSxoPH3EzKVgYGBgYkYRaOaBlwTeuQGQDEDAwODBJS2ZGBgWABlv2FgYChBN6SBAZJ0cOEH5LiMzgAA6XoX52TB9a4AAAAASUVORK5CYII=\n", "text/latex": [ - "$$1$$" + "$$\\left [ \\left[\\begin{matrix}-1 & 1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0 & 1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1 & 1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}-1 & 0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0 & 0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1 & 0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}-1 & -1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0 & -1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1 & -1\\end{matrix}\\right]\\right ]$$" ], "text/plain": [ - "1" + "[[-1 1], [0 1], [1 1], [-1 0], [0 0], [1 0], [-1 -1], [0 -1], [1 -1]]" ] }, - "execution_count": 3, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "c[1][1]" + "c" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -69,7 +68,7 @@ "[1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36]" ] }, - "execution_count": 5, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -80,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -93,7 +92,7 @@ "1" ] }, - "execution_count": 6, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -104,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -119,7 +118,7 @@ "3 " ] }, - "execution_count": 8, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -131,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -140,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -150,7 +149,7 @@ " f_next_6, f_next_7, f_next_8], dtype=object)" ] }, - "execution_count": 10, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -162,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -172,7 +171,7 @@ " f_curr_6, f_curr_7, f_curr_8], dtype=object)" ] }, - "execution_count": 11, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -184,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -198,7 +197,7 @@ "_curr_7 + f_curr_8" ] }, - "execution_count": 12, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -210,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -229,7 +228,7 @@ "_curr_7 + f_curr_8" ] }, - "execution_count": 13, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -241,26 +240,26 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/latex": [ - "$$\\frac{f_{curr 0} + f_{curr 1} + f_{curr 2} - f_{curr 7} - f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}$$" + "$$\\frac{f_{curr 0} + f_{curr 1} + f_{curr 2} - f_{curr 6} - f_{curr 7} - f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}$$" ], "text/plain": [ - " f_curr_0 + f_curr_1 + f_curr_2 - f_curr_7 - f_curr_8 \n", + " f_curr_0 + f_curr_1 + f_curr_2 - f_curr_6 - f_curr_7 - f_curr_\n", "──────────────────────────────────────────────────────────────────────────────\n", "f_curr_0 + f_curr_1 + f_curr_2 + f_curr_3 + f_curr_4 + f_curr_5 + f_curr_6 + f\n", "\n", - " \n", + "8 \n", "──────────────────\n", "_curr_7 + f_curr_8" ] }, - "execution_count": 14, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -272,20 +271,20 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/latex": [ - "$$\\left[\\begin{matrix}\\frac{- f_{curr 0} + f_{curr 2} - f_{curr 3} + f_{curr 5} - f_{curr 6} + f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}\\\\\\frac{f_{curr 0} + f_{curr 1} + f_{curr 2} - f_{curr 7} - f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}\\end{matrix}\\right]$$" + "$$\\left[\\begin{matrix}\\frac{- f_{curr 0} + f_{curr 2} - f_{curr 3} + f_{curr 5} - f_{curr 6} + f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}\\\\\\frac{f_{curr 0} + f_{curr 1} + f_{curr 2} - f_{curr 6} - f_{curr 7} - f_{curr 8}}{f_{curr 0} + f_{curr 1} + f_{curr 2} + f_{curr 3} + f_{curr 4} + f_{curr 5} + f_{curr 6} + f_{curr 7} + f_{curr 8}}\\end{matrix}\\right]$$" ], "text/plain": [ "⎡ -f_curr_0 + f_curr_2 - f_curr_3 + f_curr_5 - f_curr_6 + f_cur\n", "⎢─────────────────────────────────────────────────────────────────────────────\n", "⎢f_curr_0 + f_curr_1 + f_curr_2 + f_curr_3 + f_curr_4 + f_curr_5 + f_curr_6 + \n", "⎢ \n", - "⎢ f_curr_0 + f_curr_1 + f_curr_2 - f_curr_7 - f_curr_8 \n", + "⎢ f_curr_0 + f_curr_1 + f_curr_2 - f_curr_6 - f_curr_7 - f_curr\n", "⎢─────────────────────────────────────────────────────────────────────────────\n", "⎣f_curr_0 + f_curr_1 + f_curr_2 + f_curr_3 + f_curr_4 + f_curr_5 + f_curr_6 + \n", "\n", @@ -293,12 +292,12 @@ "───────────────────⎥\n", "f_curr_7 + f_curr_8⎥\n", " ⎥\n", - " ⎥\n", + "_8 ⎥\n", "───────────────────⎥\n", "f_curr_7 + f_curr_8⎦" ] }, - "execution_count": 15, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -310,311 +309,311 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { - "image/png": "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