Subdivision Surface: add dependency graph tracking when CPU mesh is needed #104461

Open
Alexander Gavrilov wants to merge 1 commits from angavrilov/blender:pr-depsgraph-subdiv-cpu into main

When changing the target branch, be careful to rebase the branch in your fork to match. See documentation.

After addition of GPU subdivision it is necessary to choose between
using CPU or GPU for a particular object when both ways are technically
possible. Choosing GPU when the mesh is also needed by CPU code would
cause subdivision to be run twice when the CPU mesh is requested by
other code.

This patch adds a simple way to track dependencies that need the CPU
mesh through dependency graph via an already existing mechanism.

Constraints targeting mesh vertex groups, as well as likely modifiers
now tag their targets with a dependency graph flag to notify that the
fully evaluated mesh is needed on the CPU. This is used to disable GPU
subdiv in those cases.

In addition, the evaluated mesh is used by sculpt and paint modes,
so GPU subdivision is disabled in that case too.


One question to consider is the desired behavior for the Geometry Nodes
modifier, since the dependency code doesn't know if the nodes will actually
use the geometry of the object, or only its transformation.

After addition of GPU subdivision it is necessary to choose between using CPU or GPU for a particular object when both ways are technically possible. Choosing GPU when the mesh is also needed by CPU code would cause subdivision to be run twice when the CPU mesh is requested by other code. This patch adds a simple way to track dependencies that need the CPU mesh through dependency graph via an already existing mechanism. Constraints targeting mesh vertex groups, as well as likely modifiers now tag their targets with a dependency graph flag to notify that the fully evaluated mesh is needed on the CPU. This is used to disable GPU subdiv in those cases. In addition, the evaluated mesh is used by sculpt and paint modes, so GPU subdivision is disabled in that case too. ----- One question to consider is the desired behavior for the Geometry Nodes modifier, since the dependency code doesn't know if the nodes will actually use the geometry of the object, or only its transformation.
Alexander Gavrilov requested review from Sergey Sharybin 2023-02-08 12:37:06 +01:00
Alexander Gavrilov added this to the Core project 2023-02-08 12:53:37 +01:00
Member

One question to consider is the desired behavior for the Geometry Nodes
modifier, since the dependency code doesn't know if the nodes will actually
use the geometry of the object, or only its transformation.

I think it would be better to be conservative and not request the CPU mesh by default. Hopefully in the (probably far) future we'll have a tighter integration with geometry nodes and the depsgraph so this problem could be solved differently. Not exactly sure what that would look like though.

But anyway, I think that's better than making performance much worse whenever just using an object's position.

