Pathfinder Solutions

PathTECH Login

Making Systems Development Successful

PathMATE FAQs

If you have any questions about PathMATE installation or use, we hope that you will find answers here. Below are some questions that our customers have asked us over the years.

Frequently Asked Question Categories

Installation

How do I see if I had problems installing PathMATE to work with RSM/RSD/RSA?

The installation manager creates a c:\pathmate\cm\cm.log that can have some useful information in it. It is a good idea to look at this file. Also, the checksite batch file creates a file called c:\pathmate\cm\.details. Opening this file will often point to another log file in the Eclipse installation.

How does a PathMATE license connect to an RSD license? Is it restricted to a certain RSD license? e.g. If you have a floating RSD license how does a PathMATE license handle this?

PathMATE and RSD are licensed separately and are totally independent. You can have any combination of floating and node locked licenses for PathMATE and RSD. The only restriction is that when you are using PathMATE you must have one license for each product. If you purchase a node locked license for PathMATE and have a floating license for RSD, you may use RSD without PathMATE on any computer on the network. If you want to edit PathMATE models with RSD, they will only be able to do this on the computer where the node locked PathMATE license is installed.

I tried updating the license server using the FlexLM Admin tool of PathMATE, but it didn’t work. What should I do?

Occasionally the FlexLm tool does not save the setting properly, and you will need to edit the registry. Change the value of the following registry key using regedit:HKEY_LOCAL_MACHINE\SOFTWARE\FLEXlm License Manager\PATHFNDR_LICENSE_FILE

What Version of JRE do you need to use for Eclipse and PathMATE to work properly?

You must have JRE 1.6 or higher installed to use the version of Eclipse installed with PathMATE.Merely adding Java to the Path environment variable doesn’t help on Windows. Eclipse uses a DLL to startup the JVM so the DLL must be registered. If you have to uninstall and reinstall PathMATE, be sure to run the uninstall program. Delete everything in the c:\pathmate directory with the exception of the lic and design directories. Next reinstall PathMATE.

How do I install PathMATE manually to RSA/RSM/RSD?

Try using the Manage Configuration menu option to install PathMATE.

  • 1. From the main menu select Help > Software Updates > Manage Configuration. The Product Configuration window appears.
  • 2. In the tree control on the left of the Product Configuration window, select Rational Software Architect. Right click and select Add > Extension Location. The Browse for Folder dialog appears.
  • 3. Select c:\pathmate\eclipse. Click Ok. This should manually add the PathMATE plugins to RSA/RSM/RSD.

Alternatively you can locate the installed.xml file and copy it to C:\Documents and Settings\All Users\Application Data\IBM\Installation Manager. Then run the PathMATE installation tool by selecting All Programs > Pathfinder Solutions > Installation Manager. If you are still having difficulty, try the following:

  • 1. Login as Administrator.
  • 2. Select Start > Run.
  • 3. The Run dialog appears. Enter regedit in the Open field. Click Ok.
  • 4. The Registry Editor window appears. From the browser on the left hand side of the Registry Editor window, select My Computer > HKEY_LOCAL_MACHINE > SOFTWARE > FLEXlm License Manager.
  • 5. Double click on PATHFNDR_LICENSE_FILE on the right hand side of the Registry Editor window.
  • 6. The Edit String dialog appears. Enter the directory containing the license file. Click Ok.
  • 7. If using a floating license, restart the license server. Restart the UML editor or Spotlight. The new license location should now be recognized.

General PathMATE

If we have a PathMATE use-case where we want to do a multi-process, what is the best way to do so?

You can do a multi-process with an Ant script. It would look something like this:

  • <?xml version=”1.0″?> ><project name=”DoTwoTransforms” default=”main” basedir=”.”>
  • <target name=”main”>
  • <pathmate.transform project=”SimpleOven/SimpleOven.pathmate” deployment=”Single Process C++”/>
  • <pathmate.transform project=”SimpleOven/SimpelOven.pathmate” Deployment=”Single Process Java”/>
  • </target>
  • </project>

