need array of shared ptrs to shared structs

From: Steve Reinhardt (spr_at_SGI_dot_com)
Date: Sun Dec 04 2005 - 06:21:26 PST

  • Next message: jcduell_at_lbl_dot_gov: "Re: need array of shared ptrs to shared structs"
    Hi all,
             I'm trying to port a serial code that does a search for 
    frequent subgraphs in a graph.  The technique I'm thinking to use is 
    to reuse as much as possible the serial code, with the primary 
    changes being that the priority queue of candidate subgraphs would be 
    shared.  The subgraphs are structs that have pointers to other 
    structs in them.  For the priority queue to work as a truly shared 
    structure, all of these structs need to be shared, and the pointers 
    to them from the priority queue need to be shared.  At least I claim 
    this is so; if there are better ways of doing this with UPC, I'm open 
    to suggestion.
    
             The program below captures the difficulty I'm having getting 
    data structures defined as I need them.
    
    #include <upc.h>
    
    shared int a[10][THREADS];
    shared int *shared c[10][THREADS];
    
    typedef struct {
             int a;
             int b;
    } gink;
    
    typedef struct {
             int a;
             int b;
             shared gink *c;         // private ptr to shared object
             shared gink *shared d;  // shared ptr to shared object
             shared int *e;          // private ptr to shared object
             shared int *shared f;   // shared ptr to shared object
    } gink2;
    
    shared gink2 aa[10][THREADS];
    shared gink2 *shared cc[10][THREADS];
    
    int main(int argc, char *argv[])
    {
    }
    
    The definitions of a and c work fine.  The definition of gink2, 
    however, gives the following error:
    
    hope2  137=> !!
    upcc -o simple simple.upc
    upcc: error during UPC-to-C translation (sgiupc stage):
    simple.upc:16: field `d' declared with shared qualifier
    simple.upc:17: field `f' declared with shared qualifier
    
    Having played with variations on this theme, it appears that UPC 
    doesn't support a member of a structure that's a shared pointer to a 
    shared object.  Is this so?
    
    I have some appreciation of the difficulties involved in implementing 
    that, with different blocking factors, etc.  But I'm still left with 
    wanting to have a shared data structure that has structs in it, and 
    pointers to those.  It seems like I'm left with the old approach of 
    foregoing the use of structs and using a distinct shared array of 
    shared objects for each element of the struct.  Or at least each 
    shared element of the struct.  Seems doable, but hardly elegant.  Is 
    there a better way that somebody has experience with?
    
    And, are there any others who are using UPC for codes that work 
    primarily on structs, and not just arrays of basic types?
    
    Thanks.                                         Steve
    
    
    
    
    
    
    
    -- 
    Steve Reinhardt                       Internet: spr_at_sgi_dot_com
    Principal Engineer and                Phone: 1.651.683.5664
       Parallel Architecture Wonk           Vnet: 233.5664
    SGI                                   Fax: 1.651.683.3082
    2750 Blue Water Road                  Chatty pager: spr_p_at_pager_dot_sgi_dot_com
    Eagan, MN 55121  USA
    
    Admin: Carol Gibson                   1.651.683.5878 carol_at_sgi_dot_com  
    

  • Next message: jcduell_at_lbl_dot_gov: "Re: need array of shared ptrs to shared structs"