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