A Feature Request about the Timeline and Node-based Procedural

[Anonymous]

I often drag feature in the timeline for getting reference, the current timeline control function is very useful and important to me to get those information. But it's not the best practice, for obvious cons:

- Messy logic, like component A (feature 1,2), component B (feature 1,2), component A(feature 3 for getting input from component B, eg. profile, path, cutting tool, etc.). 

- For the timeline logic limitation, it's slow as a single core single threading application which waste other CPU cores. It often take dozens of seconds for some feature, that lag makes a bad user experience recall me back Windows 95 application with a sandglass icon. It get me sad for the CAD computers with 4 or 8 cores in 2020.

I would suggest a feature/solution which used in Houdini (a famous cinema industry 3D modelling/animation software like Maya) successfully : Node-based Procedurals

- All features are node based, a component has interval time-based procedural nodes for features , but each component is independent in timeline as their nature

The above example could look like:

The pros:

- Clear logic 

- 400%-800% speed up by multiple threading application that takes the advantage of all CPU cores. That would bring a great benefit and advantage vs competitors.

[jeff_strater]

this already exists, but has never been fully enabled for users.  You can enable it using the following text command:  "Fusion.ParallelComputing /on".  It does exactly as you describe - each component's features are computed on a different thread, until there is a cross-component reference.  If you are careful in how you create your components, you can see some benefit of this, but the gains are not often great, because often there are cross-component references, and there are also some steps, such as faceting the results, which are inherently single-threaded.

[Anonymous]

That's an exciting news although it's not node-based. I did a quick test with one of projects and see the big difference.

Compute all time:

| Fusion.ParallelComputing /off | 19.15s|

| Fusion.ParallelComputing /on | 12.7s |

This is a small project that has about 30 features, my manually testing could have +- 0.5s error, but overall, it has around 50% performance improvement on my laptop with 2 core CPU. 

Is there command for turn on logs and profiler? BTW, where can I find command line document? I can't find it by googling. 

The node graph would provide more logical and better organizing for parametric design. The current "timeline + browser" approach is good, but still could be improved. For example, a component has many feature and each feature has many input source like path, profile, cutting tools, etc. The current timeline + browser solution can't show the logic behind them, and the parameter table is awkward. In short, the current solution is outdated, lacking of logic visibility, big picture and pipeline oriented. The better solution is node-based pipeline like this:

Houdini , https://www.sidefx.com/docs/houdini/basics/intro.html

Since node-based pipeline is more advanced, we can see more and more software use this solution, for example, Blender node pipeline :

[jeff_strater]

this is a node-based system, there is just no way to see the node graph.  There are hundreds of nodes, though, so I'm not sure you would make much sense from it even if you could see it.

There is no documentation for the text command system.  It's really an internal debug tool, but sometimes we put stuff there like this that can be useful outside.

There is not much of a profiler, but for this particular area there are a couple of useful tools:  "Fusion.DumpFeaturesByComputeTime" lists out all the features in your design, and how long each took to compute.  The other is "Fusion.ComputeTime", which will dump out the total compute time, and if parallel compute is on, will show the difference between the two.  If you add on a "/f", it will force a recompute, which will be more accurate, but could take some time

[Anonymous]

That's cool, very helpful. 

Here's my test result with the command:

Fusion.ComputeTime 
Available CPU count:	4
Serial compute time:	26.0652
Parallel compute time:	11.5965
Speed up ratio:	2.24767

My laptop's i7 CPU actually has 2 physical cores and 4 HT. 224% speed up, that's awesome! Why don't you guys release the feature?

About the node-based system, as my understanding, the programming architecture is node-based, providing the parallel computing that is a very big improvement. I am excited by this node-based inside, just looking forward of a node-based outside , user interface, to allow users to utilize the power of node-based system. If I open a medium or big project from my workmates or projects made by myself couple weeks ago, I don't remember the details,  so it would take me lots of time to open the feature one by one to figure out the logic behind them, what's the feature's input source like profile, path, cutting tools, etc, there's no map or graph to reveal the logic and process in one picture. That might be ok for artist's visual project , but not good for engineer's CAD project. We often break the design pipeline accidentally, it would take more hours to fix them. I can't tell accurate number, maybe 10%~50% case by case.

I really like Fusion 360 and appreciate you guys' awesome work, and I know the node-based UI will bring lots of work. Just hope Fusion 360 team can consider this feature request, let me know if you want to discuss further.  

Thank you Jeff.