Repository navigation
Merge main into SSA - #214
Merge main into SSA #214
Conversation
* Fix the Linux/GCC build
CI only builds on macOS with libc++, which transitively provides several
standard headers that libstdc++ does not, and links against a monolithic
LLVM dylib that resolves every component. Neither holds on Linux with
GCC and a component-wise LLVM install, so the build failed outright.
- Add the standard headers that were being picked up transitively:
<cmath> (CPP.cpp), <cstdint> and <algorithm> (Token.h), <functional>
(Trees.cpp, Layouts.cpp, Defers.cpp), <unordered_map> (DCE.cpp,
LoopTransforms.cpp).
- Request the LLVM components src/CodeGen uses directly: mc,
targetparser, codegen, transformutils, instcombine, scalaropts, ipo.
* Port the reduction IR nodes from ajr/pldi-benchmarks
Brings over the IR-level machinery the paper's associative and idempotent
reductions need, without any of the benchmarking scaffolding:
- AggOp{avg, count, prod, sum}, the set-level reductions of Fig. 2 that
take no lambda.
- SetOp::minimum, the paper's set-level `min`. Spelled `minimum` because
`min` is already the binary scalar intrinsic and the vector reduction.
- Annotation::Aggregate, the reduction augmentations of Section 4
(`with min(id) = idl`), alongside Data/Volume/Interval.
- Accumulate::Min/Max, plus LLVM and CUDA emission for them and for the
previously unhandled Argmax.
- Scan carries an optional reduction op, so a scan can aggregate subtree
results with something other than set union.
- Infinity becomes Extrema{inf, eps}; reductions need an epsilon for
bounds that are not tight. `eps` is now parseable alongside `inf`, and
both still print lowercase so they round-trip with the surface syntax.
Deliberately not ported from that branch: the commented-out else-if chain
in Printer::visit(IfElse), and the machine_epsilon change. Both are
unrelated to operators and would churn every golden.
* Parse the reduction operators and augmentations
- `minimum(metric, set)` and the set aggregations `avg` / `count`.
- `sum` and `prod` share a spelling with the vector reductions, so they
dispatch on the argument's type in VectorReduce::make rather than
getting their own parser entry.
- Reduction augmentations in the schedule: `with min(id) = idl`.
- `eps[[T]]` now produces a typed Extrema instead of being folded to a
float immediate at parse time.
Adding `count` as a builtin collided with layout field names, e.g. the
`count : u32; group[count] index : u32` in lower/trace.bonsai. A builtin
name now only denotes an intrinsic where it is actually applied, as `f(x)`
or `f[[T]](x)`. A bare builtin name was already an error, so this widens
what parses rather than narrowing it.
* Lower minimum, and track reduction augmentations in traversals
The Rewriter that walks a Match now also collects, per arm, the reduction
augmentations a node stores and any volumes annotated on its children,
alongside the bounding volume and scalar intervals it already tracked.
build_minimum implements Algorithm 2: value-based pruning comes from
fusing `M(x) < best` into the inner filter and letting predicate analysis
bound it, with the accumulator's interval recorded as (-inf, best]. An
empty-able set yields an option, matching build_argmin.
Predicate analysis gains the rules that reductions over scalar fields
need: Div, Select, Access, and Intrinsic::max, plus tighter Mul bounds. A
geometric operand that varies without a bounding volume now yields an
undefined interval instead of an internal error -- "cannot be bounded" is
an ordinary outcome that makes the traversal recurse unconditionally. For
the same reason, a filter whose upper bound is trivially true no longer
emits a guard.
count is lowered here too, but as the branch's special case; the next
commit replaces it with the general map-then-reduce form.
* Generalize count into map followed by reduce
The ported count lowering was a special case: a bespoke accumulator that
only fired when a node stored a `count()` augmentation. Replace it with
the general form the paper describes, where count is a map of every
element to 1 followed by an add-reduction with identity 0.
- AggOp gains `reduce`, carrying an identity and an associative,
commutative binary combiner. `count`, `sum` and `prod` become sugar
that expand_aggregate() rewrites into it.
- build_map implements Algorithm 1 lines 9-12, and Scan now carries the
map applied to subtree elements so a scan under a map stays faithful.
- build_reduce implements Algorithm 1 lines 13-22. It recognises which
augmentation, if any, computes the reduction over a subtree by matching
the combiner against the map feeding it: summing a constant 1 is a
`count()`, summing a field f is a `sum(f)`. When a node stores that
aggregate the subtree is folded in wholesale; otherwise the scan
carries the reduction and recurses.
- Updates are emitted as an Accumulate for combiners the backends can
apply in place, and otherwise as a store of the inlined combiner, so an
arbitrary user-written reduce still lowers.
`avg` still errors: it needs a pair reduction over a running sum and
count, which the combiner machinery does not build yet.
* Complete the set operators of Figure 2
Adds maximum, argmax, any and all, and general reduce, so every operator
in the paper's Figure 2 now lowers onto a tree.
- SetOp::make is restructured around shared validation (the lambda must
accept the set's elements; the result is optional when the set can be
empty), replacing the near-duplicate argmin and minimum branches.
- minimum/maximum and argmin/argmax are one lowering each, parameterized
by which end of the metric they seek: the identity, the accumulate op,
the fused "improves on best" comparison, the accumulator's own interval
and which subtree bound tightens it all follow from that direction.
- build_extremum implements the rest of Algorithm 2: an included subtree
is folded in wholesale when the node stores the matching min/max
augmentation, and a recursive call first tightens the accumulator with
the metric's bound over the subtree.
- build_quantifier implements Algorithm 4. Both directions short-circuit
once the accumulator reaches the absorbing element of the boolean
lattice, and skip a subtree whose predicate is proven always or never
true.
- reduce(identity, combiner, set) is now surface syntax; `sum` over a set
and an explicit reduce produce identical traversals.
Two bugs fixed along the way, both about bounds not being found:
predicate_analysis ignored a tagged interval on the top-level expression,
because it accepted the expression directly instead of going through the
interval-map lookup that its subexpressions use; and build_extremum built
its volume map without the matching interval map. Together these made
`minimum(|p| p.id, points)` tighten the accumulator with a dangling `p.id`
instead of the node's stored upper bound.
* Derive bounds for every geometric predicate
Extends GeomOp with the rest of Figure 1 -- covers, disjoint, equals,
touches, within, and the per-dimension ordering predicates lex/ley/lez
and ltx/lty/ltz -- and replaces the three hand-written cases in predicate
analysis with the paper's two tables.
geom_upper_bound is Algorithm 5 and geom_lower_bound Algorithm 6 lines
1-13, each transcribed case by case over the three configurations the
paper enumerates: uniform-varying, varying-uniform, and both varying. An
undefined result is the algorithms' trailing `_ |-> true` and `_ |->
false`. Metric bounds come from Algorithm 6 lines 15-25, which also fills
in distmax; only distmin was handled before.
The ordering predicates are the one family the paper leaves out "for
brevity". They are monotonic, so the sufficient condition is the same
relation between the bounding volumes, and the necessary condition is the
negation of the strict counterpart with the operands swapped.
Two deliberate deviations, both noted at the rules:
- contains(v, u) keeps this repo's contains(V_v, u) upper bound rather
than the paper's intersects(V_v, u). It is strictly tighter and equally
sound: a b inside a is inside a's volume too.
- equals(v, u) uses within(u, V_v), matching the symmetric case, since
equality constrains the uniform operand to fit inside the varying
operand's volume regardless of argument order.
lower/bvh.expect changes because filters on `intersects` now get a
sufficient condition. That is the specialization the paper's Figure 5b
shows, where `always` becomes `contains`.
* Implement the geometric predicates in the standard library
stdlib/topology.bonsai defines the topological and ordering relations for
the pairs of shapes they are meaningful on. The AABB-against-AABB
relations are not optional: predicate analysis derives its pruning
conditions in terms of bounding volumes, so it emits calls like
covers(u, V) and disjoint(V0, V1) that lower-geometrics has to resolve.
The rest are what user queries are written against: AABB against Point,
Sphere and Triangle, with box-triangle overlap done by the separating
axis test.
A ray has empty interior in three dimensions, so it can only contain
degenerate geometry; contains(Ray, ...) reports false. That is sound in
both roles the rule plays -- as a sufficient condition a false negative
only costs pruning, and under negation it is the weakest necessary
condition.
stdlib/distance.bonsai gains the metrics on bounding volumes that
Algorithm 6 lines 15-25 need: every distmin a query uses has to have a
distmax counterpart on the volumes, and a closest-point query over a
Point tree needs distmax(Point, AABB), which was missing.
Verified by lowering one query per predicate against these definitions
and checking each derived always/maybe pair against Algorithms 5 and 6.
The two trace goldens grow because they import stdlib/distance and print
the whole program.
* Bound the boolean combinators in predicate analysis
Section 6.2 gives rules for and, or and not, but only `&&` was
implemented. Predicates are usually written with `&` and `|`, which on
booleans mean the same thing, and negation appeared only as something the
analysis itself produced (disjoint's upper bound) and never as something
it could analyse.
- `&`, `|` and `||` join `&&`: all four are monotonically increasing in
both arguments, so each bound is that operator over the corresponding
bounds.
- Negation replaces a hard error. Logical not is monotonically
decreasing, so its bounds are the negated bounds swapped; arithmetic
negation reverses the order of the bounds the same way.
With these, the paper's Section 2 range query
`filter(|x| lo <= x.id & x.id <= hi, ...)` lowers to exactly the
always/maybe pair the paper shows.
* Use stored extrema to skip whole subtrees
The min/max augmentation lookup added with build_extremum could never
fire. Fusing the value-based condition into a filter is what makes
predicate analysis prune on it, but with no filter to fuse into the
wrapper was synthesised anyway, and its always-branch -- the `scan`
construct standing for a wholly included subtree -- was then dropped
because `M(x) < best` has no lower bound. The inclusion case of Section 2
was unreachable.
Now the wrapper is only built when there is a real filter to fuse into.
Lowering the set as it is keeps the scan, and build_extremum handles it:
a node storing this extremum over its subtree settles the contribution
exactly and is never visited, and otherwise the subtree is skipped when
it cannot beat the running best and tightens the accumulator when it can.
`minimum(|p| p.id, points)` over a tree annotated `with min(id) = idl`
now reads the root's stored minimum and stops, and without the annotation
falls back to the `min_wmax` traversal on page 10.
* Add per-operator lowering tests, and fix the C++ runtime on libstdc++
tests/bonsai/lower/setops covers each operator of Figure 2 over one small
interval tree, so the goldens show the traversal each lowering produces
and nothing else. The range predicate is the paper's Section 2 example,
which makes the always and maybe conditions directly comparable to it.
Separate augmented variants show a stored count or extremum folding a
whole subtree in without visiting it.
tests/bonsai/lower/geomops covers each geometric operator, in both
operand orders where Algorithms 5 and 6 give different rules, plus a
dual-tree query for the both-varying cases and a metrics query for
Algorithm 6 lines 15-25. These stop before lower-geometrics, so they
check the derived conditions without needing geometry implementations.
stdlib-resolution.bonsai goes all the way through against the standard
library and so checks the other half: that every operator the analysis
emits on a bounding volume has an implementation to resolve to.
Also fixes runtime/bonsai_cpp.h, which pulled std::round, std::abs and
friends into the global namespace and used bit_cast and memcpy without
including the headers that declare them. libc++ supplies them
transitively, so this only showed up off macOS -- it broke every
correctness/cpp test on Linux. Three of the four now pass; vec still
fails on what looks like a vector-ABI difference between the generated
object code and the hand-written driver.
* Run the set operators end to end against a linear scan
correctness/cpp/setops builds a real interval tree and checks count, sum,
minimum, maximum, any and all against an unpruned scan over the same
data, across ranges that are empty, inside one subtree, spanning several,
and covering everything. A traversal that prunes a subtree it should have
visited, or double-counts one it folded in from an augmentation, shows up
as a mismatch rather than as a golden that merely looks plausible.
Getting there needed the parts of the pipeline a reduction over a tree
touches, which nothing had exercised before:
- A scan over a wholly included subtree can now carry a reduction and a
map, so it folds elements into an accumulator instead of unioning them
into a set. That was the standing "support scan augmentations" TODO.
Scan carries the accumulator it reduces into, and scan functions are
shared per (trees, reduction, map).
- A leaf's array is iterated elementwise when reducing. Appending an
iterable adds all of it at once, which is right for a set and wrong for
an accumulator.
- The C++ backend gained Accumulate, scalar Allocate, Extrema and Build,
and now passes mutating arguments by reference -- without which a
recursive traversal updated a copy of the accumulator and the result
was always the identity.
Also drops tests/bonsai/error/string-literal.expect, which has no
corresponding .bonsai and is not registered, and corrects the label list
in tests/README.md.
* Apply clang-format to the lines this branch changed
CI runs clang-format 19 over the diff.
* Spell the equals upper bound as the paper does
Algorithm 5 line 17 gives the upper bound of equals(v, u) as
contains(V_v, u), not within(V_v, u) as I first read it. The two differ
only in which operator names the relation, and contains(V_v, u) is
exactly the within(u, V_v) that was already being emitted -- so the
behaviour was right, but the earlier commit described a departure from
the paper that does not exist.
Use the paper's spelling. Each single-varying case now keeps the volume
in the position its operand held, which is the convention the algorithms
follow throughout: within(u, V_v) when the second operand varies,
contains(V_v, u) when the first does.
The contains(v, u) deviation noted earlier does stand: Section 6.3 states
that bound as intersects(V_v, u), where this repo uses the tighter and
equally sound contains(V_v, u).
* Correct two more Algorithm 5 rules
Checked every rule in Algorithms 5 and 6 against the text extracted from
the paper rather than against a rendering of the page, which is how the
equals rule got misread. Two upper bounds were wrong:
- covers(v, u) is covers(V_v, u) on line 9, not intersects(V_v, u).
Everything a varying operand covers lies inside its bounding volume, so
this prunes strictly more.
- disjoint(v, u) is not-within(V_v, u) on line 12. Same relation as the
not-contains(u, V_v) being emitted, but spelled with the volume in the
position its operand held, which is the convention the algorithms
follow and which decides the overload lower-geometrics resolves to.
Everything else matches, including all of Algorithm 6 and the metric
bounds. The one remaining deviation is contains(v, u), where line 6 gives
intersects(V_v, u) and this repo uses the tighter contains(V_v, u); the
comment there now notes the paper uses that same tight form for the
corresponding covers case.
* Keep the fused node bound where no augmentation can replace it
Two findings from replaying the pldi-benchmarks suite against this branch.
The closest-point benchmark lost a pruning step. Synthesizing the
`M(x) < best` filter does two things: it lets predicate analysis prune on
the value, and it puts the node's distance bound in front of every match
arm, so a leaf popped from the traversal queue is rejected before its
primitives are scanned. Skipping that whenever there was no filter to
fuse into gave up the second for subtrees that could never have used a
stored extremum anyway. Now it is skipped only when the metric names a
field an augmentation might cover, which is exactly when the `scan` it
consumes is worth keeping.
Counting a leaf became a loop. The elements of a leaf are summed one at a
time, where asking the leaf how many it holds is a single operation.
Summing the same constant over every element is now that constant times
the count, which restores the generated code the benchmarks had. This
needs the free `count()` overloads on `set` and `range`, ported from
pldi-benchmarks; correctness/cpp/setops covers the new path.
* Fix the tree declarations in three benchmarks
apps/pbrt/trace.bonsai and both rtiow variants declared a leaf holding an
array of primitives but never tagged it as the data the tree stores, so
lowering built a match arm that neither yields nor recurses and tripped
an assertion. Every other tree in the repository carries the tag, e.g.
`Leaf(d : array[f32]) with data = d` in apps/queries/range.
rtiow additionally declared `tree[[Sphere]]` while its set, its leaf and
its layout all hold MaterialSphere. The primitive type is what the tree
stores; the bounding volume stays a Sphere, which is what the `with
Sphere(center, radius)` annotation is for.
All three now compile: pbrt and rtiow/cpu to a closest-hit traversal
guarded by intersects and distmin on the node volume, and rtiow/cuda
through the CUDA backend.
These were reached earlier only after this branch's parser fix let
`group[count]` through; before that they failed at parse time, which is
why the underlying problem had not surfaced.
* Point the README at the PLDI 2026 branches
The compiler on main is the general one; the branches carrying the
paper's benchmarks and artifact are easy to miss from here.
* Re-bless the error goldens whose assert line numbers moved
These three goldens record the source line of the internal_assert that
fires, and later edits to Expr.cpp and Parser.cpp shifted those asserts
without the goldens being updated:
Expr.cpp 340 -> 341 (BinOp of non-number or boolean types)
Expr.cpp 276 -> 277 (implicit casting of types)
Parser.cpp 451 -> 469 (duplicate default value for field)
All three asserts sit on a single line, so the reported number does not
depend on the compiler.
* Clang-format bonsai_benchmark.h and u56.h
Both were unformatted, which fails the repo-wide clang-format check.
* Fix two C++ interop bugs that made correctness/cpp/vec print garbage
The vec golden was blessed on uninitialized memory: it recorded
`r: 203935396562725628553461760.000000` for a field the driver sets to
100, and it was missing the "-2 and 5" line that main_vec.cpp prints
unconditionally, so it could not match a correct run on any platform.
Two separate defects were behind it.
printf is variadic, so the default argument promotions apply: a float
arrives as a double, and that is what "%f" reads. print_helper pushed the
narrow f32 straight through, leaving the upper half of the argument
undefined. That is where the garbage came from, and it is why the value
differed between the golden, CI and a local run. Emit an fpext to double
for any float narrower than one.
Separately, vector<T, N> did not match the type the generated code uses.
The backend represents it as LLVM's <N x T>, which rounds the lane count
up to a power of two and which the C ABI passes in a single SSE register
(SSE + SSEUP); the runtime declared a packed T[N] instead, which is
classified as one register per eightbyte. A three-lane f32 vector was
therefore handed over in xmm0+xmm1 and read back out of xmm0 alone,
losing the third lane, and a field following a vector inside an element
sat at the wrong offset -- Sphere::r at 12 rather than 16. Back the
storage with a native vector so the size, alignment and classification
all agree.
Vectors of bytes keep their exact N-byte layout: there they stand in for
a bit-packed field whose offsets the generated layout arithmetic already
depends on, and vector_size cannot express a non-power-of-two size anyway.
The rand goldens gain the fpext instructions; vec now reports the values
the driver actually stores.
* Update exported-function golden for the printf double promotion
* Rename a ctor parameter to satisfy readability-identifier-naming
* Stop ScansToCalls dereferencing its moved-from constructor parameter
* Stop the LLVM backend building a 32-bit target machine make_target_machine computed the host triple into target_triple, used it to look up the llvm::Target, and then passed module.getTargetTriple() to createTargetMachine. The module only gets a triple further down, and only for the ASM and CPP backends, so that argument was the empty string every time. On an x86 host an empty triple selects a generic i386 subtarget. Two things followed. The data layout the CPP backend installs from that machine has 32-bit pointers, so the optimizer laid structs out with 4-byte pointers while the object itself was emitted 64-bit by the separate, correctly tripled target machine in CPP.cpp -- a real miscompile, not a formatting difference. And its TargetTransformInfo reports zero vector registers, so the loop and SLP vectorizers silently did nothing at -O3. AArch64 keeps 64-bit pointers and NEON even for an unknown triple, so none of this showed on the macOS/arm64 machines that CI and the goldens come from. Pass target_triple, which is what the surrounding code already assumes. backends/cpp/not-exported, backends/llvm/exported-function and backends/llvm/map-func have been recording the correct vectorized output all along and now match again. * Emit the grow-capacity select's operands in a defined order CreateSelect was called with CreateICmpEQ and CreateMul as two of its arguments. Each appends an instruction to the block, and the order in which a call's arguments are evaluated is unspecified, so which of the two landed first depended on the compiler that built Bonsai: GCC evaluates right to left and emitted the mul first, Clang left to right and emitted the icmp first. The generated code was correct either way, but the IR a given Bonsai binary prints should not depend on how that binary was built. backends/llvm/dynamic-array records the Clang order. * Reserve a fixed 64 bytes for a dynamic array's mutex The field was sized with the host's sizeof(pthread_mutex_t): 40 bytes on glibc/x86-64, 48 on glibc/aarch64, 64 on Apple libc. That put the host's libc into the layout of a generated struct. apps/cd/cpu/fcl/main.h mirrors this struct by hand and declares the field as a 64-byte vector, so on anything but macOS the generated code and that driver disagreed about the struct's size -- an ABI mismatch, not just golden churn. Reserve the upper bound instead, with a static_assert for a platform that would need more. Over-reserving costs a few bytes per array. * Let a golden be overridden per target architecture Three backends goldens differ between AArch64 and x86-64 for reasons that are not the compiler's doing: LLVM 19 SLP vectorizes a pair of i32 operations on AArch64 and not on x86-64 (backends/cpp/struct, backends/llvm/mut-basic), and SimplifyCFG names one select %spec.select there and %common.ret.op here (backends/llvm/index). No change to Bonsai can make one host produce the other's output. Look for <name>.<arch>.expect next to the base golden and prefer it when it exists. The base files are untouched, so the macOS CI job keeps comparing against exactly what it does today, and the x86-64 overrides added here are what a correct compiler emits on this architecture. check_output.cmake swaps EXPECT before both the diff and the update path, so BONSAI_UPDATE_EXPECT re-blesses an override where one exists rather than overwriting the golden the other architecture depends on. The README says when to reach for this and when not to. It is worth being strict about: the other three differences in this area all looked like the same thing and were real bugs. ctest is now 306/306 on Linux/x86-64.
| #pragma once | ||
|
|
||
| #include <cstdint> | ||
| #include "runtime/bonsai_cpp.h" |
There was a problem hiding this comment.
warning: 'runtime/bonsai_cpp.h' file not found [clang-diagnostic-error]
#include "runtime/bonsai_cpp.h"
^| int32_t project6(const float3 ax, const float3 p1, const float3 p2, | ||
| const float3 p3, const float3 q1, const float3 q2, | ||
| const float3 q3) { | ||
| const float P1 = dot(ax, p1); |
There was a problem hiding this comment.
warning: invalid case style for variable 'P1' [readability-identifier-naming]
| const float P1 = dot(ax, p1); | |
| const float p1 = dot(ax, p1); |
apps/cd/cpu/fcl/cd_profiled.cpp:23:
- const float mn1 = min(min(P1, P2), P3);
+ const float mn1 = min(min(p1, P2), P3);apps/cd/cpu/fcl/cd_profiled.cpp:28:
- const float mx1 = max(max(P1, P2), P3);
+ const float mx1 = max(max(p1, P2), P3);| const float3 p3, const float3 q1, const float3 q2, | ||
| const float3 q3) { | ||
| const float P1 = dot(ax, p1); | ||
| const float P2 = dot(ax, p2); |
There was a problem hiding this comment.
warning: invalid case style for variable 'P2' [readability-identifier-naming]
| const float P2 = dot(ax, p2); | |
| const float p2 = dot(ax, p2); |
apps/cd/cpu/fcl/cd_profiled.cpp:23:
- const float mn1 = min(min(P1, P2), P3);
+ const float mn1 = min(min(P1, p2), P3);apps/cd/cpu/fcl/cd_profiled.cpp:28:
- const float mx1 = max(max(P1, P2), P3);
+ const float mx1 = max(max(P1, p2), P3);| const float3 q3) { | ||
| const float P1 = dot(ax, p1); | ||
| const float P2 = dot(ax, p2); | ||
| const float P3 = dot(ax, p3); |
There was a problem hiding this comment.
warning: invalid case style for variable 'P3' [readability-identifier-naming]
| const float P3 = dot(ax, p3); | |
| const float p3 = dot(ax, p3); |
apps/cd/cpu/fcl/cd_profiled.cpp:23:
- const float mn1 = min(min(P1, P2), P3);
+ const float mn1 = min(min(P1, P2), p3);apps/cd/cpu/fcl/cd_profiled.cpp:28:
- const float mx1 = max(max(P1, P2), P3);
+ const float mx1 = max(max(P1, P2), p3);| const float P1 = dot(ax, p1); | ||
| const float P2 = dot(ax, p2); | ||
| const float P3 = dot(ax, p3); | ||
| const float Q1 = dot(ax, q1); |
There was a problem hiding this comment.
warning: invalid case style for variable 'Q1' [readability-identifier-naming]
| const float Q1 = dot(ax, q1); | |
| const float q1 = dot(ax, q1); |
apps/cd/cpu/fcl/cd_profiled.cpp:24:
- const float mx2 = max(max(Q1, Q2), Q3);
+ const float mx2 = max(max(q1, Q2), Q3);apps/cd/cpu/fcl/cd_profiled.cpp:29:
- const float mn2 = min(min(Q1, Q2), Q3);
+ const float mn2 = min(min(q1, Q2), Q3);| _recloop_func0(_t0, _t1, triangles1, triangles2, _dyn_alloc); | ||
| const uint32_t _t6 = triangles2_index + _t76.offset; | ||
| _recloop_func0(_t0, _t6, triangles1, triangles2, _dyn_alloc); | ||
| const uint32_t _t10 = triangles1_index + _t72.offset; |
There was a problem hiding this comment.
warning: invalid case style for variable '_t10' [readability-identifier-naming]
| const uint32_t _t10 = triangles1_index + _t72.offset; | |
| const uint32_t t10 = triangles1_index + _t72.offset; |
| } | ||
| } else { | ||
| const uint32_t _t66 = _t76.nPrims; | ||
| if (_t66 == 0u) { |
There was a problem hiding this comment.
warning: invalid case style for variable '_t66' [readability-identifier-naming]
| if (_t66 == 0u) { | |
| const uint32_t t66 = _t76.nPrims; | |
| if (t66 == 0u) { |
apps/cd/cpu/fcl/cd_profiled.cpp:157:
- for (uint32_t _idx1 = 0u; _idx1 < _t66; _idx1 += 1u) {
+ for (uint32_t _idx1 = 0u; _idx1 < t66; _idx1 += 1u) {| _recloop_func0(triangles1_index, triangles2_index + _t76.offset, | ||
| triangles1, triangles2, _dyn_alloc); | ||
| } else { | ||
| for (uint32_t _idx0 = 0u; _idx0 < _t70; _idx0 += 1u) { |
There was a problem hiding this comment.
warning: invalid case style for variable '_idx0' [readability-identifier-naming]
| for (uint32_t _idx0 = 0u; _idx0 < _t70; _idx0 += 1u) { | |
| for (uint32_t idx0 = 0u; idx0 < _t70; idx0 += 1u) { |
| triangles1, triangles2, _dyn_alloc); | ||
| } else { | ||
| for (uint32_t _idx0 = 0u; _idx0 < _t70; _idx0 += 1u) { | ||
| for (uint32_t _idx1 = 0u; _idx1 < _t66; _idx1 += 1u) { |
There was a problem hiding this comment.
warning: invalid case style for variable '_idx1' [readability-identifier-naming]
| for (uint32_t _idx1 = 0u; _idx1 < _t66; _idx1 += 1u) { | |
| for (uint32_t idx1 = 0u; idx1 < _t66; idx1 += 1u) { |
| } else { | ||
| for (uint32_t _idx0 = 0u; _idx0 < _t70; _idx0 += 1u) { | ||
| for (uint32_t _idx1 = 0u; _idx1 < _t66; _idx1 += 1u) { | ||
| const Triangle _t39 = |
There was a problem hiding this comment.
warning: invalid case style for variable '_t39' [readability-identifier-naming]
| const Triangle _t39 = | |
| const Triangle t39 = |
|
just the cuda backends failures, those don't work on the SSA branch yet anyways |
No description provided.