MacOS Create and Debug Model

What do you need

• Download: latest binary files and source code
• Documentation:
  • MacOS Quick Start for Developers
  • (optional) MacOS: Create and Debug Models using Xcode

Prerequisites

• Tested on: MacOS 10.15 Catalina And Big Sur >= 11.1.
• Install Xcode and command line developer tools, if not installed already by Xcode: xcode-select --install.
• (optional) Install Visual Studio Code for cross-platform development: MacOS: Install VSCode
• Check if clang, make and sqlite3 are installed on your computer:

g++ --version
....
Apple clang version 11.0.0 (clang-1100.0.33.12)

make --version
....
GNU Make 3.81

sqlite3 --version
....
3.28.0 2019-04-15 14:49:49

• Download and unpack latest openM++ release using Safari or curl:

curl -L -o om.tar.gz https://github.com/openmpp/main/releases/download/v1.6.0/openmpp_mac_20200621.tar.gz
tar xzf om.tar.gz

MacOS security issue

Make sure you are using tight security settings on your Mac and antivirus software, if necessary. We are trying our best to keep development machines clean, but cannot provide any guarantee.

On Big Sur it is very likely to get an security error when you are trying to run any downloaded executable:

• please reply "Cancel" to that question (click "Cancel" button).
• remove quarantine attribute from openM++ installation directory, for example:

xattr -r -d com.apple.quarantine ~/openmpp_mac_20200621

Create new Model

• create new directory for your model under models sub-folder: models/MyModel Please note: It is recommended (not required) to have directory name exactly the same as model name.
• copy other test model makefile into your model folder, copy your model files and data files:

