Support runtime target translation for Phyp

- Added ordinal IDs to system XML files
- Added new HBRT_HYP_ID attribute to proc, membuf, core targets
- Removed duplicate target type extensions
- Customize HBRT_HYP_ID attributes in istep 21 based on payload type
- Updated runtime translation interfaces for simple, efficient lookup
- Added templated memoizer to speed up simple input/output functions
- Generate ordinal IDs in common attribute parser
- Added various test cases

RTC: 146153
CMVC-Coreq: 989094
Change-Id: Ic60996f3b7c3197191f8939f362c578b54475df4
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/22254
Tested-by: Jenkins Server
Tested-by: FSP CI Jenkins
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>
Reviewed-by: Corey V. Swenson <cswenson@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>
Reviewed-by: William G. Hoffa <wghoffa@us.ibm.com>

1 files changed, 88 insertions, 311 deletions

diff --git a/src/usr/targeting/runtime/rt_targeting.C b/src/usr/targeting/runtime/rt_targeting.C
index 707be836d..372d2baf4 100644
--- a/src/usr/targeting/runtime/rt_targeting.C
+++ b/src/usr/targeting/runtime/rt_targeting.C
@@ -35,363 +35,140 @@
 #include <targeting/common/trace.H>
 #include <targeting/common/targreasoncodes.H>
 #include <arch/pirformat.H>
-
+#include <runtime/customize_attrs_for_payload.H>
 #include <runtime/rt_targeting.H>
