pml_analyzer
DocsAPI
Generated with
pml_analyzer/onera.pmlanalyzer.views.interference.model.specification/InterferenceSpecification

InterferenceSpecification

onera.pmlanalyzer.views.interference.model.specification.InterferenceSpecification
See theInterferenceSpecification companion object
trait InterferenceSpecification extends BasicInstances

Base trait for all interference specification

Attributes

Companion:
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Default
trait Default
Self type

Members list

Concise view

transform_operator

given given_Transform_Application_Set: given_Transform_Application_Set.type

Convert an application to the set of transaction id its trigger

Convert an application to the set of transaction id its trigger

Attributes

Inherited from:
BasicInstances
object given_Transform_Application_Set

Convert an application to the set of transaction id its trigger

Convert an application to the set of transaction id its trigger

Attributes

Inherited from:
BasicInstances
Graph
Supertypes
class Object
trait Matchable
class Any
given given_Transform_PhysicalTransactionId_Option: given_Transform_PhysicalTransactionId_Option.type

Convert a physical id to the corresponding path of services

Convert a physical id to the corresponding path of services

Attributes

Inherited from:
BasicInstances
object given_Transform_PhysicalTransactionId_Option

Convert a physical id to the corresponding path of services

Convert a physical id to the corresponding path of services

Attributes

Inherited from:
BasicInstances
Graph
Supertypes
class Object
trait Matchable
class Any

transaction_relation

final lazy val purifiedTransactions: Map[PhysicalTransactionId, PhysicalTransaction]

Map from the physical transaction id and their service sequence representation computed through an analysis of the platform WARNING: this lazy variable MUST NOT be called during platform object initialisation

Map from the physical transaction id and their service sequence representation computed through an analysis of the platform WARNING: this lazy variable MUST NOT be called during platform object initialisation

Attributes

final lazy val purifiedTransactionsName: Map[PhysicalTransaction, PhysicalTransactionId]

Map from the service sequence representation to their id WARNING: this lazy variable MUST NOT be called during platform object initialisation

Map from the service sequence representation to their id WARNING: this lazy variable MUST NOT be called during platform object initialisation

Attributes

scenario_relation

final lazy val purifiedScenarios: Map[PhysicalScenarioId, PhysicalScenario]

compute the considered scenarios depending on the configuration and the (optional) library, a scenario is either: a named and used transaction (e.g. val t = Transaction(a read b); t.used) a named and used scenario (e.g. val s = Scenario(t1, t2); s.used) an anonymous copy (e.g. a copy r on s) an anonymous transaction (e.g. a read b) not already involved in a copy, a named scenario or a named transaction WARNING this will discard an anonymous transaction defined inside and outside a copy, this issue does not occur if we keep the segregation Smart/NonSmart

compute the considered scenarios depending on the configuration and the (optional) library, a scenario is either: a named and used transaction (e.g. val t = Transaction(a read b); t.used) a named and used scenario (e.g. val s = Scenario(t1, t2); s.used) an anonymous copy (e.g. a copy r on s) an anonymous transaction (e.g. a read b) not already involved in a copy, a named scenario or a named transaction WARNING this will discard an anonymous transaction defined inside and outside a copy, this issue does not occur if we keep the segregation Smart/NonSmart

Attributes

Returns:

the set of scenarios

transparent_predicate

def isTransparentTransaction(t: PhysicalTransactionId): Boolean

Check whether a transaction is discarded during the analysis

Check whether a transaction is discarded during the analysis

Attributes

t

the identifier of the transaction

Returns:

true is the transaction is discarded

exclusive_predicate

final def finalExclusive(l: PhysicalTransactionId, r: PhysicalTransactionId): Boolean

Check whether two transaction will not occur simultaneously

Check whether two transaction will not occur simultaneously

Attributes

l

the left transaction

r

the right transaction

Returns:

true if they cannot occur simultaneously

final def finalExclusive(l: PhysicalScenarioId, r: PhysicalScenarioId): Boolean

Check whether two scenarios will not occur simultaneously

Check whether two scenarios will not occur simultaneously

Attributes

l

the left scenarios

r

the right scenarios

Returns:

true if they cannot occur simultaneously

final def finalExclusive(s: Set[PhysicalScenarioId]): Map[PhysicalScenarioId, Set[PhysicalScenarioId]]

Provide the map encoding of finalInterfereWith

Provide the map encoding of finalInterfereWith

Attributes

s

the set of scenario

Returns:

the map encoding

equivalence_predicate

final def equivalenceTransactionClasses(s: Set[PhysicalTransactionId]): Set[Set[PhysicalTransactionId]]

Provide the equivalence classes over s with views.interference.operators.Equivalent.Ops relation

Provide the equivalence classes over s with views.interference.operators.Equivalent.Ops relation

Attributes

s

the set of views.interference.model.specification.InterferenceSpecification.PhysicalTransactionId

Returns:

the equivalence classes

final def serviceEquivalenceClasses(s: Set[Service]): Set[Set[Service]]

Provide the equivalence classes over s with views.interference.operators.Equivalent.Ops relation

Provide the equivalence classes over s with views.interference.operators.Equivalent.Ops relation

Attributes

s

the set of pml.model.service.Service

Returns:

the equivalence classes

utilFun

final def channelNonEmpty(l: Set[PhysicalScenarioId], r: Set[PhysicalScenarioId]): Boolean

Check if it exists at least one common service used by two set of scenarios

Check if it exists at least one common service used by two set of scenarios

Attributes

l

the left set of scenarios

r

the right set of scenarios

Returns:

true whether one channel exists

final def channelNonEmpty(s: Set[Set[PhysicalScenarioId]]): Map[Set[PhysicalScenarioId], Set[Set[PhysicalScenarioId]]]

Provide the map encoding of channelNonEmpty

Provide the map encoding of channelNonEmpty

Attributes

s

the set of gathered scenarios

Returns:

the map encoding

final def purify(t: PhysicalTransactionId): PhysicalTransaction

Add the services of transactionInterfereWith to the path and remove the ones of transactionNotInterfereWith

Add the services of transactionInterfereWith to the path and remove the ones of transactionNotInterfereWith

Attributes

t

the identifier of the transaction

Returns:

the path of the transaction

interfere_predicate

final def finalInterfereWith(l: Hardware, r: Hardware): Boolean

Check whether two hardware cannot work simultaneously

Check whether two hardware cannot work simultaneously

Attributes

l

the left hardware

r

the right hardware

Returns:

true if they cannot work simultaneously

final def finalInterfereWith(l: Service, r: Service): Boolean

Check if two services interfere with each other

Check if two services interfere with each other

Attributes

l

the left service

r

the right service

Returns:

true if they interfere

def transactionInterfereWith(t: PhysicalTransactionId): Set[Service]

Provide the services a given transaction interfere with (additionally to the one identified in its path)

Provide the services a given transaction interfere with (additionally to the one identified in its path)

Attributes

t

the identifier of the transaction

Returns:

a set of services

def transactionNotInterfereWith(t: PhysicalTransactionId): Set[Service]

Provide the services a given transaction do not interfere with

Provide the services a given transaction do not interfere with

Attributes

t

the identifier of the transaction

Returns:

a set of services

Value members

Deprecated methods

final def channel(t: PhysicalTransactionId, in: Set[PhysicalTransactionId]): Set[Service]

Attributes

Deprecated
true
final def equivalentTransactionSets(s: Set[PhysicalTransactionId], in: Set[PhysicalTransactionId]): Set[Set[PhysicalTransactionId]]

Attributes

Deprecated
true
Generated with