cd openmpp_mac_20200621/models/
mkdir MyModel
cd MyModel
cp ../NewCaseBased/makefile .
mkdir code
cp ~/my_model_sources/*mpp code
cp ~/my_model_sources/*.cpp code
cp ~/my_model_sources/*.h code
mkdir -p parameters/Default
cp ~/my_model_data/*dat parameters/Default

• build your model:

make all publish

• run the model:

cd ompp-mac/bin
./MyModelD
cd ..

• you can also build and run the model using make:

make all publish run

Create multiple input sets of parameters (multiple scenarios)

In example above we were creating only one "Default" scenario for our model from *.dat files in parameters/Default directory. It is also possible to create multiple input sets of parameters (multiple scenarios) when you are building the model:

make SCENARIO_NAME=Default,Other OMC_SCENARIO_PARAM_DIR=parameters/Default,parameters/SomeOther all publish

Above command will create two input sets of parameters:

• scenario "Default" from *.dat, *.odat, *.csv and *.tsv files in parameters/Default directory
• scenario "Other" from *.csv and *.tsv files in parameters/SomeOther directory

Please notice: additional scenario directory can contain only CSV or TSV files and not .dat or .odat files.

To find out more about CSV and TSV parameter files please read: How to use CSV or TSV files for input parameters values

Use AddressSanitizer to catch memory violation bugs

There is an excellent AddressSanitizer tool which allow to catch most of memory violation bugs. For example:

int x[10];
int main (int argc, char ** argv)
{
    x[20] = 20;  // error: global buffer overflow
    ........
}

It is not recommended to use AddressSanitizer in production, it slows down model code execution approximately by 70% and double memory usage. For that reason openM++ binary release does not enable AddressSanitizer by default and you will need to re-build openM++ run-time libraries to use it for your models testing.

To enable AddressSanitizer for your developement do:

• unpack openM++ release in separate folder, for example: ~/openmpp-asan. It is not recommended to use it in your main development folder
• re-build openM++ run-time library:

cd ~/openmpp-asan
rm -rf lib
rm -rf build

cd openm
make USE_ASAN=1 libopenm
make USE_ASAN=1 RELEASE=1 libopenm

• rebuild your model with AddressSanitizer, for example if your model name is RiskPaths you can build Debug and Release model versions by:

cd ~/ompp-main/models/RiskPaths
make clean-all
make USE_ASAN=1 all publish
make USE_ASAN=1 RELEASE=1 all publish

• and now you can run Debug or Release version of your model:

cd ompp-mac/bin
./RiskPathsD
./RiskPaths

Please notice, Debug version of the model executable is always significantly slower than Release. It is recommended to prepare smaller version of your test scenario to run it with Debug model. Or, maybe adjust some parameters from default scenario, for example:

cd ompp-mac/bin
./RiskPathsD -Parameter.SimulationCases 1234

How to use Visual Studio Code

Build openM++ models using VSCode

Prerequisites:

• install Visual Studio Code and configure it for openM++ model development: MacOS: Install VSCode
• follow steps described above to create new model

Note: In example below we are using RiskPaths demo model, please replace "RiskPaths" with your actual model name.

Start VSCode and use menu to File -> Open... -> ~/openmpp_mac_20200621/models/RiskPaths:

Configure build tasks by using menu: Terminal -> Configure Tasks...

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build-RiskPaths",
            "type": "shell",
            "command": "make all publish",
            "problemMatcher": "$gcc",
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "dependsOrder": "sequence",
            "dependsOn": [
                "build-libopenm",
                "stop-ui-RiskPaths"
            ]
        },
        {
            "label": "build-RiskPaths-release",
            "type": "shell",
            "command": "make RELEASE=1 all publish",
            "problemMatcher": "$gcc",
            "group": "build",
            "dependsOrder": "sequence",
            "dependsOn": [
                "build-libopenm-release",
                "stop-ui-RiskPaths"
            ]
        },
        {
            "label": "start-ui-RiskPaths",
            "type": "shell",
            "command": "../start-model-ui-mac.sh",
            "problemMatcher": []
        },
        {
            "label": "start-ui-RiskPaths-release",
            "type": "shell",
            "command": "RELEASE=1 start-model-ui-mac.sh",
            "problemMatcher": []
        },
        {
            "label": "stop-ui-RiskPaths",
            "type": "shell",
            "command": "../stop-model-ui-mac.sh",
            "problemMatcher": []
        },
        {
            "label": "clean-RiskPaths",
            "type": "shell",
            "command": "make clean-all && make RELEASE=1 clean-all",
            "group": "build",
            "problemMatcher": []
        },
        {
            "label": "build-libopenm",
            "type": "shell",
            "command": "make libopenm",
            "options": {
                "cwd": "../../openm"
            },
            "problemMatcher": "$gcc",
            "group": "build"
        },
        {
            "label": "build-libopenm-release",
            "type": "shell",
            "command": "make RELEASE=1 libopenm",
            "options": {
                "cwd": "../../openm"
            },
            "problemMatcher": "$gcc",
            "group": "build"
        }
    ]
}

You also can find file above at ~/openmpp_debian_20210304/models/RiskPaths/.vscode-mac/tasks.json

Note: Model default build task make all publish run does:

• create Debug version of model executable
• copy model SQLite database file into ompp-mac/bin "publish" folder

If you also want to run the model after successful build then use: make all publish run. If you want to build Release version of the model then use: make RELEASE=1 all publish.

To build and run your model please use menu: Terminal -> Run Build Task...

Debug openM++ model using VSCode

Create your model debug configuration by using menu Run -> Add Configuration...

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "debug RiskPaths",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/ompp-mac/bin/RiskPathsD",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}/ompp-mac/bin",
            "environment": [
              { "name": "OM_RiskPaths", "value": "${workspaceFolder}" }
            ],
            "externalConsole": false,
            "MIMode": "lldb"
        }
    ]
}

You also can find file above at ~/openmpp_debian_20210304/models/RiskPaths/.vscode-mac/launch.json

Start model debugging by using menu Run -> Start Debugging or as shown below:

Set breakpoint(s):

• open any model.ompp or *.mpp file and put breakpoint in it
• (optional) RunSimulation entry point using File -> Open File... -> use/case_based/case_based_common.ompp -> RunSimulation()
• (optional) main() entry point: File -> Open File... -> openm/libopenm/main.cpp

To inspect model parameters add Watch variable:

Start model UI on MacOS from VSCode

To start model UI from VSCode use menu: Terminal -> Run Tasks... -> start-ui-RiskPaths

To stop backgound oms web-service after you done with model UI use: Terminal -> Run Tasks... -> stop-ui-RiskPaths

View Doxygen comments on hover your Model code in Visual Studio Code

It is a convenient to see Doxygen comments in your model code when you hover:

If such functionality does not work for you then it maybe a result of missing include path in your c++ model settings. To fix it find a missing (red underscored) include, in example below it is #include "omc/omSimulation.h" and select Quick Fix -> Edit includePath settings:

It should open Microsoft C/C++ extension settings page. Add "${workspaceFolder}/../../include/**" to your Include Path list. It is also a good idea to set C++ standard as c++17:

That can be done by adding .vscode/c_cpp_properties.json to your model folder, but such JSON maybe specific to the particular version of VSCode:

{
    "configurations": [
        {
            "name": "Mac",
            "includePath": [
                "${workspaceFolder}/**",
                "${workspaceFolder}/../../include/**"
            ],
            "defines": [],
            "macFrameworkPath": [
                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
            ],
            "compilerPath": "/usr/bin/clang",
            "cStandard": "c17",
            "cppStandard": "c++17",
            "intelliSenseMode": "macos-clang-x64"
        }
    ],
    "version": 4
}

You also can find file above at ~/openmpp_debian_20210304/models/RiskPaths/.vscode-mac/c_cpp_properties.json

Model run options

As described at Linux Quick Start for Model Users you can run the model with different options. For example, you can calculate 8 sub-values (a.k.a. sub-samples, members, replicas), use 4 threads and simulate 8000 cases:

./RiskPathsD -OpenM.SubValues 8 -OpenM.Threads 4 -Parameter.SimulationCases 8000

You can supply run options as model command line arguments or by using model.ini file:

[OpenM]
SubValues = 8
Threads = 4

[Parameter]
SimulationCases=8000

./RiskPathsD -ini RiskPathsD.ini

There are two possible ways to use model ini-file with Visual Studio Code:

• by adding -ini RiskPaths.ini command line argument to model executable. Go to menu -> Run -> Open Configurations and edit launch.json at "program" line:

{
    // .... .... ....
    "program": "${workspaceFolder}/ompp-linux/bin/RiskPathsD -ini RiskPaths.ini",
    // .... .... ....
}

• by adding MODEL_INI=RiskPaths.ini command line argument to model make. Go to menu -> Terminal -> Configure Task -> build-RiskPaths and edit tasks.json at "command": "make .... line:

{
    "tasks": [
        {
            "label": "build-RiskPaths",
            "command": "make MODEL_INI=RiskPaths.ini all publish run",
        // .... .... ....
        }]
}

That MODEL_INI argument will be passed to model executable when make run the model as:

ompp-linux/bin/RiskPathsD -ini RiskPaths.ini