There is an ant view in Eclipse that makes it easy to run ant scripts. Do a Window > Show View > Other > Ant > Ant. Drag the ant script over to the view. Right Click and do a Run > Run As > Ant Build. If you are using Rational Software Modeler, be sure to run the ant script in the same VM as eclipse by selecting Run > Run As > Ant Build… On the JRE tab, click the Run in the same JRE as the workspace radio button.

How does the code design synchronization work? How is it intended to use PathMATE in this connection?

PathMATE generates fully executable code. There is no need to modify the code after it has been generated. To make changes, modify the model and press the transform button. No synchronization is necessary. Another important distinction in our generated code is its Self Optimization. Building on the semantic awareness that comes from platform-independent action language, PathMATE generates Self Optimized code that has been measured at one-third the size of code produced from a leading code-in-the-model tool, and seven times faster for critical performance tests.

Does PathMATE support dynamic comment construction based on data stored in the model? For example, a class implements a Safety Critical requirement. The headers for the files created for that class must specify that it is safety critical, and all operations that implement that safety critical requirements would also need to have it specified in their headers.

To customize code generation templates, make copies of the templates that you want to modify in a separate directory. Modify the templates and then create a new platform model that includes the custom templates first followed by the default PathMATE templates. Use the new custom platform model for the transformation. For example, add a marking of SafetyCritical with values T (for true) or F (for false). The default is F or non-safety critical. Add markings to the properties.txt file:

  • Object,..,SafetyCritical,T

Then in the templates print out the appropriate header. For example, in c:\pathmate\design\java\templates\obj_svc.arc, to print out the safety critical marking after the description:

  • /**
  • * [svc.description]
  • * Safety Critical: [IF (PROPERTY(svc, "SafetyCritical", "F") == "T")]Yes[ELSE]No[ENDIF] */

This will print out the following text if the operation is safety critical:

  • /**
  • *
  • * Safety Critical: Yes
  • */

Or the following if the operation is not safety critical:

  • /**
  • *
  • * Safety Critical: No
  • */

The Safety Critical header for the class could be derived from the operations or it could be another marking. For example:

  • [ARCHETYPE class_is_safety_critical(Object obj; Boolean is_safety_critical)]
  • [/* if any of the operations in the class are safety critical, */]
  • [/* the whole class is safety critical. */] [ASSIGN is_safety_critical = FALSE] [FOREACH svc IN obj.services]
  • [IF (PROPERTY(svc, "SafetyCritical", "F") == "T")]
  • [ASSIGN is_safety_critical = TRUE]
  • [BREAK]
  • [ENDIF]
  • [ENDFOREACH]

Is there a distinction between “Can’t Happen” and “Event Ignored” on state transition tables generated by PathMATE?

Can’t happen, event ignored, and event deferred are the three options for an event when there is no transition out of a state. Can’t happen (the default) means that the event should never be received while the class is in that state. If an event is received while in this state, an error is reported and the event is ignored. Event ignored means that the class could receive the event while in the state, but, if it does, the event should be ignored. Event deferred means that the class is not ready to receive the event. The event will be put back on the queue until the class reaches a state where the event is not deferred. To specify an event is ignored in a state:

  • 1. Select the state and open the properties view.
  • 2. Select the Advanced tab. Enter the qualified name of each ignored event (:) in the PathMATE > IgnoredEvents property.

If you want the events to show as ignored by default, the easiest thing to do is to modify the report template to print out ignored for both can’t happen and ignored.

Does PathMATE provide any help for the merging of Action Language similar to what RSM/Eclipse/ClearCase provides for model files?

PathMATE supports comparing and merging of action language from different versions of a model file. To use this feature, ensure that you have all of the versions of the model available in your workspace. For two-way merges, you will need your version of the model as well as the version you are comparing to your model. For three-way merges, you will also need a common ancestor base version available. Right click on your model file (.emx file) and select Compare With > PathMATE Action Language… to activate the compare/merge wizard.

I’ve come across a problem where I’m using a PfdIncident handle from realized code to make consecutive updates. The first call doesn’t always work, but the second does. When I put a 2 second sleep in between, they both always work. Why?