+#include <map>
+#include <util/memoize.H>
 
 using namespace TARGETING;
 
 namespace RT_TARG
 {
 
-errlHndl_t procRtTargetError(const TARGETING::Target * i_target)
+errlHndl_t getRtTarget(
+    const TARGETING::Target* i_pTarget,
+          rtChipId_t&        o_rtTargetId)
 {
-    errlHndl_t err = NULL;
-    uint32_t huid = get_huid(i_target);
-    TRACFCOMP(g_trac_targeting,ERR_MRK
-              "No proc target found for target. huid: %08x",
-              huid);
-    /*@
-     * @errortype
-     * @moduleid     TARG_RT_GET_RT_TARGET
-     * @reasoncode   TARG_RT_NO_PROC_TARGET
-     * @userdata1    HUID of the UNIT target
-     * @devdesc      No processor target found for the UNIT
-     */
-    err =
-        new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                                TARGETING::TARG_RT_GET_RT_TARGET,
-                                TARGETING::TARG_RT_NO_PROC_TARGET,
-                                huid,
-                                0,
-                                true);
-
-    ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
-        addToLog(err);
-
-    return err;
-}
-
-
-errlHndl_t getRtTarget(const TARGETING::Target* i_target,
-                       rtChipId_t &o_chipId)
-{
-    errlHndl_t err = NULL;
+    errlHndl_t pError = NULL;
 
     do
     {
-        if(i_target == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
+        if(i_pTarget == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
         {
             TARGETING::Target* masterProcChip = NULL;
             TARGETING::targetService().
                 masterProcChipTargetHandle(masterProcChip);
-
-            i_target = masterProcChip;
+            i_pTarget = masterProcChip;
         }
 
-        TARGETING::TYPE target_type = i_target->getAttr<TARGETING::ATTR_TYPE>();
-
-        if(target_type == TARGETING::TYPE_PROC)
-        {
-            uint32_t fabId =
-                i_target->getAttr<TARGETING::ATTR_FABRIC_GROUP_ID>();
-
-            uint32_t procPos =
-                i_target->getAttr<TARGETING::ATTR_FABRIC_CHIP_ID>();
-
-            o_chipId = PIR_t::createChipId( fabId, procPos );
-        }
-        else if( target_type == TARGETING::TYPE_MEMBUF)
+        auto hbrtHypId = RUNTIME::HBRT_HYP_ID_UNKNOWN;
+        if(   (!i_pTarget->tryGetAttr<TARGETING::ATTR_HBRT_HYP_ID>(hbrtHypId))
+           || (hbrtHypId == RUNTIME::HBRT_HYP_ID_UNKNOWN))
         {
-            //MEMBUF
-            // 0b1000.0000.0000.0000.0000.0GGG.GCCC.MMMM
-            // where GGGG is group, CCC is chip, MMMM is memory channel
-            //
-            TARGETING::TargetHandleList targetList;
-
-            getParentAffinityTargets(targetList,
-                                    i_target,
-                                    TARGETING::CLASS_UNIT,
-                                    TARGETING::TYPE_MCS);
-
-            if( targetList.empty() )
-            {
-                uint32_t huid = get_huid(i_target);
-                TRACFCOMP(g_trac_targeting,ERR_MRK
-                          "getRtTarget: No target found for huid: %08x",
-                          huid);
-                /*@
-                 * @errortype
-                 * @moduleid     TARG_RT_GET_RT_TARGET
-                 * @reasoncode   TARG_RT_UNIT_TARGET_NOT_FOUND
-                 * @userdata1    HUID of given MEMBUF target
-                 * @devdesc      No MCS target(s) found for the
-                 *               given MEMBUF target
-                 */
-                err =
-                    new ERRORLOG::ErrlEntry
-                    (ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                     TARGETING::TARG_RT_GET_RT_TARGET,
-                     TARGETING::TARG_RT_UNIT_TARGET_NOT_FOUND,
-                     huid,
-                     0,
-                     true);
-
-                ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
-                    addToLog(err);
-
-                break;
-            }
-
-            TARGETING::Target * target = targetList[0];
-            uint32_t pos = target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
-
-            targetList.clear();
-            getParentAffinityTargets(targetList,
-                                     target,
-                                     TARGETING::CLASS_CHIP,
-                                     TARGETING::TYPE_PROC);
-
-            if(targetList.empty())
-            {
-                err = procRtTargetError(target);
-                break;
-            }
-
-            TARGETING::Target * proc_target = targetList[0];
-
-            err = getRtTarget(proc_target, o_chipId);
-            if(err)
-            {
-                break;
-            }
-
-            o_chipId = (o_chipId << MEMBUF_ID_SHIFT);
-            o_chipId += pos;
-            o_chipId |= MEMBUF_TYPE;
-        }
-        else if(target_type == TARGETING::TYPE_CORE)
-        {
-            // CORE
-            // 0b0100.0000.0000.0000.0000.GGGG.CCCP.PPPP
-            // GGGG is group, CCC is chip, PPPPP is core
-            uint32_t pos = i_target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
-
-            const TARGETING::Target * proc_target = getParentChip(i_target);
-            if(proc_target == NULL)
-            {
-                err =  procRtTargetError(i_target);
-                break;
-            }
-
-            err = getRtTarget(proc_target, o_chipId);
-            if(err)
-            {
-                break;
-            }
-
-            o_chipId = PIR_t::createCoreId(o_chipId,pos);
-            o_chipId |= CORE_TYPE;
-        }
-        else
-        {
-            uint32_t huid = get_huid(i_target);
-            TRACFCOMP(g_trac_targeting,ERR_MRK
-                      "Runtime target type %d not supported."
-                      " huid: %08x",
-                      target_type,
-                      huid);
+            auto huid = get_huid(i_pTarget);
+            auto targetingTargetType =
+                i_pTarget->getAttr<TARGETING::ATTR_TYPE>();
+            TRACFCOMP(g_trac_targeting, ERR_MRK
+                "Targeting target type of 0x%08X not supported. "
+                "HUID: 0x%08X",
+                targetingTargetType,
+                huid);
             /*@
              * @errortype
-             * @moduleid     TARG_RT_GET_RT_TARGET
-             * @reasoncode   TARG_RT_TARGET_TYPE_NOT_SUPPORTED
-             * @userdata1    HUID of the target
-             * @userdata2    target_type
-             * @devdesc      Target type not supported by HBRT.
+             * @moduleid    TARG_RT_GET_RT_TARGET
+             * @reasoncode  TARG_RT_TARGET_TYPE_NOT_SUPPORTED
+             * @userdata1   Target's HUID
+             * @userdata2   target's targeting type
+             * @devdesc     Targeting target's type not supported by runtime
+             *              code
              */
-            err =
-                new ERRORLOG::ErrlEntry
-                (ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                 TARGETING::TARG_RT_GET_RT_TARGET,
-                 TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
-                 huid,
-                 target_type,
-                 true);
-
-            ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
-                addToLog(err);
+            pError = new ERRORLOG::ErrlEntry(
+                ERRORLOG::ERRL_SEV_INFORMATIONAL,
+                TARGETING::TARG_RT_GET_RT_TARGET,
+                TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
+                huid,
+                targetingTargetType,
+                true);
+
+            ERRORLOG::ErrlUserDetailsTarget(i_pTarget,"Targeting Target").
+                addToLog(pError);
         }
+
+        o_rtTargetId = hbrtHypId;
+
     } while(0);
 
-    return err;
+    return pError;
 }
 
-
-errlHndl_t getHbTarget(rtChipId_t i_rt_chip_id,
-                       TARGETING::Target *& o_target)
+/**
+ *  @brief API documentation same as for getHbTarget; this just implements the
+ *      core logic (i.e. called when the memoizer doesn't have a cached answer)
+ */
+errlHndl_t _getHbTarget(
+    const rtChipId_t          i_rtTargetId,
+          TARGETING::Target*& o_target)
 {
-    errlHndl_t err = NULL;
-    o_target = NULL;
+    errlHndl_t pError = NULL;
 
     do
     {
-        uint64_t idType = i_rt_chip_id & CHIPID_TYPE_MASK;
-
-        if(0 != (idType ==  MEMBUF_TYPE))
+        // Don't even attempt the lookup if the unknown ID is used
+        TARGETING::TargetHandle_t pTarget = NULL;
+        if(i_rtTargetId != RUNTIME::HBRT_HYP_ID_UNKNOWN)
         {
-            //membuf
-            uint64_t proc_chip_id = i_rt_chip_id & ~CHIPID_TYPE_MASK;
-            uint32_t unitPos = proc_chip_id & MEMBUF_ID_MASK;
-            proc_chip_id >>= MEMBUF_ID_SHIFT;
-            TARGETING::Target * proc = NULL;
-            TARGETING::Target * msc = NULL;
-
-            err = getHbTarget(proc_chip_id, proc);
-            if(err)
+            for (TARGETING::TargetIterator pIt =
+                    TARGETING::targetService().begin();
+                 pIt != TARGETING::targetService().end();
+                 ++pIt)
             {
-                break;
-            }
-
-            PredicateCTM mcsFilter(CLASS_UNIT, TYPE_MCS);
-            PredicateAttrVal<ATTR_CHIP_UNIT> unitAttr(unitPos);
-            PredicatePostfixExpr mcsUnitFilter;
-            mcsUnitFilter.push(&mcsFilter).push(&unitAttr).And();
-
-            TargetHandleList target_list;
-
-            targetService().getAssociated( target_list,
-                                           proc,
-                                           TargetService::CHILD_BY_AFFINITY,
-                                           TargetService::ALL,
-                                           &mcsUnitFilter);
-
-            // should only be one result
-            if(target_list.size())
-            {
-                msc = target_list[0];
-
-                target_list.clear();
-
-
-                getChildAffinityTargets( target_list,
-                                         msc,
-                                         TARGETING::CLASS_CHIP,
-                                         TARGETING::TYPE_MEMBUF);
-
-                // should only be one result
-                if(target_list.size())
+                auto rtTargetId = RUNTIME::HBRT_HYP_ID_UNKNOWN;
+                if(   ((*pIt)->tryGetAttr<
+                           TARGETING::ATTR_HBRT_HYP_ID>(rtTargetId))
+                   && (rtTargetId == i_rtTargetId))
                 {
-                    o_target = target_list[0];
+                    pTarget = (*pIt);
+                    break;
                 }
             }
-
-            if(o_target == NULL) // no mcs and/or membuf found
-            {
-                TRACFCOMP(g_trac_targeting,ERR_MRK "getHbTarget: "
-                          "MCS or MEMBUF target not found for chipId %08lx",
-                          i_rt_chip_id);
-                /*@
-                 * @errortype
-                 * @moduleid     TARGETING::TARG_RT_GET_HB_TARGET
-                 * @reasoncode   TARG_RT_UNIT_TARGET_NOT_FOUND
-                 * @userdata1    Runtime chip Id
-                 * @devdesc      No MCS or MEMBUF target(s) found for the
-                 *               given target
-                 */
-                err =
-                    new ERRORLOG::ErrlEntry
-                    (ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                     TARGETING::TARG_RT_GET_HB_TARGET,
-                     TARGETING::TARG_RT_UNIT_TARGET_NOT_FOUND,
-                     i_rt_chip_id,
-                     0,
-                     true);
-            }
-
-        }
-        else if(0 != (idType == CORE_TYPE))
-        {
-            uint64_t core_id = i_rt_chip_id & ~CHIPID_TYPE_MASK;
-            uint32_t unitPos = PIR_t::coreFromCoreId(core_id);
-            uint64_t chip_id = PIR_t::chipFromCoreId(core_id);
-            TARGETING::Target * proc = NULL;
-
-            err = getHbTarget(chip_id, proc);
-            if(err)
-            {
-                break;
-            }
-
-            PredicateCTM exFilter(CLASS_UNIT, TYPE_CORE);
-            PredicateAttrVal<ATTR_CHIP_UNIT> unitAttr(unitPos);
-            PredicatePostfixExpr exUnitFilter;
-            exUnitFilter.push(&exFilter).push(&unitAttr).And();
-
-            TargetHandleList target_list;
-
-            targetService().getAssociated( target_list,
-                                           proc,
-                                           TargetService::CHILD,
-                                           TargetService::ALL,
-                                           &exUnitFilter);
-
-            //Should only be one result
-            if(target_list.size())
-            {
-                o_target = target_list[0];
-            }
-            // o_target not found caught below..
         }
-        else if( idType == PROC_TYPE)
-        {
-            // assume processor chip
-            uint32_t fabId = PIR_t::groupFromChipId(i_rt_chip_id);
-            uint32_t procPos = PIR_t::chipFromChipId(i_rt_chip_id);
-
-            PredicateCTM procFilter(CLASS_CHIP, TYPE_PROC);
-            PredicateAttrVal<ATTR_FABRIC_GROUP_ID> nodeFilter(fabId);
-            PredicateAttrVal<ATTR_FABRIC_CHIP_ID> chipFilter(procPos);
-
-            PredicatePostfixExpr theProc, theAttrs;
-            theAttrs.push(&nodeFilter).push(&chipFilter).And();
-            theProc.push(&procFilter).push(&theAttrs).And();
-
-            TargetRangeFilter procRange(targetService().begin(),
-                                        targetService().end(),
-                                        &theProc);
 
-            if(procRange)
-            {
-                o_target = *procRange;
-            }
-        }
-
-        if(!err && o_target == NULL)
+        if(pTarget == NULL)
         {
-            TRACFCOMP( g_trac_targeting,
-                       ERR_MRK"Can't find HB target for chipId 0x%lx",
-                       i_rt_chip_id);
+            TRACFCOMP( g_trac_targeting, ERR_MRK
+                "Can't find targeting target for runtime target ID of "
+                "0x%16llX",
+                i_rtTargetId);
             /*@
              * @errortype
              * @moduleid     TARGETING::TARG_RT_GET_HB_TARGET
              * @reasoncode   TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED
-             * @userdata1    runtime procId
+             * @userdata1    Runtime target ID
              * @userdata2    0
-             * @devdesc      Can't find HB Target for chipId provided.
+             * @devdesc      Can't find targeting target for given runtime
+             *               target ID
              */
-            err =
-                new ERRORLOG::ErrlEntry
-                (
-                 ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                 TARGETING::TARG_RT_GET_HB_TARGET,
-                 TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
-                 i_rt_chip_id,
-                 0,
-                 true);
-
+            pError = new ERRORLOG::ErrlEntry(
+                ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                TARGETING::TARG_RT_GET_HB_TARGET,
+                TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
+                i_rtTargetId,
+                0,
+                true);
         }
+
+        o_target = pTarget;
+
     } while(0);
 
-    return err;
+    return pError;
+}
+
+errlHndl_t getHbTarget(
+    const rtChipId_t          i_rtTargetId,
+          TARGETING::Target*& o_target)
+{
+      return Util::Memoize::memoize(_getHbTarget,i_rtTargetId,o_target);
 }
 
-}; // namespace
+}; // End namespace RT_TARG