Repository navigation
Conversation
|
Can one of the admins verify this patch? |
|
Thanks for submitting this. Actually Spark SQL/catalyst itself already supports more than 22 fields. It's just that case classes in Scala 2.10 doesn't. As long as the user's class (not case classes) implements the Product interface, it should be fine. Instead of introducing a new API, do you mind updating the documentation to indicate that? (i.e. any concrete implementations of Product are fine; case class is merely a special example of that) |
|
The upcoming Scala 2.11 now supports case classes with more than 22 fields https://issues.scala-lang.org/browse/SI-7296 |
|
ok, i will update the doc to indicate this |
|
hi, i update this patch to an example that query table with more than 22 fields by implementing the Product interface |
Don't clone records for text files
Don't clone records for text files (cherry picked from commit 74b46ac) Signed-off-by: Reynold Xin <[email protected]>
### What changes were proposed in this pull request? Task 195's first-query benchmark, fixed, and its measurement. **The fix.** `VarkaColdStartBenchmark` gave each iteration fresh offsets of `10000 * (iteration + 1)` so that nothing is cached, and those offsets are also `add_months` month counts. The Varka kernel runs a batch only while a month count is within `VarkaChrono.MONTH_ARITH_MAX_MONTHS` (24564); past it the batch goes to Spark's row path. So from the third iteration on, and on every second-run iteration, the Varka arm timed vanilla's code, and the results file merged with the task was measured that way. Iterations are now a hundred apart, the largest offset is checked against the kernel's bound at start, and the fusion check runs at the largest offset each case uses. The size ladder's shared check, `VarkaSizeLadder.varkaFused`, now also requires every fallback counter of the node to be zero, so a run with any batch on the row path fails. **The measurement**, on the quiet laptop at both widths. A new shape's first query is slower on Varka than on vanilla at every rung: at 100 entries 1260 against 872 ms for a hundred thousand rows. The JVM says why: under `-XX:+PrintCompilation` not one of the kernels' loop or epilogue methods is compiled at any tier in the whole run, while vanilla's generated `processNext` is compiled 506 times in the same log. A kernel's loop is called once per batch - ten times for a hundred thousand rows at the cache's default 10,000-row batch, about 625 iterations each - short of every first-tier compile threshold (200 calls, 2,000 calls and iterations with at least 100 calls, or 60,000 iterations in one call), so the query runs in the bytecode interpreter, where every Vector API operation is a library call. `PLAN_TASK_195.md` 5 scores the six predictions (two held, one partly, three refuted) and names the design questions for the next milestone: start a new shape on the row path, emit one loop per partition, or compile ahead of time. The JIT lesson is in `the-jit.md`. The branch also carries apache#428's fix, so that its quote check passes before apache#428 merges. ### Why are the changes needed? The second post's first-query bound rests on this number, and the merged benchmark measured the wrong thing. ### Does this PR introduce _any_ user-facing change? No. ### How was this patch tested? The smoke mode and the full run pass the new checks at every rung; scalastyle, the quote check and the Varka pre-commit checks pass. ### Was this patch authored or co-authored using generative AI tooling? Generated-by: Claude Code (Claude Opus 5.5)
### What changes were proposed in this pull request? Task 198's quiet run, which apache#388 merged without: `VarkaSharedPrefixBenchmark` regenerated on the quiet laptop at both widths, a band from five repeats, and `PLAN_TASK_198.md` 6 scoring the three predictions. - **The computed-once prefix is admitted, and row 200 with it.** Sixty groups cost 2.7 times the default twelve on the wide run (2.5 narrow), and the default's repeated prefixes are at most about 40% of its time (33% narrow), above the 20% the admission asked for. It is a ceiling, since each extra group also reloads the column and runs its own loop. - **The cheap-tail cliff is decided per JVM run, not by grouping.** The same kernel ran fast in some runs and about sixty times slower in others; the one-group kernel was fast in all five band runs and slow in the regeneration's single run, and the pattern reverses at 128 bits. Row 209 now starts from the JVM's own evidence rather than timings, and the committed cheap-tail rows are marked as a slow-mode run. The branch also carries apache#428's fix, so that its quote check passes before apache#428 merges. ### Why are the changes needed? The admission check is the decision this task exists to make, and apache#388 merged before the quiet window. ### Does this PR introduce _any_ user-facing change? No. ### How was this patch tested? The canary passed before the run; the quote check and the Varka pre-commit checks pass. ### Was this patch authored or co-authored using generative AI tooling? Generated-by: Claude Code (Claude Opus 5.5)
No description provided.