def func():
ck = ti.to_numpy_type(vartype)(0)
for i in range(n):
x[i] = ti.atomic_add(c[None], step)
y[i] = ti.atomic_add(ck, step)
def inc(self):
for i, j in self.val:
ti.atomic_add(self.val[i, j], self.increment)
def reduce(self):
for i, j in self.val:
ti.atomic_add(self.total, self.val[i, j] * 4)
def atomic_add(self, other):
import taichi as ti
_taichi_skip_traceback = 1
return ti.atomic_add(self, other)
def test():
for i in x:
x[i] = ti.atomic_add(c[None], 1)
for i in range(c[None], c[None] * 2):
x[i - n] += c[None]
def compute_loss(t: ti.i32):
ti.atomic_add(loss[None], dt * (x[t] - goal[t]).norm_sqr())
def atomic_add(self, other):
_taichi_skip_traceback = 1
return ti.atomic_add(self, other)
def apply_impulse(t, i, impulse, location):
ti.atomic_add(v_inc[t + 1, i], impulse * inverse_mass[i])
ti.atomic_add(omega_inc[t + 1, i],
(location - x[t, i]).cross(impulse) * inverse_inertia[i])
def kernel2(n: ti.i32) -> ti.i32:
x = 0
for i in range(n):
ti.atomic_add(x, 1)
return x
def accumulate():
for i in x:
ti.atomic_add(sum, i)
def accumulate():
for i, j in x:
ti.atomic_add(sum, i + j * 2)
def alloc_trash():
ret = ti.atomic_add(trash_table_len[None], 1)
assert ret < kMaxDepth
return ret
def count_activate(grid: ti.template()):
for I in ti.grouped(grid):
ti.atomic_add(count[None], 1)
def march(self) -> int:
r_n = 0
for I in ti.grouped(ti.ndrange(*[[1, self.N - 1]] * self.dim)):
id = 0
if ti.static(self.dim == 2):
i, j = I
if self.m[i, j] > 1: id |= 1
if self.m[i + 1, j] > 1: id |= 2
if self.m[i, j + 1] > 1: id |= 4
if self.m[i + 1, j + 1] > 1: id |= 8
else:
i, j, k = I
if self.m[i, j, k] > 1: id |= 1
if self.m[i + 1, j, k] > 1: id |= 2
if self.m[i + 1, j + 1, k] > 1: id |= 4
if self.m[i, j + 1, k] > 1: id |= 8
if self.m[i, j, k + 1] > 1: id |= 16
if self.m[i + 1, j, k + 1] > 1: id |= 32
if self.m[i + 1, j + 1, k + 1] > 1: id |= 64
if self.m[i, j + 1, k + 1] > 1: id |= 128
for m in range(self.et.shape[1]):
if self.et[id, m][0] == -1:
break
n = ti.atomic_add(r_n, 1)
for l in ti.static(range(self.dim)):
e = self.et[id, m][l]
R = float(I)
if ti.static(self.dim == 2):
i, j = I
# (.5, 0), (0, .5), (1, .5), (.5, 1)
if e == 0:
p = (1 - self.m[i, j]) / (self.m[i + 1, j] -
self.m[i, j])
R = [i + p, j]
elif e == 1:
p = (1 - self.m[i, j]) / (self.m[i, j + 1] -
self.m[i, j])
R = [i, j + p]
elif e == 2:
p = (1 - self.m[i + 1, j]) / (
self.m[i + 1, j + 1] - self.m[i + 1, j])
R = [i + 1, j + p]
elif e == 3:
p = (1 - self.m[i, j + 1]) / (
self.m[i + 1, j + 1] - self.m[i, j + 1])
R = [i + p, j + 1]
else:
i, j, k = I
# (.5, 0, 0), (1, .5, 0), (.5, 1, 0), (0, .5, 0)
# (.5, 0, 1), (1, .5, 1), (.5, 1, 1), (0, .5, 1)
# (0, 0, .5), (1, 0, .5), (1, 1, .5), (0, 1, .5)
if e == 0:
p = (1 - self.m[i, j, k]) / (self.m[i + 1, j, k] -
self.m[i, j, k])
R = [i + p, j, k]
elif e == 1:
p = (1 - self.m[i + 1, j, k]) / (
self.m[i + 1, j + 1, k] - self.m[i + 1, j, k])
R = [i + 1, j + p, k]
elif e == 2:
p = (1 - self.m[i, j + 1, k]) / (
self.m[i + 1, j + 1, k] - self.m[i, j + 1, k])
R = [i + p, j + 1, k]
elif e == 3:
p = (1 - self.m[i, j, k]) / (self.m[i, j + 1, k] -
self.m[i, j, k])
R = [i, j + p, k]
elif e == 4:
p = (1 - self.m[i, j, k + 1]) / (
self.m[i + 1, j, k + 1] - self.m[i, j, k + 1])
R = [i + p, j, k + 1]
elif e == 5:
p = (1 - self.m[i + 1, j, k + 1]) / (
self.m[i + 1, j + 1, k + 1] -
self.m[i + 1, j, k + 1])
R = [i + 1, j + p, k + 1]
elif e == 6:
p = (1 - self.m[i, j + 1, k + 1]) / (
self.m[i + 1, j + 1, k + 1] -
self.m[i, j + 1, k + 1])
R = [i + p, j + 1, k + 1]
elif e == 7:
p = (1 - self.m[i, j, k + 1]) / (
self.m[i, j + 1, k + 1] - self.m[i, j, k + 1])
R = [i, j + p, k + 1]
elif e == 8:
p = (1 - self.m[i, j, k]) / (self.m[i, j, k + 1] -
self.m[i, j, k])
R = [i, j, k + p]
elif e == 9:
p = (1 - self.m[i + 1, j, k]) / (
self.m[i + 1, j, k + 1] - self.m[i + 1, j, k])
R = [i + 1, j, k + p]
elif e == 10:
p = (1 - self.m[i + 1, j + 1, k]) / (
self.m[i + 1, j + 1, k + 1] -
self.m[i + 1, j + 1, k])
R = [i + 1, j + 1, k + p]
elif e == 11:
p = (1 - self.m[i, j + 1, k]) / (
self.m[i, j + 1, k + 1] - self.m[i, j + 1, k])
R = [i, j + 1, k + p]
self.r[n, l] = R
return r_n
def compute_loss(t: ti.i32):
for i in range(n_grid):
for j in range(n_grid):
ti.atomic_add(loss, dx * dx * ti.sqr(target[i, j] - p[t, i, j]))
def func():
for i in range(n):
j = i
x[i] = ti.atomic_add(j, step)
def atomic_add(self, other):
import taichi as ti
return ti.atomic_add(self, other)
def func():
ck = init_ck
for i in range(n):
x[i] = ti.atomic_add(c[None], step)
y[i] = ti.atomic_add(ck, step)
def compute_loss(t: ti.i32):
ti.atomic_add(loss[None], dt * ti.sqr(target_v[t][0] - v[t, head_id][0]))
def func():
for i in range(n):
# this is an expr with side effect, make sure it's not optimized out.
ti.atomic_add(c[None], step)
def compute_loss():
for i in range(16):
ti.atomic_add(loss[None], z[i])
def func():
for i in range(n):
s = i
# Both adds should get demoted.
x[i] = ti.atomic_add(s, step)
y[i] = s.atomic_add(step)
def func2(): ti.atomic_add(y[0], x[0] % 3)
def func(n: ti.template()) -> ti.i32:
x = 0
for i in range(n):
ti.atomic_add(x, 1)
return x
def func():
for i in range(N):
ti.atomic_add(loss[None], x[i]**2)
def inc2(self, increment: ti.i32):
for i, j in self.val:
ti.atomic_add(self.val[i, j], increment)
def reduce(self):
for i, j in self.val:
ti.atomic_add(self.total, self.val[i, j] * self.multiplier)
def forces_vjp():
for i in range(n_objects):
ti.atomic_add(loss, v_acc[i][0] * v_acc_bar[i][0])
ti.atomic_add(loss, v_acc[i][1] * v_acc_bar[i][1])
def compute_loss():
for i in range(n_grid):
for j in range(n_grid):
ti.atomic_add(
loss,
ti.sqr(target[i, j] - smoke[steps - 1, i, j]) * (1 / n_grid**2))
def func():
a = 0
for i in range(10):
ti.atomic_add(a, i)
A[None] = a