What’s happening is you are actually delivering the same instance of the Incident twice. If you are going to make repeated calls to the same incident then you need to make a copy of the actual PfdIncident itself. You can use the duplicate() method. See /pathmate/design/cpp/mechanisms/incident.hpp.

How do I reference a constant defined in an implementation code file in a platform independent model?

All model constants are defined as CONST variables. If the constant is required by all domains in the system, open the system initialization action language. If the constant is required by a single domain, open the domain initialization action language.  Constant declaration syntax follows CONST <type> <variable name> = <value>; .  For example:

CONST Integer SYS_MAX_INITIALIZATION_DURATION_MS = 1500;

The keyword EXTERN indicates the constant variable is instantiated outside the model: EXTERN CONST <type> <variable name>; . For example:

EXTERN CONST Integer SYS_MAX_INITIALIZATION_DURATION_MS ;

To indicate where the constant is included from, specify the IncludeFile property of the constant in the action language using the IncludeFile marking.  For example:

EXTERN CONST ; { IncludeFile = “include_file_name.hpp” }

Specifying the IncludeFile property will generate an include for the specified file wherever the constant is used.

Editor Integration

Does PathMATE support the use of parameterized (template) classes in RSM?

When using custom PathMATE templates, a generated implementation might make use of parameterized classes such as the vector class in the C++ Standard Template Library. The vector could be used in place of the PfdBaseList when implementing the many sides of an association.

I am using RSD V 7.05 and PathMATE V7.0.0. If I follow the QuickStart example, on page 10 it states that I can select from e.g. PathMATE System model, but the options I get do not include any PathMATE projects.

The template files for domain and system models do not work properly with version 7.0.5. Please replace the existing files with the attached template files in theC:\pathmate\eclipse\plugins\com.pathfinder.editorIntegration.rsa.profile_7.0.0\templates directory. Then restart Rational Software Modeler. The templates should then appear in the New wizard.

If you have a project you want to design and implement in RSD with PathMATE, and you have some *.c and *.h -files you have bought elsewhere, how do you incorporate the existing code you want to use into a PathMATE project? For example, this could be some RTOS (Real Time > Operating System) code already written in C.

Existing code can be incorporated in several ways. If you need to access the capabilities of the realized code in the models, create a realized domain to encapsulate this code. If you completed the SimpleOven example, the ExternalDeviceControl domain is an example of a realized domain.

  • 1. To create a realized domain, create a domain.
  • 2. In the Modeling Perspective, select the domain in the Project Explorer.
  • 3. Go to the Properties view and select the Advanced tab.
  • 4. Locate the PathMATE > Analyzed property and set it to False.
  • 5. Add operations to the realized domain interface.
  • 6. Generate the code for the system. For realized domains, the C++ Transformation Map will create an interface and a stub for the realized domain.
  • 7. The domain stub will be located in the gc//_services.cpp file. Copy the file out of the gc directory into a directory to hold realized code. DO NOT edit the code in the gc directory. Any changes that you make to the gc directory or its subdirectories will be overwritten the next time you generate code. Generally we put realized code in a directory parallel to the gc directory, but you can put it wherever you want. The properties.txt will specify where the realized code is located.
  • 8. Edit the copy of the services file. Remove the #ifdef PATH_STUB_UserLockR and its corresponding #endif.
  • 9. Implement the services defined by the realized domain.
  • 10. Include the realized code in the project by adding the RealizedPath setting to the properties.txt file. Open the properties.txt file in the output directory for your C++ deployment. Add the setting:
  •                       Domain,.,RealizedPath,
  •                       Where= name of the system model
  •                       = name of realized domain
  •                       = the absolute or relative path to the realized code.

The templates will include in all files appropriate in this directory into the makefile or build project.

