Dependency Analysis Framework by davidwrighton · Pull Request #42 · dotnet/corert

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework

davidwrighton · 2015-10-08T20:37:27Z

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things.

This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be followon work.

Included in this change

DependencyAnalyzerBase
- Api surface for use of analyzer.
DependencyAnalyzer
- Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations.
- Specialized over a mark strategy. (The mark strategy specialization allows log customization)
DependencyNodeCore/DependencyNode
- Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents.
IDependencyAnalysisMarkStrategy
- Interface underlying mark logging customization.
- Provided mark strategies
- NoLogStrtegy, no support for logging.
  - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance.
- FirstMarkLogStrategy, the first edge to mark a node is logged
  - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node.
- FullGraphLogStrategy
  - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables
DgmlWriter
- Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio
Tests
- Basic unit test framework in place
- All types of dependency are tested to minimal standards
- DGML logging is tested.

davidwrighton · 2015-10-08T20:37:55Z

@MichalStrehovsky @jkotas , could the two of you take a look at this?

MichalStrehovsky · 2015-10-08T21:49:19Z

Nit: System.Reflection.Metadata is probably not needed for this.

Dependency analysis allows tracing what output components depend on other components from a root set instead of simply working with a list of already loaded things. This patch adds a framework for performing this computation, but no rules that are specific to compiling ILToNative. That will be follow on work. Included in this change - DependencyAnalyzerBase - Api surface for use of analyzer. - DependencyAnalyzer - Object that should actually be constructed to perform analysis. Not intended for most use, so as to allow dynamic switching between various particular specializations. - Specialized over a mark strategy. (The mark strategy specialization allows log customization) - DependencyNodeCore/DependencyNode - Base type of dependency node in depedency graph. Provides a set of facilities to describe dependents. - IDependencyAnalysisMarkStrategy - Interface underlying mark logging customization. - Provided mark strategies - NoLogStrategy, no support for logging. - Marks, but doesn't log anything. Most memory/performance efficient approach. Expected to be used in retail builds by default for best performance. - FirstMarkLogStrategy, the first edge to mark a node is logged - More memory efficient logging at mark points. In particular, only logs mark's that newly mark a node. - FullGraphLogStrategy - Used when the ability to generate a complete log of the graph is important. Fairly memory intensive due to the presence of a great many allocated hash tables - DgmlWriter - Interfaces with DependencyAnalyzer and various mark strategies to generate a DGML graph of the dependencies. DGML graphs can be viewed in Visual Studio - Tests - Basic unit test framework in place - All types of dependency are tested to minimal standards - DGML logging is tested.

MichalStrehovsky · 2015-10-13T19:04:37Z

LGTM

…rk_update Dependency Analysis Framework