This is a single value specifying a fixed metric. It is exactly
equivalent to
<derived><constant>x</constant></derived>, but much
shorter to type.
Base Type: xsd:double
This data type expresses a metric that can take on one of several
values, or a continuous range of values.
A continuous range is given
using the <min> and <max> elements to bound the (inclusive)
range of values the metric may take.
For a discrete set, one can either add the <by> element to a
continuous specification, which specifies an increment value. This
converts the continuous range into a discrete set of values formed by
starting at the minimum value and repeatedly adding the increment until
the value exceeds the maximum. This is analogous to a for loop.
Alternatively, you can list the discrete values each in a
<discrete> element.
- Choice between (choose 1):
- Sequence of:
- Element: <min>
- type: tns:MetricValue
- occurs: Once
- Element: <max>
- type: tns:MetricValue
- occurs: Once
- Element: <by>
- type: tns:MetricValue
- occurs: At most once (optional)
- Sequence of:
- Element: <discrete>
- type: tns:MetricValue
- occurs: One or more times
The set of valid names for metrics used when referencing one metric
freom a derived metric.
Base Type: xsd:string
Restricted to:
"power"
"capacity"
"rate"
"latency"
This is a term in an arithmetic constraint of a resource metric. It's
an encoding of a simple linear forumla into a data structure. Each
choice of term value is documented below. Expressions are evaluated
from the inside out so:
<sum> <product> <term><constant>2</constant></term> <term><constant>3</constant></term> </product> <term><constant>1</constant></term> </sum>is a verbose way to say 7.
Each choice for a MetricTerm is described below.
- Choice between (choose 1):
- Element: <constant>
A simple constant value.
- type: tns:MetricValue
- occurs: Once
- Element: <metric>
Substitution for the value of another metric in this resource description. The "resource" attribute is the ID attribute of the referenced resource and the "metric" attribute identifies the specific metric (power, capacity, latency, etc.) to use. Constraints must be resolvable, though it is difficult to specify data structure constraints that allow complexity but avoid possible circular definitions.
- occurs: Once
- content follows
- attribute: resource
- type: xsd:string
- required
- attribute: metric
- type: tns:MetricName
- required
- Element: <sum>
A sum of constraint terms.
- occurs: Once
- content follows
- Sequence of:
- Element: <term>
- type: tns:MetricTerm
- occurs: At least 2 times
- Element: <product>
A product of constraint terms.
- occurs: Once
- content follows
- Sequence of:
- Element: <term>
- type: tns:MetricTerm
- occurs: At least 2 times
- Element: <difference>
The difference between constraint terms. Note that differences are pariwise.
- occurs: Once
- content follows
- Sequence of:
- Element: <term>
- type: tns:MetricTerm
- occurs: Between 2 and 2 times
- Element: <quotient>
The quotient of constraint terms. Note that division is pariwise.
- occurs: Once
- content follows
- Sequence of:
- Element: <term>
- type: tns:MetricTerm
- occurs: Between 2 and 2 times
This is the data type for resource metrics. All resources are
characterized by one or more metrics with units attached to them. In
the simplest form this value is just a real number that describes the
amount of the resource. The type can also express ranges of available
values (continuous or discrete) and arithmetic constraints.
An example of two components that are arithmetically constrained is a
storage resource (ID="disk") and communication resource (id=Net) that
share a 300Mb/s bus. The storage resource could have a rate="1 to 300"
(rateUnits="Mbs") and the communication resource a capacity of (300 -
disk:rate) (units="Mbs"). This would be expressed as:
<storage id="disk"> <capacity units="MB"><value>300</value></capacity> <rate> <range><min>1</min><max>300</max></range> </rate> </storage> <communication> <capacity> <derived> <difference> <term><constant>300</constant></term> <term><metric resource="disk" metric="rate"/></term> </difference> </derived> </capacity> </communication>
Each resource subclasses this datatype to constrain the acceptable
units for the reources, but all use the language for expressing
constraints.
- Choice between (choose 1):
- Element: <value>
- type: tns:MetricValue
- occurs: Once
- Element: <range>
- type: tns:MetricRange
- occurs: Once
- Element: <derived>
- type: tns:MetricTerm
- occurs: Once
For processing resources that do not have full programmability, this
data type describes their capabilities in the terms we discussed on
list. I'll document those more fully later.
Base Type: xsd:string
Restricted to:
"Full"
"Modify"
"Generate"
"Classify"
These are the units of processing power. These are a little vague
right now and are strawmen for what will eventually characterize
processing power.
Base Type: xsd:string
Restricted to:
"IntegerMultiplyPerSecond"
"FLOPS"
"FrameDecodesSecond"
This is the data type for describing a processing resource. Each
allocable processing resource will be described by a separate
occurrance of this data type, each uniquely identified by an ID
attribute.
The processor's capacity is expressed in the "power" attribute in units
given in the "units" attribute. "Power" is a metric data type, so it
can be constrained as described in that data type's description. If
the "function" element is present, it describes the processors
capabilities.
- Sequence of:
- Element: <power>
- occurs: Once
- content follows
- attribute: units
- type: tns:ProcessingUnits
- optional (default: "IntegerMultiplyPerSecond")
- Element: <function>
- type: tns:ProcessorFunction
- occurs: At most once (optional)
Base Type: tns:Metric
Extended by:
- attribute: ID
- type: xsd:string
- required
Several components describe their capacity in terms of data rates.
This base type sets values for a few application independent rates that
other types can use.
Base Type: xsd:string
Restricted to:
"Kbs"
"Mbs"
"Gbs"
These are the units a communication resource can describe its capacity
in. In addition to the generic data rates in the base class, rates can
be given in terms of the units addded here.
I'm not sure how to actually use a sub-classing here, so the DataRates
terms are copied.
Base Type: xsd:string
Restricted to:
"Kbs"
"Mbs"
"Gbs"
"MessagesPerSecond"
These are values that a communication resource can use to describe its
interaction with other communication resources, or to specify that no
such interaction exists. The various shared values correspond to time,
space, and frequency division multiplexing while "exclusive" implies
that the communication is unaffected by other communicators. Again,
straw men.
Base Type: xsd:string
Restricted to:
"TimeShared"
"FreqShared"
"SpaceShared"
"Exclusive"
A data type used to characterize the underlying communication model in
very broad terms. Placeholder, of course.
Base Type: xsd:string
Restricted to:
"Connectionless"
"ConnectionOriented"
The communication resource data type. Like processing, it describes
its capacity in the "capacity" attribute expressed in the units in the
"units" attribute. "Units" default to Mbs, and can be omitted. The ID
must be unique. Again, "capacity" is a metric and can be constrained.
If the "medium" element is present, it characterizes the interaction of
the communication resource with other resources. If the "model"
element is present, it charcaterizes the model. Both elements are
optional, but can only occur once.
- Sequence of:
- Element: <capacity>
- occurs: Once
- content follows
- attribute: units
- type: tns:CommunicationUnits
- optional (default: "Mbs")
- Element: <medium>
- type: tns:CommunicationMedium
- occurs: At most once (optional)
- Element: <model>
- type: tns:CommunicationModel
- occurs: At most once (optional)
Base Type: tns:Metric
Extended by:
- attribute: ID
- type: xsd:string
- required
Another extension of the DataRates type to specialize for measurement.
Measurement devices may characterize their output in terms of events.
I'm not sure how to actually use a sub-classing here, so the DataRates
terms are copied.
Base Type: xsd:string
Restricted to:
"Kbs"
"Mbs"
"Gbs"
"EventsPerSecond"
A simple attempt to characterize the sort of measurement a mesaurement
resource may be up to. Obviously a straw man.
Base Type: xsd:string
Restricted to:
"Sensor"
"GENIMonitor"
"SNMPAgent"
A measurement resoucre description. Of a set of sketches, this is the
sketchiest. The resource is characterized in terms of its measurement
capacity in the "capacity" attribute (which is again a constrainable
Metric datatype) in the uints in the "units" attribute. The type of
measurement accomplished is given in the "type" attribute, expressed in
the broad terms of the MeasurementType datatype.
- Sequence of:
- Element: <capacity>
- occurs: Once
- content follows
- attribute: units
- type: tns:MeasurementUnits
- optional (default: "EventsPerSecond")
Base Type: tns:Metric
Extended by:
- attribute: ID
- type: xsd:string
- required
- attribute: type
- type: tns:MeasurementType
- optional
Storage capacity units. All of these are in bytes.
Base Type: xsd:string
Restricted to:
"KB"
"MB"
"GB"
"TB"
"PB"
Units used to describe the latency of the storage resource. Time
units.
Base Type: xsd:string
Restricted to:
"sec"
"msec"
"usec"
"nsec"
Some storage can be removed from components and transported other
places for post mortem analysis or other use. This datatype is used to
indicate if the resource in question is removable or not.
Base Type: xsd:string
Restricted to:
"persistent"
"transient"
How can users of the storage resource use it. The standard choices are
varients of reading and writing. Are there more?
Base Type: xsd:string
Restricted to:
"R/O"
"R/W"
"W/O"
Sorage resources may characterize themselves across three axes -
capacity, data rate, and atency. Each axis has a metric in an
attribute of the obvous name, but only capacity is a required
characterization. Each axis is a constrainable metric and has its own
associated attribute for the units of that metric.
In addition, optional elements specifying the type of permissable axis
(the "access" element) and the persistence of the storage (the
"persistence" element) may appear. Both are optional.
- Sequence of:
- Element: <capacity>
- occurs: Once
- content follows
- attribute: units
- type: tns:CapacityUnits
- optional (default: "MB")
- Element: <latency>
- occurs: At most once (optional)
- content follows
- attribute: units
- type: tns:LatencyUnits
- optional (default: "msec")
- Element: <rate>
- occurs: Once
- content follows
- attribute: units
- type: tns:DataRates
- optional (default: "Mbs")
- Element: <access>
- type: tns:StorageAccess
- occurs: At most once (optional)
- Element: <persistence>
- type: tns:StoragePersistence
- occurs: At most once (optional)
Base Type: tns:Metric
Extended by:
Base Type: tns:Metric
Extended by:
Base Type: tns:Metric
Extended by:
- attribute: ID
- type: xsd:string
- required
This data type describes a components resources - or one configuration
of a set of possible constained configurations. Elements with types of
the "Processing," "Communication," "Measurement," and "Stroage" defines
above may appear more than once , with the collection defining the
component resources. As described under the "Metric" data type, these
resources may constrain their capacities in terms of each other's
capacities.
Any ResourceGroup can be assigned an identifier using teh ID attribute
to simplify references to that ResourceGroup.
- Sequence of:
- Element: <processing>
- type: tns:Processing
- occurs: Zero or more times
- Element: <communication>
- type: tns:Communication
- occurs: Zero or more times
- Element: <measurement>
- type: tns:Measurement
- occurs: Zero or more times
- Element: <storage>
- type: tns:Storage
- occurs: Zero or more times
- attribute: ID
- type: xsd:string
- optional
This is a part of the constraint system that presents choices
between complete configurations. The name is somewhat confusing.
This data type describes a set of possible configuration choices,
each surrounded by an <and> ... </and> pair. The set
of <and>s is then put in an <or> to indicate that any
one of the choices contained in an <and> ... </and>
pair is possible, but only one choice from the enclosing
<or> ... </or> is acceptable.
For example:
<or> <and> <processing> <power><value>10</value></power> </processing> <storage> <capacity><value>10</value></capacity> </storage> </and> <and> <measurement> <capacity units="EventsPerSecond"><value>100</value></capacity> </measurement> </and> </or>describes a component that can either be a 10 Mhz CPU with a 10 MB disk or a 100 event/s sensor, but no other mix of configuration is possible.
This allows one to specify that a node can support one of several
mutually exclusive configurations (which can be internally
constrained using Metric constraints).
Each <and> block may have an identifier and a weight
attribute that can be used in describing choices and expressing
preferences. <and> groups with higher weight values are
preferable to the entity describing the resources. The type of
the <and> group extends the ResourceGroup type to provide
this attribute. All ResourceGroups can have an identifier.
N.B. A single available configuration is expressed as an <or>
group with a single <and> group inside.
- Sequence of:
- Element: <or>
- occurs: Once
- content follows
- Sequence of:
- Element: <and>
- occurs: One or more times
- content follows
- attribute: weight
- type: xsd:double
- optional
Base Type: tns:ResourceGroup
Extended by: