onera.pmlanalyzer.pml.examples.simpleKeystone

Program entry point to export several version of Keystone

Transaction that are always used. A user transaction is considered during the analyses if identified as so. For instance to indicate that the t11 transaction defined in SimpleKeystoneTransactionLibrary is used

t11_app1_rd_interrupt1.used

All transaction are used

Transactions used when the L1 is not used

Transaction used when app4, app1 and app21 are scheduled

Transaction used when app22, app1 and app3 are scheduled

Simple model of the Keystone platform illustrating the main features of PML. The components of the architectures can be created using the constructors provided in pml.model.hardware.BaseHardwareNodeBuilder For instance the SimpleKeystonePlatform.dma is built with:

val dma: Initiator = Initiator()

An axi-bus is built with:

val axi-bus: SimpleTransporter= SimpleTransporter()

A peripheral or a memory is built with

val sram: Target = Target()

Some components may be composite, if you want to define one instance of composite you can use the object instantiation pattern used for the TeraNet

object TeraNet extends Composite 

You can also define a type of Composite that may be instantiated afterward, for instance here ARMCores are defined as a composition of a core (initiator) and a cache (transporter). A name is given as a parameter of the ARMCore class

class ARMCore (name:Symbol) extends Composite 

Then components can be linked together, this operation simply connect the service of the same type provided by the two components. For instance

ARM0.core link axi_bus

links the pml.model.service.Load and pml.model.service.Store service of the ARM0.core to the ones of the axi-bus Beware that all links are not possible, for instance you cannot link two pml.model.hardware.Target or a pml.model.hardware.Composite to another component.

This trait contains a library of all transactions that can occur on the platform One way to define a pml.model.configuration.TransactionLibrary.Transaction or a pml.model.configuration.TransactionLibrary.Scenario is to use the read/write operators specifying which pml.model.software.Data is used by which pml.model.software.Application. For instance

val app4_wr_input_d : Transaction = Transaction(app4 write input_d)

defines a read transaction called '''app4_wr_input_d''' between the initiator of app4 and the input_d data. The location of the application and the data are provided in the SimpleSoftwareAllocation trait.

If you want to define several paths representing a multi-transaction use the pml.model.configuration.TransactionLibrary.Scenario For instance

val app1_rd_wr_L1 : Scenario = Scenario(app1_rd_L1, app1_wr_L1)

defines a scenario named '''app1_rd_wr_L1''' where app1 is reading and writing L1 cache

Routing constraints considered for simple Keystone

Definition and allocation of software and data to hardware for simple Keystone. Declaring the application app1

val app1: Application = Application()

Allocating app1 on pml.examples.simpleKeystone.SimpleKeystonePlatform.ARM0

app1 hostedBy ARM0.core

Declaring the data input_d

val input_d: Data = Data()

Allocating app1 on pml.examples.simpleKeystone.SimpleKeystonePlatform.MemorySubsystem.sram

input_d hostedBy MemorySubsystem.sram