You are currently viewing SemiWiki as a guest which gives you limited access to the site. To view blog comments and experience other SemiWiki features you must be a registered member. Registration is fast, simple, and absolutely free so please, join our community today!

  • Requirements Management and IP Management Working Together

    I first heard about requirements management back in 1995 while marketing a graphic HDL entry tool for an EDA vendor, and it sounded like a very useful automation approach, however our team quickly discovered that there were too many different vendors for requirements management, so there could be no simple way to integrate with all of them. Living in Oregon I've heard about Jama Software, and visiting their web site I saw that their requirements management tool is named Jama and that they serve industries like:
    • Aerospace & Defense
    • Automotive
    • Medical
    • Semiconductor


    Jama even quoted tier one company Infineon Technologies:

    "Currently, IoT is still highly fragmented with a lot of single solutions. A key factor for success will be the competence to integrate and apply these single solutions. For example, it is crucial to combine the functionalities of sensors, actuators and computing power"
    Dr. Reinhard Ploss, CEO of Infineon Technologies

    Article: Virtual Prototype your SoC including Arteris FlexNoC and optimize architecture using CPAK from Carbon-jama-min.jpg
    Getting back to the question of integration it turns out that IP Management vendor Methodics has created an elegant way to integrate with Jama, so now semiconductor IP users can use both requirements management and IP management tools together. The basic idea is to allow users doing IP management to see their requirements in context of their actual SoC design.

    Related blog - Go Native With Methodics at DAC in Austin

    Does this integration require data translations? Thankfully no, instead you continue to keep all of your requirement management files in their native formats, leaving them as source documents. The IP management tool from Methodics is called ProjectIC, and one example of leaving native formats alone is for bug integration where bugs stay within the native bug tracking tool, then while using ProjectIC you can view any of the bugs associated with IP blocks in context of the SoC.

    The methodology is to use Jama for all requirements management setup and updates, then inside of ProjectIC you view the requirements in a summary format while in the IP context. The Project IC system is extendable with widgets and this is where you define an executable script to run that fills in the widget with results as shown below:

    Article: Virtual Prototype your SoC including Arteris FlexNoC and optimize architecture using CPAK from Carbon-widget-integration-min.jpg
    This integration script can be written in either Perl or Python and it will extract the necessary information and then return it to ProjectIC using the popular JSON (JavaScript Object Notation) format. From the ProjectIC tool your integration uses Custom Fields to extend the definition of an IP block for additional meta-data like requirements management. Custom Fields in ProjectIC can also send data to your script.

    Related blog - 5 Reasons Why Platform Based Design Can Help Your Next SoC

    Jama has defined their own API which enables integrations to an IP Management tool like ProjectIC, and here's a Jama screenshot using a sample project that lists the requirements on the left-hand side.

    Article: Virtual Prototype your SoC including Arteris FlexNoC and optimize architecture using CPAK from Carbon-jama-screen-min.jpg

    The integration script will extract this Jama data and make it visible inside of ProjectIC using an ID for each IP block. In ProjectIC our first step is to create a custom field named 'JAMA_ID' and it's value will be passed to our integration script. Users will look in their Jama user story hierarchy for this particular IP block and get this number.

    The following Python script reads the custom field value for 'JAMA_ID' and returns up to 2 level of the requirements hierarchy back to ProjectIC.

    #!/usr/bin/env python
    """
    Get a Jama tree up to 2 levels by ID
    ID is passed as argument to the script
    """
    from jama import API
    import json
    import sys

    jama_id = sys.argv[1]
    api = API()
    jfunc = 'getChildrenOfItem'
    item = api(jfunc, int(jama_id))

    res = {}
    for i in item:
    res['title'] = i.name
    if i.hasChildren:
    res['isFolder'] = True
    kids = api(jfunc, i.id)
    rkids = []
    for k in kids:
    t = {}
    t['title'] = k.name
    t['isFolder'] = False
    rkids.append(t)
    res['children'] = rkids
    else:
    res['isFolder'] = False

    print(json.dumps(res))


    Our third step is to create a widget in ProjectIC that will invoke our Python script:

    Article: Virtual Prototype your SoC including Arteris FlexNoC and optimize architecture using CPAK from Carbon-widget-min.jpg

    With our widget defined and script debugged, we can start to view Jama requirement results while working inside of the ProjectIC IP management tool:

    Article: Virtual Prototype your SoC including Arteris FlexNoC and optimize architecture using CPAK from Carbon-jama-projectic-min.jpg

    Summary
    It's now possible to quickly integrate results from your favorite requirements management tool like Jama within the ProjectIC IP project management tool. This type of integration gives you a fully traceable, hierarchical SoC development throughout the IP Lifecycle Management process, connecting system design requirements and IP implementation.

    Read the complete White Paper here.