Release Note v140

RELEASE DATE: July 25, 2012

[FMDB] Repo: http://redmine.scorec.rpi.edu/anonsvn/fmdb/software/trunk/FMDB/FMDB
[SCUtil] Repo: http://redmine.scorec.rpi.edu/anonsvn/fmdb/software/trunk/SCORECUtil/SCORECUtil
[GMI] Repo: http://redmine.scorec.rpi.edu/anonsvn/gmi/trunk

Constraints

  • single partition (communicator) per process
  • the same number of parts per mesh instance

Known Bugs/Issues

See Issue Tickets.

Bug Fixes

  • [FMDB] (#416) FMDB_Mesh_Verify collective status report
  • [FMDB] (#415) FMDB_Mesh_Verify for optimized calls
  • [FMDB] (#414) FMDB does not compile on BG/P

New API/Features

  • [FMDB.h] given part handle, getting local/global part id
    int FMDB_Part_LocalID (pPart part);
    int FMDB_Part_GlobID (pPart part);
    

    Given a part handle, returns local/global part id.

    For i'th part p on process rank j, where # parts per process is M and # processes is X (i=0,...,M-1, j=0,...,X-1)

      FMDB_Part_LocalID(p) returns i;
      FMDB_Part_GlobID(p) returns j*M+i;
    

  • [FMDB.h] given global part id, getting process rank and local part id
    int  FMDB_PartID_CommRank (pid);
    int  FMDB_PartID_LocalID (pid);
    

    For global part id pid, where # parts per process is M

      FMDB_PartID_CommRank (pid) returns pid/M;
      FMDB_PartID_LocalID (pid) returns pid%M;
    

  • [FMDB.h] (#405) For a vertex, getting loading part id and read-in order from mesh file
    int FMDB_Vtx_GetLoadPartOrderPair (pPart part, pMeshEnt vtx, int* load_partid, int* load_order);
    

    - Given a source part handle, part, and vertex handle, vtx, get loading part id and read-in order from mesh file. If vtx doesn't exist in part or vtx is not a vertex handle, the error code SCUtil_INVALID_ENTITY_HANDLE is returned.
    - Restriction: only one or zero partitioning in a given process
    - load_partid is global part id where the global id of i'th part on process j is j*M+i, # parts per process is M and # processes is X (i=0,...,M-1, j=0,...,X-1).
    - load_order starts from 1
    - Note: global part id is changed dynamically every time # part per process changes. Suppose N is # part per process at time of loading and M is # part per process at time of partitioning. If N is not qual to M, for proper part id mapping, load_partid returned by FMDB_Vtx_GetLoadPartOrderPair should be converted to the part id at time of loading .

    [Equation]
        For a vertex, global part id at time of loading = FMDB_PartID_CommRank(pid)*N + FMDB_PartID_LocalID(pid),
        where
            N: # part per process at time of loading
            pid: loading part id returned by FMDB_Vtx_GetLoadPartOrderPair
    
    [Example]
    N=1: # part per process at time of loading
    M=56: # part per process at time of partitioning
    i = 0: local part id of part where vertex v is created
    j = 2: process rank of part where vertex v is created
        // load a partitioned mesh on X processes (1 part per process)
        FMDB_Mesh_LoadFromFile(mesh, ...);  // suppose a vertex v is loaded on part 2 (=2*1+0) in 10'th order
        FMDB_Mesh_SetNumPart(mesh, 56); // global id of part 2 is changed to 128 (=2*56+0)
        FMDB_Mesh_GlobPtn(mesh, ...); // support a vertex v is migrated to part 173
        int load_partid, load_order;
        FMDB_Vtx_GetLoadPartOrderPair (part 173, v, &load_partid, &load_order); 
        assert (load_partid==128 && load_order==10);
    

    Using Equation, the part id of part 128 at time of loading is
    FMDB_PartID_CommRank(128)*1 + FMDB_PartID_LocalID(128) = (128/56)*1+(128%56) = 2
    
  • [FMDB.h] merging N part mesh (migrating all parts to part 0 on master process)
    int FMDB_Mesh_Merge ( pMeshMdl mesh, MigrCB migrCB)
    

    Given a mesh instance, and migation callback, merge all parts (migrate all parts to part 0 on master process). How to handle the tag attached to the entity or P-set along with migration is specified in migrCB. Tags not specified in migrCB are discarded when entities and entitiy sets are migrated to part 0. For N part mesh merged to part 0, FMDB Mesh WriteToFile call still creates N mesh files where N − 1 mesh files are empty.
  • [FMDB.h] set weight for entity topology.
    int FMDB_Topo_SetWeight ( pMeshMdl /* in */ mesh, int    /* in */ topo, double /* in */ weight)
    

    Given a mesh instance, entity topology topo, and double weight value weight, set the weight of the entities of topology to weight for dynamic mesh partitioning control. The specified entity weight is maintained even after the entity is migrated to other part. In FMDB Mesh GlobPtn, if no specific weight is set, the default weight for each entity is 1.0. Weight control is not available for static mesh partitioning (initial mesh partitioning performed in FMDB Mesh LoadFromFile).
  • [FMDB.h] delete weight for entity topology
    int FMDB_Topo_DelWeight ( pMeshMdl /* in */ mesh, int    /* in */ topo)
    

    Given a mesh instance and entity topology topo, delete the weight of the entities of topology.
  • [FMDB.h] set weight for individual entity
     
    int FMDB_Ent_SetWeight ( pMeshEnt /* in */ meshEnt, double /* in */ weight)
    

    Given a mesh entity handle and double weight value weight, set the weight of the entity to weight for dynamic mesh partitioning control. The specified entity weight is maintained even after the entity is migrated to other part. In FMDB Mesh GlobPtn, if no specific weight is set, the default weight for each entity is 1.0. Weight control is not available for static mesh partitioning (initial mesh partitioning performed in FMDB Mesh LoadFromFile).

  • [FMDB.h] delete weight for individual entity
     
    int FMDB_Ent_DelWeight ( pMeshEnt /* in */ meshEnt)
    

    Given a mesh entity handle, delete the weight of the entity to weight.

  • [FMDB.h] get weight for individual entity
    int FMDB_Ent_GetWeight ( pMeshEnt /* in */ meshEnt, double* /* out */ weight)
    

    Given a mesh entity handle, get the weight of the entity.

  • [FMDB.h] get weight for p-set
    int FMDB_Set_GetWeight ( pEntSet /* in */ entSet, double* /* out */ weight)
    

    Given an entity set handle, get the weight of the entity set. The weight of entity set is the summation of consisting entities’s weight.

Improved API/Features

  • [FMDB.h] FMDB_Mesh_DspStat - improved to compute imbalance ratio per part/process based on weight of partition node
    (click here for sample)
  • [FMDB.h] FMDB_Rgn_Create - vertex ordering is checked on region creation and displays warning message if not valid.
  • [FMDB.h] Checking if entity is in part/set
    [OLD] 
    int FMDB_Part_HasEnt (pPart part, pMeshEnt ent, int* hasEnt);
    int FMDB_Set_HasEnt (pEntSet set, pMeshEnt ent, int* hasEnt);
    
    [NEW]
    int FMDB_Part_FindEnt (pPart part, pMeshEnt ent, int* found);
    int FMDB_Set_FindEnt (pEntSet set, pMeshEnt ent, int* found);
    
  • [FMDB.h] finding an entity consisting of input downward entities
    [OLD]
    int FMDB_Ent_Find (pPart part, pMeshEnt* down_ents, int num_down_ents, pMeshEnt& ent);
    
    [NEW]
    int FMDB_Ent_Find (pMeshEnt* down_ents, int num_down_ents, pMeshEnt& ent);
    
  • [FMDB.h] getting a pset where an entity belongs to
    [OLD]
    // isIn=1 if entity is in p-set, otherwise 0
    int FMDB_Ent_GetPOSet (pMeshEnt meshEnt, int* isIn, pEntSet& entSet);  
    
    [OLD]
    // returns an error code if entity is not in p-set
    int FMDB_Ent_GetPSet (pMeshEnt meshEnt, pEntSet& entSet);   
    
  • [FMDB.h] getting type of entity set (FMDB_SSET, FMDB_LSET, FMDB_PSET)
    [OLD]
    // isList=1 if entity set is list-type (unordered) set, otherwise 0
    // isPO=1 if entity set is p-set, otherwise 0
    int FMDB_Set_GetType (pEntSet entSet, int* isList, int* isPO); 
    
    // *set_type is FMDB_SSET, FMDB_LSET, or FMDB_PSET
    int FMDB_Set_GetType (pEntSet entSet, int* set_type); 
    

Removed Fuctions/Files

Build Change/Note

- NONE

Old vs. New API Table

Sample Programs

Prev Release
Next Release

Back to Top...