Getting started with Fast Models and RTX (1/2)

Arm Fast Models are fast, flexible programmer's view models of Arm IP. Fast Models are used to build virtual prototypes for software development which are useful during all phases of a project. System models can start very small and grow into comprehensive models of hardware. Fast Models are also a great way to learn the details of software development for the Arm architecture.

Ease of use and flexibility make Fast Models an important tool for software developers. Virtual prototype creators construct system models and provide them to software developers to enable early software development.

Fast Models (FM) is a versatile product with large set of IP models and features to choose for a seasoned software developer. With an ever-growing IP catalog and feature set, it becomes overwhelming for a new software developer to get started. This blog post series aims to provide easy to replicate tutorials to start using Fast Models in your software development projects.

RTX is a royalty-free, deterministic Real-Time Operating System designed for Arm and Cortex-M devices. It provides easy to use API to perform multiple functions simultaneously and helps create applications which are better structured and easily maintained. Read here for more on RTX.

In these posts we concentrate on the following:

1. Creating and Building a simple Cortex-M33-based custom SystemC platform using System Canvas (SGCanvas)
2. Then Writing, Compiling, and Executing an RTX app on the custom Cortex-M33 platform created in this post.

In this post, we concentrate on step 1:

Creating a simple Cortex-M33 based platform using System Canvas (SGCanvas)

• To install Fast Models, check out the guide at Installation Guide
• To set up your environment go to FastModelsPortfolio_11.9 folder and source etc/setup_all.csh.
• Sourcing setup_all.csh sets up the following environment variables:
  • PVLIB_HOME - Path to the Fast Models portfolio installation base directory.
  • MAXCORE_HOME - Path to the Fast Models Tools installation base directory.
  • SYSTEMC_HOME - Path to Accellera SystemC library included with Fast Models product
  • IRIS_HOME - Path to Iris-related library and include files. Iris provides an interface for external tools like debuggers to control the simulation run within Fast Models.
  • PYTHONPATH - Python Iris module and command-line debug tool.
  • Expected output from sourcing the script is visible in the following snapshot.

• To get detailed instructions on starting up with Fast Models refer to the Fast Models quick start guide here.

This sets up the required environment variables for FM product to find the IP library at PVLIB_HOME and tools like SGCanvas at MAXCORE_HOME.

• Once your environment is set up correctly then start "sgcanvas" from the prompt.
  
  
• This starts the following screen:
  
  
• Click on File menu and start a New Project
  
  
• This prompts for your TopComponent name. Select a new directory to start your project and enter a name like "MyTopComponent" in the File name option
  
  
• Press "Select" to continue. This opens Creating project dialog box and prompts you to enter the top component file name. You can leave the name as suggested and press "Select" again.
  
  
• This takes you to next screen where you get a generated top level component in LISA.
  
  
• You can switch to "Block Diagram" view.
  
  
• We need the following components for our basic Cortex-M33 platform:
  • MasterClock
    This component generates the primary clock that drives the complete platform. By default, clock generated by MasterClock is 1 Hz frequency.
    
  • ClockDivider
    This component scales the input clock frequency to a higher or lower output clock frequency based on either "mul" or "div" parameters.
    
  • ARMCortexM33CT
    This is the primary Cortex-M33 Core component. It is the model of Cortex-M33 Core that is capable to executing instructions.
    
  • PVBusDecoder
    PVBusDecoder routes incoming bus transactions to different outgoing master ports connected to different slaves.
    
  • RAMDevice
    RAMDevice is the memory model. It acts as a dynamic or static RAM in our platform.
    
    
  Select all these components from the "Components" list at the right of the screen and place these on the Block Diagram window. To place any component, select it in the Components list and drag-drop it into the "Block Diagram" window.
  
  
• Once you have all the components on the "Block Diagram" window, it is time to connect the appropriate ports. Let us begin with connecting MasterClock's clk_out port to ClockDivider's clk_in port. Select "Connect" from the top ribbon menu and then click on MasterClock's clk_out and next click on ClockDivider's clk_in port.
  
  
• Next step is to connect ClockDivider's clk_out port to ARMCortexM33CT's clk_in port.
  
  
• Connect ARMCortexCM33CT's pvbus_m port to PVBusDecoder's pvbus_s port.
  
  
• Connect PVBusDecoder's pvbus_m_range to RAMDevice's pvbus port.
  
  
• Go back to "Edit" mode using the "Edit" button in the ribbon menu.
  Select ClockDivider and click the "Properties" in the ribbon menu then set the parameter "mul" to set up scaling factor for the output clock frequency. Set value of "mul" to 50.
  In a real platform, you would set the value of "mul" or "div" based on your SoC's specification. In terms of Fast Models, low value of output clock frequency could lead to sluggish speed of your platform.
  
  
• Select PVBusDecoder's pvbus_m_range to set the address range the input address range mapped to RAMDevice's pvbus port
  
  
• Press "Edit Connection" and then tick "Enable address mapping" to change the address range
  
  
• Change the "End" address to 0x20ffffff and click Ok.
  
  
• Select RAMDevice and click on Properties button on the ribbon menu to change the size of the memory.
  
  
• Change the size from 4GB (0x100000000) to 64 GB (0x1000000000). Then press Ok.
  
  
  This completes the platform creation steps.  Press "Save All" to save the platform and its connections.

Building the Platform

Follow the steps:

• From the projects menu select project settings (Projects→Project Settings). This opens the following dialog.
  
  
• Select the Configuration from the drop down list that you want to build for (e.g Linux64-Release-GCC-6.4)
  
  
• In the Targets window, de-select "CADI library" and select "SystemC integrated simulator".
  
  
• Press "Apply" and then press "Ok" to close the dialog box.
  
  
• From the Ribbon menu "Select Active Project Configuration" select Linux64-Release-GCC-6.4 from the drop-down. Then press "Build" button from the Ribbon menu. This prompts you to save the modified build configuration and on pressing "Ok", it begins the platform generation and build. Finally, it prints "Model build process completed successfully" in the "Log" window.
  
  

This completes the platform generation and build process. If you go to your working directory you can see that the platform binary is generated as "isim_system". This platform binary can now be used to run your Cortex-M33 targeted software on this platform.

$ ls -l
total 304
drwxr-x--- 3 navkha01 navkha01   4096 Jan  8 10:19 Linux64-Release-GCC-6.4
-rw-r----- 1 navkha01 navkha01    804 Jan  8 10:19 MyTopComponent.lisa
-rw-r----- 1 navkha01 navkha01 294805 Jan  8 10:19 MyTopComponent.sgcanvas
-rw-r----- 1 navkha01 navkha01   7166 Jan  8 10:16 MyTopComponent.sgproj

To discuss fast models and other simulation models that Arm provides, head over to our

Models Discussion Forum