If you need to use the realized code to override the default implementation of the mechanisms, you can create a custom version of the mechanism files. Some examples include using different mechanisms to implement timers or customizing the startup code.

  • 1. Make a copy of the mechanism files in c:\pathmate\design\cpp\mechanisms.
  • 2. Make changes to the mechanisms.
  • 3. Change the properties.txt file to include the custom version of the mechanisms.
  •                        System,,MechanismsPath,
  •                        Where= name of the system model
  •                        = the absolute or relative path of the custom mechanisms code

Can I still use something like RRTEI to peek into the model information?PathMATE allows access to the model through the templates. The template language includes constructs to navigate the model and iterate through all classes in a package and produce reports. We have off the shelf templates that collect metrics and check modeling guidelines.

Do you have any documentation on how to make a setup in RSD in order to make an *.exe-file (for model testing) with a different compiler than Visual Studio (e.g. Borland compiler)?

If you set your system TargetOS marking to Linux and retranslate with whatever deployment includes the “Build file generation – makefiles and project files” map, you will get a Linux makefile generated in your build directory. The line you add to your properties.txt file looks like: System,SimpleOven,TargetOS,Linux. See PathMATE Help, Transformation Maps, Build Maps.

How do I integrate legacy C++ with PathMATE generated code to encapsulate the legacy code in a realized domain?

Have you done the QuickStart Guide and completed the SimpleOven example? If you have, the ExternalDeviceControl domain is a realized domain, and you can use this as an example. The QuickStart Guide is in C:\pathmate\doc\Quickstart_.pdf. To create a realized domain:

  • 1. Add a domain to encapsulate the legacy code.
  • 2. Set the Analyze property to false in the UML editor. This will vary depending on which UML editor you are using.
  • 3. Define a set of domain services that the model will use to access the legacy C++.
  • 4. Generate code.
  • 5. Create a realized code directory parallel to the generated code directory.
  • 6. Copy the gc//_services.cpp file into the realized code directory and change the name of the file to_services_realized.cpp.
  • 7. Remove the #ifdef PATH_STUB_and its corresponding #endif from the_services.cpp file. For example, for ExternalDeviceControl you would remove the following lines:
  •                 /* do not include stubbed realized services unless PATH_STUB_ExternalDeviceControl is
  •                 defined. */ #ifdef PATH_STUB_ExternalDeviceControl
  •           And:
  •                 #endif /* PATH_STUB_ExternalDeviceControl */
  • 8. Add the implementation of the domain services.
  • 9. In properties.txt, specify the RealizedPath property for the domain. You may use relative paths. Paths are relative to the MAIN directory containing the generated makefile or build project file. For example, Domain,SimpleOven.ExternalDeviceControl,RealizedPath,..\realized_cpp.

Transformation, Target Environment

Can we still use the TargetRTS as in RRT or something familiar with Windows, Linux and VxWorks targets?

Yes. PathMATE has an equivalent platform independent layer, called software mechanisms, that has been ported to the platforms above and more.  If you need to port to another platform we do not yet support, the source code for the mechanisms is shipped with the product. You could also change the transformation rules to run on top of the Rose RT TargetRTS.

If we have a multi-process/multi-task embedded system, do you think PathMATE will deliver enough performance and multitasking efficiency in this type of target environment?

The PathMATE generated code is very efficient and has many features for developing multi-process/multi-task embedded systems. We have the following features:

  • Memory pooling
  • Easy to configure multi-process/multi-task deployments that can be changed by modifying markings and regenerating code
  • Advanced trimming and optimization features
  • Support for the Linux platform
  • Static allocation of class instance populations
  • All aspects of generated code can be configured

PathMATE offers the most configurable and optimal support for model driven development of embedded systems.

We had problems getting the QuickStart SimpleOven java code to execute and connect with Spotlight. When we run QuickStartApp::main from RSM (Eclipse), the following message appears in the console: ExternalDeviceControl::ActivateDevice for SYS_DEVICE_LIGHT. and the execution terminates before we can connect to Spotlight. What should we do?

The Java mechanisms ship with a constant defined by default that disables Spotlight instrumentation. You can edit the PfdDefine.java file in the Java mechanisms folder and toggle the NO_PATH_IE constant from true to false. This will enable the Spotlight instrumentation in the application.

