Thanks for the replies all. Looks like direct instantiation is the
winner.
Andy, you mentioned strict order of compilation is required. Can you
elaborate?
Shannon
No, elaboration is different from compilation (analysis) ;^)
Oh, you want more information on order of compilation...
When you compile an architecture with component instantiations, only
the component definition needs to be previously compiled (either in a
package, or in the declarative region of the instantiating
architecture itself). Subsequently, only if the component later
changes does the instantiating architecture have to be recompiled.
When you compile an architecture with a direct entity and architecture
instantiation, both the architecture and its entity must already be
compiled (naturally, the entity before its architecture).
Subsequently, any change to the entity or architecture will force a
recompile on the instantiating architecture.
If the architecture is not indicated explicitly in an entity
instantiation, then only entity changes (which would likely have
caused the component to change also, had there been one) require the
instantiating architecture to be recompiled. But the entity must have
been compiled first before the instantiating architecture.
For most tools, this is not a big problem, since they tend to take
care of knowing when to compile what, once the design is compiled
correctly the first time. Some tools allow you to just throw a list of
files at them (in any order), and they will parse them and figure out
the correct order (you have to tell them the top level usually). They
can even correctly compile modules that occur out of order in the same
file.
Clear as mud?
Andy