Repository navigation
optimization: Build the G-code preview in C++ - #4481
Conversation
bd037e7 to
c0bf905
Compare
|
What are all those json files doing in there? It seems you want to do some "bake" test, but I did not see a Another point, you are "redecorating" the gcodemodule. Would it be an idea if we move this to pybind11 at the same time? Doing this work twice may be more work and may also be error prone. |
c0bf905 to
0b8fa5f
Compare
My fault, forgot to add test.sh - done now. JSON files are reference results for related .ngc files from another folder. No problem with headless - these tests are for C++ routines that do math only - no GUI, no graphics.
Any WIP on this or samples? Yes, I can work on pybind11 conversion, but any existing refrerences to such change in LinuxCNC will be helpful. If any |
|
I agree test files do not look good. I will rework it to easily see what each case is testing. In time being, I'd appreciate feedback on the rest of PR. |
OK, I have found halquery is using pybind now. I will try to rework gcodemodule to use it too in this branch. |
0b8fa5f to
7597f74
Compare
|
Reworked with pybind11 , it is a pleasure to work with. Resulting code is much easier to read and follow! Added some modern C++ which gcodemodule.cc deserve ) Tests reworked too. |
|
Last commit is breaking compatibility - returns tuples instead of arrays is not good idea, breaks code on Python side. I will revert this at Monday. |
It was false alarm, problem not caused by this code. Everything seems to be OK and ready for review and testing. Current live testing results: loading of 418Mb .ngc file (real work file sent by customer, with G2 arcs): 25 seconds to first render. |
🤤 |
Together with PR #4491 : 12 seconds! P.S. As said before AXIS [specially AXIS] is using not optimised file editor code that now eats more memory and CPU than graphical preview. So for benchmarking I cut it off. Worth to be optimised too, may be later. |
|
Could you please fetch master, then merge or rebase and push, just to let the CI run again, and we shall get the shots of all the UIs to make sure nothing regressed. |
2564163 to
075e6b8
Compare
Done. And squashed to one commit. |
|
And the screenshots seem to be similar to what we see elsewhere. |
|
Finished with changes, hope all mentioned is fixed now |
|
You might want to look at CI the clang is reporting failures, we have it fail on warnings, gotta clean those up. |
fixed with last commit. |
NTULINUX
left a comment
There was a problem hiding this comment.
Very awesome, thank you!
|
BsAtHome sorry, I clicked "request review" by mistake. |
|
Pushed documentation update, must be good to go now. |
|
Last commit adds ability for Python code to request actual machine axis positions array along with usually returned visual XYZ points. It is optional and disabled by default. It may be useful for advanced rendering or program analysis. |
|
Tool offsets is useful to build correct re-presentation based on AXIS coordinates [ like vismach ] . So it is returned too as sorted tuples, records mark line range affected. ProgramGeometry in python knowns how to parse it. |
Just pushed and understood that implementation is invalid - it must index not line# but idx# in move array. It'd be incorrect if tool offsets change mid line. Not sure if that is possible but anyway better to fix. I will submit better implementation next week. |
|
BTW, you need to rebase because there is a conflict now. |
07e4603 to
a46e1c7
Compare
done |
|
Probably need one more step here: I almost implemented TimeEstimateCanon in C++ which does close-to-real time estimate during parse and return it to GUI. It would deserve separate PR but because it changes gcodemodule.cc internals it may be here too. Let me know if separate PR is better choice. |
A 98% match is better than most people can guess, I guess.
I think this PR has been boiling quite enough for now. The speed improvement is a good thing. Improving on it can be the next update. |
|
I completely agree: this PR is ready to be served. I'll add one small refactoring : split GcodeRenderer to 2 classes, one that is base and second is preview-targeted. And it will be enough for this branch and ready to merge. Next PR for time estimate will use the base class to do its own job, and it will be add-on only not touching the preview itself, I think it will be best that way. And time estimate definitely will work much better than Win 3.11 install progress ) |
|
And please squash the commits, if you can. |
Adds C++ GCodeRenderer, which builds the whole preview - transform, arcs, taps, suppression, vertices, extents, lengths and event records - during gcode.parse and hands it over once, replacing the Python rendering engine. C++ handles Vec[9] -> X,Y,Z transform completely, and Python renders it into OpenGL using shaders. 2 protocols to interact with python: CallbackCanon (compat) and GCodeRenderer (new). Selected when "parse" method called based on canon properties.
9dd8985 to
dad6bc1
Compare
|
After trying I decided to abandon idea of the class split - code becomes too noisy and hard to follow. So I squashed all commits already reviewed. Last problem I found accidentally - LineCode pybind11 rewrite slow down it. It does not affect new rendering code, but those who will use old python canon protocol (where all moves are reported to python methods) will be affected. And it is not cosmetic (numbers below). So I rewrote it back to C++ struct shared to python without pybind11. I made this a separate commit. After review, it is ready to merge [ I can do squash again ] Benchmark8M-move pure-G1 file, dev container, both
The first row is exactly the 0.80 s the plan attributed to the object. The other two are the part the plan listed as unmeasured, and it was the larger half: a field read went from ~125 ns (pybind11 property lambda) to ~19 ns (descriptor over a struct offset). |
Follows PR##4293
Adds C++ GCodeRenderer, which builds the whole preview - transform, arcs, taps, suppression, vertices, extents, lengths and event records - during gcode.parse and hands it over once, replacing the Python rendering engine. C++ handles Vec[9] -> X,Y,Z transform completely, following all interpretator details, and Python renders it into OpenGL using shaders.
Parsing is ~2.9x faster on move-shaped programs and peaks at less memory; and specially for arcs, the last per-move Python call kept in code, go from 1.58 s to 0.075 s at 1.28M segments.
Even without speed benefit it is anyway better because resulting code is much more clean and easy to follow. Previous code was hard to read, understand and test. Right now we can test GCodeRenderer engine directly, it is independent of presentation.
Benchmark results, compare to current master
Headless,
fractal-1M.ngc(1,000,149 moves):Byte-identical geometry out, ~3.7x less time to produce it.
Results could be much better if ngc file use arcs (current master calculates arcs in Python which was bad idea, after moving to C++ it is 100x faster).