>One question to consider is the desired behavior for the Geometry Nodes modifier, since the dependency code doesn't know if the nodes will actually use the geometry of the object, or only its transformation. I think it would be better to be conservative and not request the CPU mesh by default. Hopefully in the (probably far) future we'll have a tighter integration with geometry nodes and the depsgraph so this problem could be solved differently. Not exactly sure what that would look like though. But anyway, I think that's better than making performance much worse whenever just using an object's position.
Hans Goudey reviewed 2023-02-08 14:40:59 +01:00
@ -117,0 +117,4 @@
static bool subsurf_modifier_has_cpu_dependents(const Depsgraph *depsgraph, const Object *ob)
{
/* The sculpt and paint mode UI requires the mesh. */
if (ob->mode & OB_MODE_ALL_SCULPT) {
Member

I can understand why paint mode needs the mesh, but from what I remember about sculpt mode, it doesn't seem to. What am I missing there?

I can understand why paint mode needs the mesh, but from what I remember about sculpt mode, it doesn't seem to. What am I missing there?
Author
Member

Anything that calls sculpt_update_object (e.g. via BKE_sculpt_update_object_after_eval) would access the mesh. It is possible that code retrieves the mesh even when it doesn't need it and can be improved, but that is probably out of the scope of this patch.

One thing though, this code here probably should check DEG_is_active too - the location calling to BKE_sculpt_update_object_after_eval does check it.

Anything that calls `sculpt_update_object` (e.g. via `BKE_sculpt_update_object_after_eval`) would access the mesh. It is possible that code retrieves the mesh even when it doesn't need it and can be improved, but that is probably out of the scope of this patch. One thing though, this code here probably should check `DEG_is_active` too - the location calling to `BKE_sculpt_update_object_after_eval` does check it.
@ -429,1 +428,3 @@
uiItemL(layout, "Autosmooth or custom normals detected, disabling GPU subdivision", ICON_INFO);
if (BKE_subsurf_modifier_force_disable_gpu_evaluation_for_mesh(depsgraph, ob, mesh, smd)) {
uiItemL(layout,
"Disabling GPU subdivision due to autosmooth, custom normals or dependencies",
Member

I'm not sure an optimization like this deserves a UI label. If there is a way to show whether GPU subdivision is being used, it should probably be more subtle IMO.

I'm not sure an optimization like this deserves a UI label. If there is a way to show whether GPU subdivision is being used, it should probably be more subtle IMO.
Author
Member

Well, I wasn't the one who put this here, I just change the text to reflect my additions ;)

Well, I wasn't the one who put this here, I just change the text to reflect my additions ;)

Custom normals are incompatible with subdivision surfaces. The fact that GPU subdivision is disabled in the presence of such normals is to start a differentiation between workflows with custom shading and workflows with subdivision surfaces. See #68891 and #68893. This is what this UI label is for. Essentially to put in users mind that subdivision and custom normals should be different workflows. It only affects GPU subdivision as it is easier/more acceptable to prevent new features from introducing "bad" workflows than breaking compatibility.

Custom normals are incompatible with subdivision surfaces. The fact that GPU subdivision is disabled in the presence of such normals is to start a differentiation between workflows with custom shading and workflows with subdivision surfaces. See #68891 and #68893. This is what this UI label is for. Essentially to put in users mind that subdivision and custom normals should be different workflows. It only affects GPU subdivision as it is easier/more acceptable to prevent new features from introducing "bad" workflows than breaking compatibility.
Author
Member

Custom normals are incompatible with subdivision surfaces. ... Essentially to put in users mind that subdivision and custom normals should be different workflows.

If you really mean this, rather than just simplifying the phrase 'the GPU implementation of subdivision surfaces', I think the NPR people will very much beg to differ. In fact, the subdivision surface modifier specifically has an option to subdivide and interpolate custom normals.

In my view the purpose of the message is to let the user know when the GPU optimization won't be used, so they can be aware and plan accordingly. IIRC something similar happened in 2.7* versions. In #104441 I even added a message tracking the internal state when it is actually being used for feedback.

> Custom normals are incompatible with subdivision surfaces. ... Essentially to put in users mind that subdivision and custom normals should be different workflows. If you really mean this, rather than just simplifying the phrase 'the *GPU implementation* of subdivision surfaces', I think the NPR people will *very much* beg to differ. In fact, the subdivision surface modifier specifically has an option to subdivide and interpolate custom normals. In my view the purpose of the message is to let the user know when the GPU optimization won't be used, so they can be aware and plan accordingly. IIRC something similar happened in 2.7* versions. In #104441 I even added a message tracking the internal state when it is actually being used for feedback.
First-time contributor

Will this somehow help with #102012, #102127?

Will this somehow help with https://projects.blender.org/blender/blender/issues/102012, https://projects.blender.org/blender/blender/issues/102127?
Author
Member

Will this somehow help with #102012, #102127?

I think it was most likely largely helped by #104441 already. This would produce further improvement, but smaller in comparison to that one.

> Will this somehow help with #102012, #102127? I think it was most likely largely helped by #104441 already. This would produce further improvement, but smaller in comparison to that one.
Alexander Gavrilov requested review from Kévin Dietrich 2023-02-09 09:32:54 +01:00
Alexander Gavrilov force-pushed pr-depsgraph-subdiv-cpu from ac2a835af4 to b815f2bc92 2023-02-09 09:43:05 +01:00 Compare
First-time contributor

Will this somehow help with #102012, #102127?

I think it was most likely largely helped by #104441 already. This would produce further improvement, but smaller in comparison to that one.

Yes, it really helped in both cases and + one more, I couldn't find the report, the problem was with a very large slowdown in operations with shape keys, when the GPU Subdivision was turned on

> > Will this somehow help with #102012, #102127? > > I think it was most likely largely helped by #104441 already. This would produce further improvement, but smaller in comparison to that one. Yes, it really helped in both cases and + one more, I couldn't find the report, the problem was with a very large slowdown in operations with shape keys, when the GPU Subdivision was turned on

One question to consider is the desired behavior for the Geometry Nodes
modifier, since the dependency code doesn't know if the nodes will actually
use the geometry of the object, or only its transformation.

I am not sure why the geometry nodes are different from the modifiers in this regard. The modifiers explicitly desitinguish transform from geometry components using DEG_OB_COMP_TRANSFORM and DEG_OB_COMP_GEOMETRY components passed to the DEG_add_object_relation(). I'd imagine the geometry nodes can (and should) do the same thing.

I think it would be better to be conservative and not request the CPU mesh by default.

Not sure what is the exact proposal of how to achieve this?


As for the implementation of this patch, things like DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF); seems far to specific. What if we add other GPU-side modifiers?

And why do we need such explicit flag?

Ideally I'd imagine that the modifier will provide capability that it can be evaluated on GPU, and then the dependency graph can provide information about where the modifier is to be evaluated.

Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side.

> One question to consider is the desired behavior for the Geometry Nodes modifier, since the dependency code doesn't know if the nodes will actually use the geometry of the object, or only its transformation. I am not sure why the geometry nodes are different from the modifiers in this regard. The modifiers explicitly desitinguish transform from geometry components using `DEG_OB_COMP_TRANSFORM` and `DEG_OB_COMP_GEOMETRY` components passed to the `DEG_add_object_relation()`. I'd imagine the geometry nodes can (and should) do the same thing. > I think it would be better to be conservative and not request the CPU mesh by default. Not sure what is the exact proposal of how to achieve this? --- As for the implementation of this patch, things like `DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF);` seems far to specific. What if we add other GPU-side modifiers? And why do we need such explicit flag? Ideally I'd imagine that the modifier will provide capability that it can be evaluated on GPU, and then the dependency graph can provide information about where the modifier is to be evaluated. Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side.
Sergey Sharybin requested changes 2023-02-13 11:16:45 +01:00
Sergey Sharybin left a comment
Owner

Marking as Requested changes since the design of the solution does not really seem optimal and at least requires much better explanation on the decision.

Marking as `Requested changes` since the design of the solution does not really seem optimal and at least requires much better explanation on the decision.
Author
Member

I am not sure why the geometry nodes are different from the modifiers in this regard. The modifiers explicitly desitinguish transform from geometry components using DEG_OB_COMP_TRANSFORM and DEG_OB_COMP_GEOMETRY components passed to the DEG_add_object_relation(). I'd imagine the geometry nodes can (and should) do the same thing.

Because the Geometry Nodes modifier currently only knows that an object is referenced, and has no idea what the object is used for. It's possible the actual nodes only access the transform, for instance; or the node may not even be connected to the output at all and not evaluated.

As for the implementation of this patch, things like DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF); seems far to specific. What if we add other GPU-side modifiers?

Maybe rename to DAG_EVAL_NEED_CPU_EVALUATED_MESH?

Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side.

Because it does not mean that. For one, there are modifiers like Collision which save a snapshot of a particular point in the modifier stack, and all physics collision dependencies want GEOMETRY to ensure it is evaluated, but don't care about the final evaluated mesh.

> I am not sure why the geometry nodes are different from the modifiers in this regard. The modifiers explicitly desitinguish transform from geometry components using `DEG_OB_COMP_TRANSFORM` and `DEG_OB_COMP_GEOMETRY` components passed to the `DEG_add_object_relation()`. I'd imagine the geometry nodes can (and should) do the same thing. Because the Geometry Nodes modifier currently only knows that an object is referenced, and has no idea what the object is used for. It's possible the actual nodes only access the transform, for instance; or the node may not even be connected to the output at all and not evaluated. > As for the implementation of this patch, things like `DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF);` seems far to specific. What if we add other GPU-side modifiers? Maybe rename to `DAG_EVAL_NEED_CPU_EVALUATED_MESH`? > Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side. Because it does not mean that. For one, there are modifiers like Collision which save a snapshot of a particular point in the modifier stack, and all physics collision dependencies want GEOMETRY to ensure it is evaluated, but don't care about the final evaluated mesh.

From the design perspective of the dependency graph relation means data dependency.

The collision case you're mentioning is kinda a violation of this design, and I'd rather see that un-entagled than adding a fragile low-level band-aid.

If the collision relation will point to the collision modifier instead of the component the benefits you're gaining are:

  • Allowance of a more tricky setups, without introducing "fake" dependency cycles.
  • Treat all modifiers in the stack which follow (up to) modifier with an outgoing relation to another component as "data needs to be on CPU"
  • Avoid requirement of adding extra hint in every other relation creation other than the collision relation
  • Bring the dependency graph closer to the original design (relation == data dependency).

We might also introduce a relation flag to facilitate the collision relations builder if needed.

From the design perspective of the dependency graph relation means data dependency. The collision case you're mentioning is kinda a violation of this design, and I'd rather see that un-entagled than adding a fragile low-level band-aid. If the collision relation will point to the collision modifier instead of the component the benefits you're gaining are: - Allowance of a more tricky setups, without introducing "fake" dependency cycles. - Treat all modifiers in the stack which follow (up to) modifier with an outgoing relation to another component as "data needs to be on CPU" - Avoid requirement of adding extra hint in every other relation creation other than the collision relation - Bring the dependency graph closer to the original design (relation == data dependency). We might also introduce a relation flag to facilitate the collision relations builder if needed.
Alexander Gavrilov force-pushed pr-depsgraph-subdiv-cpu from b815f2bc92 to 42dd5bc091 2023-03-20 11:48:50 +01:00 Compare
Alexander Gavrilov force-pushed pr-depsgraph-subdiv-cpu from 42dd5bc091 to 7d5a6e7caf 2023-03-20 12:19:03 +01:00 Compare
Author
Member

As for the implementation of this patch, things like DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF); seems far to specific. What if we add other GPU-side modifiers?

I renamed the flag to DAG_EVAL_NEED_CPU_EVALUATED_MESH to make it more generic.

Ideally I'd imagine that the modifier will provide capability that it can be evaluated on GPU, and then the dependency graph can provide information about where the modifier is to be evaluated.

The flag is providing this information, though.

Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side.

This won't work, because there almost always are dependencies on the geometry component, e.g. DIMENSIONS(), GEOMETRY_EVAL_DONE() of a collection, DUPLI() etc. In the case of simple instancing, none of these need the cpu mesh, so a special flag is necessary in any case. In case of rigid body, there is even an option to use the deform-only mesh for collision.

The only question is whether the flag should be attached to the object like in this implementation, or the relation (possibly with the default being 'needs everything' and the flag marking relations that don't) and then propagated to an object status somehow.

From the design perspective of the dependency graph relation means data dependency.

However it does not mean a dependency on the complete evaluated mesh.

If the collision relation will point to the collision modifier instead of the component the benefits you're gaining are:

Currently it can't work because modifier nodes are dummies and the actual evaluation happens in GEOMETRY_EVAL().

  • Treat all modifiers in the stack which follow (up to) modifier with an outgoing relation to another component as "data needs to be on CPU"

As mentioned before, dependency on geometry does not mean dependency on the fully evaluated mesh on CPU.

> As for the implementation of this patch, things like `DEG_add_collection_geometry_special_eval_flag(ctx->node, col, DAG_EVAL_NEED_CPU_SUBSURF);` seems far to specific. What if we add other GPU-side modifiers? I renamed the flag to DAG_EVAL_NEED_CPU_EVALUATED_MESH to make it more generic. > Ideally I'd imagine that the modifier will provide capability that it can be evaluated on GPU, and then the dependency graph can provide information about where the modifier is to be evaluated. The flag is providing this information, though. > Until then I do not really see why can't we imply that dependency on the geometry component means the geometry is to exist on the CPU side. This won't work, because there almost always are dependencies on the geometry component, e.g. `DIMENSIONS()`, `GEOMETRY_EVAL_DONE()` of a collection, `DUPLI()` etc. In the case of simple instancing, none of these need the cpu mesh, so a special flag is necessary in any case. In case of rigid body, there is even an option to use the deform-only mesh for collision. The only question is whether the flag should be attached to the object like in this implementation, or the relation (possibly with the default being 'needs everything' and the flag marking relations that don't) and then propagated to an object status somehow. > From the design perspective of the dependency graph relation means data dependency. However it does not mean a dependency on the complete evaluated mesh. > If the collision relation will point to the collision modifier instead of the component the benefits you're gaining are: Currently it can't work because modifier nodes are dummies and the actual evaluation happens in `GEOMETRY_EVAL()`. > - Treat all modifiers in the stack which follow (up to) modifier with an outgoing relation to another component as "data needs to be on CPU" As mentioned before, dependency on geometry does not mean dependency on the fully evaluated mesh on CPU.
Hans Goudey changed title from Subdivision Surface: add dependency graph tracking when cpu mesh is needed. to Subdivision Surface: add dependency graph tracking when CPU mesh is needed 2023-03-20 14:38:45 +01:00

For DIMENSIONS and collection's GEOMETRY_EVAL_DONE and can (and probably should) to introduce the other type of relations which will mean "evaluation order only".

The DUPLI I do not remember from the top of my head the exact topology, but dupli-verts will need the final evaluated mesh.

For the rigid body I'd rather have a solution in the DepsgraphRelationBuilder::build_rigidbody which will align relations better with the actual usage of the dependencies with the solver: if the solver does not access the final evaluated mesh it should not add relation to the final state.

Those kind of solver dependencies were always a mess, and nowadays we can do much better job in routing the relations properly.

Long story short: I'd really like to see an effort of solving the root causes in a more localized areas.

For `DIMENSIONS` and collection's `GEOMETRY_EVAL_DONE` and can (and probably should) to introduce the other type of relations which will mean "evaluation order only". The `DUPLI` I do not remember from the top of my head the exact topology, but dupli-verts will need the final evaluated mesh. For the rigid body I'd rather have a solution in the `DepsgraphRelationBuilder::build_rigidbody` which will align relations better with the actual usage of the dependencies with the solver: if the solver does not access the final evaluated mesh it should not add relation to the final state. Those kind of solver dependencies were always a mess, and nowadays we can do much better job in routing the relations properly. Long story short: I'd really like to see an effort of solving the root causes in a more localized areas.
Author
Member

if the solver does not access the final evaluated mesh it should not add relation to the final state.

This is all moot while modifier evaluation actually happens in GEOMETRY_EVAL(). While evaluation works in the same as it does now, it is completely impossible to decouple dependencies on different parts of the evaluated state.

In case of rigid body specifically, there is an option that specifies which version of the mesh it uses for collision, and the default is actually the Deform Only evaluated mesh. It is thus bound to the same GEOMETRY_EVAL bottleneck as snapshotting modifiers like collision.

> if the solver does not access the final evaluated mesh it should not add relation to the final state. This is all moot while modifier evaluation actually happens in `GEOMETRY_EVAL()`. While evaluation works in the same as it does now, it is completely impossible to decouple dependencies on different parts of the evaluated state. In case of rigid body specifically, there is an option that specifies which version of the mesh it uses for collision, and the default is actually the Deform Only evaluated mesh. It is thus bound to the same `GEOMETRY_EVAL` bottleneck as snapshotting modifiers like collision.

I am not sure why its considered really completely impossible.

To me it seems that it is possible to do some (conceptually) simple modifications in the graph to handle the physics relations more properly.

For example, you can add a GEOMETRY_FINAL exit no-op operation for the geometry component (wich will be executed after the GEOMETRY_EVAL), and route relations which needs the final evaluated mesh to it. Operations which do not need final state but something that is evaluated as a part of modifier stack (like, orco or deform-only) will still point to the GEOMETRY_EVAL.

I am not sure why its considered really completely impossible. To me it seems that it is possible to do some (conceptually) simple modifications in the graph to handle the physics relations more properly. For example, you can add a `GEOMETRY_FINAL` exit no-op operation for the geometry component (wich will be executed after the `GEOMETRY_EVAL`), and route relations which needs the final evaluated mesh to it. Operations which do not need final state but something that is evaluated as a part of modifier stack (like, orco or deform-only) will still point to the `GEOMETRY_EVAL`.
Author
Member

I am not sure why its considered really completely impossible.

Well, let's say it requires changes to the dependency graph that are beyond my understanding of the overall design, so I need design suggestions from somebody like you.

For example, you can add a GEOMETRY_FINAL

That could work, but:

  • How would the modifier access outgoing relation information?
  • How would that node work with implicit relations to other abstract 'final' nodes that are always created and thus don't mean anything in the context of the issue at hand? (are there any such relations?)
  • There are some kind of geometry eval done nodes in collections, which are used for some dependencies targeting a collection. These usages may or may not imply dependency on the final geometry, so how would you deal with that?
> I am not sure why its considered really completely impossible. Well, let's say it requires changes to the dependency graph that are beyond my understanding of the overall design, so I need design suggestions from somebody like you. > For example, you can add a GEOMETRY_FINAL That could work, but: * How would the modifier access outgoing relation information? * How would that node work with implicit relations to other abstract 'final' nodes that are always created and thus don't mean anything in the context of the issue at hand? (are there any such relations?) * There are some kind of geometry eval done nodes in collections, which are used for some dependencies targeting a collection. These usages may or may not imply dependency on the final geometry, so how would you deal with that?

How would the modifier access outgoing relation information?

I would do it on the depsgraph issue, as the post-build pass to see if there are links coming from the EVAL_DONE node in the geometry component to other IDs.

How would that node work with implicit relations to other abstract 'final' nodes that are always created and thus don't mean anything in the context of the issue at hand? (are there any such relations?)

I am not really sure what implicit relations those are.

There are some kind of geometry eval done nodes in collections

Yeah, those would need some indirection check.

The collection geometry is used to allow modifiers referencing collection as geometry. It was done for the boolean modifiers: https://archive.blender.org/developer/D11053

Would need to do some follow-the-link logic for those to see if a collection geometry is actually used by anything than other collections. A bit annoying, but seems straighfroward and centralized enough.

> How would the modifier access outgoing relation information? I would do it on the depsgraph issue, as the post-build pass to see if there are links coming from the `EVAL_DONE` node in the geometry component to other IDs. > How would that node work with implicit relations to other abstract 'final' nodes that are always created and thus don't mean anything in the context of the issue at hand? (are there any such relations?) I am not really sure what implicit relations those are. > There are some kind of geometry eval done nodes in collections Yeah, those would need some indirection check. The collection geometry is used to allow modifiers referencing collection as geometry. It was done for the boolean modifiers: https://archive.blender.org/developer/D11053 Would need to do some follow-the-link logic for those to see if a collection geometry is actually used by anything than other collections. A bit annoying, but seems straighfroward and centralized enough.
Bastien Montagne added the
Module
Core
Interest
Dependency Graph
labels 2024-07-01 17:55:00 +02:00
Bastien Montagne removed this from the Core project 2024-07-01 17:55:04 +02:00

Is this PR still relevant?
Removing from the Core workboard for the time being.

Is this PR still relevant? Removing from the Core workboard for the time being.
This pull request has changes conflicting with the target branch.
  • source/blender/blenkernel/BKE_subdiv_modifier.h
  • source/blender/blenkernel/intern/subdiv_modifier.cc
  • source/blender/depsgraph/DEG_depsgraph.h
  • source/blender/depsgraph/DEG_depsgraph_build.h
  • source/blender/depsgraph/intern/depsgraph_build.cc
  • source/blender/gpencil_modifiers/intern/MOD_gpencilshrinkwrap.c
  • source/blender/modifiers/intern/MOD_meshdeform.c
  • source/blender/modifiers/intern/MOD_shrinkwrap.c
  • source/blender/modifiers/intern/MOD_subsurf.cc

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u pr-depsgraph-subdiv-cpu:angavrilov-pr-depsgraph-subdiv-cpu
git checkout angavrilov-pr-depsgraph-subdiv-cpu
Sign in to join this conversation.
No Label
Interest
Alembic
Interest
Animation & Rigging
Interest
Asset System
Interest
Audio
Interest
Automated Testing
Interest
Blender Asset Bundle
Interest
BlendFile
Interest
Collada
Interest
Compatibility
Interest
Compositing
Interest
Core
Interest
Cycles
Interest
Dependency Graph
Interest
Development Management
Interest
EEVEE
Interest
EEVEE & Viewport
Interest
Freestyle
Interest
Geometry Nodes
Interest
Grease Pencil
Interest
ID Management
Interest
Images & Movies
Interest
Import Export
Interest
Line Art
Interest
Masking
Interest
Metal
Interest
Modeling
Interest
Modifiers
Interest
Motion Tracking
Interest
Nodes & Physics
Interest
OpenGL
Interest
Overlay
Interest
Overrides
Interest
Performance
Interest
Physics
Interest
Pipeline, Assets & IO
Interest
Platforms, Builds & Tests
Interest
Python API
Interest
Render & Cycles
Interest
Render Pipeline
Interest
Sculpt, Paint & Texture
Interest
Text Editor
Interest
Translations
Interest
Triaging
Interest
Undo
Interest
USD
Interest
User Interface
Interest
UV Editing
Interest
VFX & Video
Interest
Video Sequencer
Interest
Virtual Reality
Interest
Vulkan
Interest
Wayland
Interest
Workbench
Interest: X11
Legacy
Asset Browser Project
Legacy
Blender 2.8 Project
Legacy
Milestone 1: Basic, Local Asset Browser
Legacy
OpenGL Error
Meta
Good First Issue
Meta
Papercut
Meta
Retrospective
Meta
Security
Module
Animation & Rigging
Module
Core
Module
Development Management
Module
EEVEE & Viewport
Module
Grease Pencil
Module
Modeling
Module
Nodes & Physics
Module
Pipeline, Assets & IO
Module
Platforms, Builds & Tests
Module
Python API
Module
Render & Cycles
Module
Sculpt, Paint & Texture
Module
Triaging
Module
User Interface
Module
VFX & Video
Platform
FreeBSD
Platform
Linux
Platform
macOS
Platform
Windows
Priority
High
Priority
Low
Priority
Normal
Priority
Unbreak Now!
Status
Archived
Status
Confirmed
Status
Duplicate
Status
Needs Info from Developers
Status
Needs Information from User
Status
Needs Triage
Status
Resolved
Type
Bug
Type
Design
Type
Known Issue
Type
Patch
Type
Report
Type
To Do
No Milestone
No project
No Assignees
6 Participants
Notifications
Due Date
The due date is invalid or out of range. Please use the format 'yyyy-mm-dd'.

No due date set.

Dependencies

No dependencies set.

Reference: blender/blender#104461
No description provided.