This paper is pretty clear and self-contained.  It introduces a
framework to construct machine descriptions.  It employs a two-tier
model, which is comprised of easy-to-understand and easy-to-maintain
high-level language description and the equivalent efficient-to-use
low-level representations.  The paper also discussed a set of
transformations to bridge the gap between the two levels of
representations and obtain efficient low-level representation from its
high-level counterpart.  The transformations include use OR-trees and
AND/OR-trees instead of reservation tables to represent execution
constraints, eliminating redundant information in OR-trees and
AND/OR-trees, using bit-vectors to represent resource usages in the
same cycle, putting resource usages in different cycles into
bit-vectors and optimizing AND/OR-trees for early conflict detection.

There's one case that the paper doesn't model and isn't supported by
any current compilers, which is the modeling for multimedia
architecture extensions and compiling for them.  Traditional compiling
breaks programs into basic operations, then optimizes and schedules
these basic operations.  Compiling for multimedia extensions(or
microSIMD extension, largely) is like aggregating a group of basic
operations into a larger composite operation, which is not well
modeled.  The descriptions of these multimedia extensions don't fall
nicely into the framework this paper introduces.  In order to schedule
microSIMD operations, we may need to do some code transformations
before scheduling to combine data pieces.  But we can't do these
transformations until we know the target machine supports microSIMD
operations.  It seems that we need to go back to high-level optimizer
from scheduler or level-optimizer in order to compiler for multimedia
extensions from machine independent code.  It appears to be a very
hard thing to do and no compiler support compiling machine independent
code to use machine dependent multimedia extensions.  Multimedia
instructions are not even in machine descriptions.  Instead, if people
want to use them, they have to use machine specific macros(which is
equivalent to assembly code), and the compiler has to be machine
specific too.  It is awkward that for such broadly used architecture
extensions, there is little compiler support and programmers have to
know the machine dependent details.

It would be interesting to extend the machine description framework
introduced in this paper to include multimedia architecture extensions
and to extend compiler structure to effectively compile for these
extensions based on information in the machine descriptions.