The attached Sentry model when generated to C++ in PathMATE v7 gives me the following error when compiling driver.cpp:

  • c:\rsm_7_work\sentry\cpp\gc\sys\group_gg_space_t.hpp(351) : warning C4541: ‘dynamic_cast’ used on polymorphic type ‘class Groupgg_space_t’ with /GR-; unpredictable behavior may resultclass ListGroupItergg_space_t : public GroupItergg_space_t
  • {
  • friend class ListGroupgg_space_t;
  • public:
  • // create a group iterator that doesn’t point to a list yet
  • ListGroupItergg_space_t() {};// destroy the iterator
  • virtual ~ListGroupItergg_space_t() {};
  • // set the group that we are iterating over
  • virtual void setGroup(Groupgg_space_t& new_group)
  • {
  • ListGroupgg_space_t* list_impl = dynamic_cast(&new_group);

What should we do?

You may need to regenerate the Visual Studio project. In Visual Studio project properties navigate to Configuration Properties > C/C++ > Language. The value of the Enable Run-Time Type Info property should be set to Yes (/GR). If not, regenerate the project.

UML2 profiles applied to analysis elements can be accessed by the PathMATE transformation templates. How can I use stereotypes?

  • 1. Create a UML2 Profile.
  • 2. Apply stereotypes to model elements.
  • 3. Specify which profiles to extract by setting the IncludeProfile property of the PathMATE System Model.
  •        i. In the Modeling perspective, select the PathMATE System model in the Project Explorer.
  •        ii. In the Properties view, select the Advanced tab.
  •        iii. Enter a comma separated list of the names of the profiles to be extracted.
  •        iv. Properties of the extracted profile can be accessed in the templates using the PROPERTY template directive.

You can find more information about user defined stereotypes in the PathMATE documentation included with Eclipse. Select the topic PathMATE Help >Modeler Guide for Rational Software Modeler > User Defined Properties. If you are looking for more information about creating and applying UML profiles with Rational Software Modeler, see the RSM help topic Extending Rational Software Modeler Functionality > Extending the Rational modeling environment > Extending the UML metamodel.

Spotlight

I have a problem running Spotlight. The dynamic link library mscoree.dll could not be found.

The mscoree.dll is part of the Microsoft .NET framework required by Spotlight. The .NET framework should be installed automatically as part of the PathMATE installation. Please check to see if .NET Framework is installed by going to the Windows Control Panel; double click Add or Remove Programs. You should see Microsoft .NET Framework in the listing of currently installed programs. PathMATE requires version 1.1.

Can you please instruct me how to approach automatic testing using Spotlight and Pathmate with special attention to the organization of test steps, test cases and test suites?

Spotlight testing can be performed on either a single domain or sets of domains. Typically we relate test cases to domain level scenarios. Each domain level scenario should map to one or more tests cases. Each test case sets up the class instances in the domain as required to exercise the desired test path. The test is initiated by calling a domain service or generating an event. The test results are captured in a log. Tracepoints capture a log of the behavior; e.g. transitions, event generations, etc. Instance dumps capture the instances at a particular point in time. Both logs can be validated as the gold standard. When the test is performed again, the results are compared to the gold standard. If they match, the test passes. If they do not match, the test fails. To do automated test with Spotlight, you need to set up a spotlight driver file for each test. You can then either write a script that will start each test case or alternatively you can use a GUI testing tool to drive Spotlight and start each case.

You can learn more about the Spotlight drivers in the Automated Testing section of the Spotlight User Guide. Spotlight has the ability to read a test script, in the form of an XML file, that allows the script to do most of the things that can be done through the Spotlight UI.

The element describes how to start up the Java application (it can also start C++ executables) and the network port to connect each task. The verification of the results, trace files and instance dumps, must currently happen outside the PathMATE toolset, but regression testing is certainly possible. Also, management of test suites is also currently outside of the PathMATE toolset, but the .stdf files are linked to Spotlight on Windows, so you can easily write a test per .stdf file and write a batch script to start each one.

If our FAQs have not answered your question, please contact us.