Changeset 160 for soft/giet_vm/xml

Timestamp:

Jun 12, 2012, 4:21:27 PM (13 years ago)

Author:

karaoui

Message:

giet-vm new version

Location:

soft/giet_vm/xml

Files:

• Makefile (modified) (1 diff)
• mapping_info.h (modified) (7 diffs)
• xml_driver.c (modified) (9 diffs)
• xml_parser.c (modified) (22 diffs)

soft/giet_vm/xml/Makefile

@@ -8 +8 @@
         gcc -Wall -I. -I/usr/include/libxml2 xml_parser.c -o xml2bin -lxml2
 
+test:
+        ./xml2bin map.xml test.bin
+        ./bin2xml test.bin test.xml
+
+up_test:
+        ./xml2bin ../map.xml ../test.bin
+        ./bin2xml ../test.bin ../test.xml
+
+
 clean:
         rm xml2bin bin2xml 

soft/giet_vm/xml/mapping_info.h

@@ -18 +18 @@
 // - mapping_vspace_t   vspace[vspaces]     (MAPPING_VSPACE_SIZE * vspaces)
 // - mapping_vseg_t     vseg[vsegs]         (MAPPING_VSEG_SIZE * vsegs)
+// - mapping_vseg_t     vobj[vsegs]         (MAPPING_VOBJ_SIZE * vsegs)
 // - mapping_task_t     task[tasks]         (MAPPING_TASK_SIZE * tasks)
-// - mapping_mwmr_t     mwmr[mwmrs]         (MAPPING_MWMR_SIZE * mwmrs)
 //
 // The number of clusters and the number of vspaces are defined in the header.
@@ -43 +43 @@
 #define MAPPING_VSPACE_SIZE     sizeof(mapping_vspace_t)
 #define MAPPING_VSEG_SIZE           sizeof(mapping_vseg_t)
+#define MAPPING_VOBJ_SIZE           sizeof(mapping_vobj_t)
 #define MAPPING_PSEG_SIZE           sizeof(mapping_pseg_t)
 #define MAPPING_TASK_SIZE           sizeof(mapping_task_t)
@@ -54 +55 @@
 #define OUT_MAPPING_SIGNATURE   0xBABEF00D
 
+enum 
+{
+    ELF = 0,    //loadable code object
+    PTAB,       //page table 
+    PERI,       //hardware component
+    MWMR,       //MWMR channel
+    LOCK,       //Lock
+    BUFFER,     //Any "no intialiasation needed" objects (stacks...)
+    BARRIER     //Barrier
+};
+
+
 ///////////////////////////////
 typedef struct mapping_header_s
@@ -63 +76 @@
         unsigned int    globals;                // number of vsegs mapped in all vspaces
         unsigned int    vspaces;                // number of virtual spaces
-        unsigned int    vsegs;                  // total number of virtual segments (for all vspaces
+        unsigned int    vsegs;                  // total number of virtual segments (for all vspaces)
+        unsigned int    vobjs;                  // total number of virtual memory objects (for all vspaces)
         unsigned int    tasks;                  // total number of tasks (for all vspaces)
     char            name[32];       // mapping name
-    char            syspath[64];    // path for the system binary code ("sys.bin")
 } mapping_header_t;
 
@@ -90 +103 @@
 {
     char            name[32];       // virtual space name
-    char            binpath[64];    // pathname to the binary code ("app.bin")
+    unsigned int    funcs_offset;   // offset of the vobj containing the function entry table (relative to vobj_offset)
         unsigned int    vsegs;              // number of private virtual segments
+        unsigned int    vobjs;              // number of vobjs channels
         unsigned int    tasks;              // number of tasks
-        unsigned int    mwmrs;              // number of mwmr channels
         unsigned int    ttys;               // number of required TTY terminals
     unsigned int    vseg_offset;    // index of first vseg in vspace 
+    unsigned int    vobj_offset;    // index of first vobjs in vspace
     unsigned int    task_offset;    // index of first task in vspace
-    unsigned int    mwmr_offset;    // index of first mwmr in vspace
 } mapping_vspace_t;
 
@@ -110 +123 @@
         unsigned char   mode;           // C-X-W-U flags
     unsigned char   ident;          // identity mapping if non zero
-    unsigned char   mwmr;           // mwmr channel if non zero
+        unsigned int    vobjs;              // number of vobjs channels
+    unsigned int    vobj_offset;    // index of first vobjs in vspace
     unsigned char   reserved;       // unused
 } mapping_vseg_t;
@@ -120 +134 @@
         unsigned int    clusterid;          // physical cluster index
         unsigned int    proclocid;      // processor local index (inside cluster)
-    unsigned int    vseglocid;      // stack vseg index in vspace
+    unsigned int    vobjlocid;      // stack vobj index in vspace
     unsigned int    startid;        // index in start_vector (in seg_data)
     unsigned int    ttylocid;       // tty index (inside the vspace)
 } mapping_task_t;
+
+/////////////////////////////
+typedef struct mapping_vobj_s 
+{
+    char            name[32];       // vobj name (unique in a vspace)
+    char            binpath[64];    // path for the binary code ("*.bin")
+        unsigned int    type;           // type of vobj
+        unsigned int    length;         // size (bytes)
+        unsigned int    align;          // required alignement (logarithm of 2)
+        unsigned int    vaddr;          // virtual addresse of the vobj location (bytes)
+        unsigned int    paddr;          // physical addresse of the vobj location (bytes)
+} mapping_vobj_t;
 
 #endif

soft/giet_vm/xml/xml_driver.c

@@ -20 +20 @@
 void buildXml( mapping_header_t* header, FILE* fpout)
 {
+
+    const char* 
+    vobj_type[] = 
+    { 
+        "ELF",
+        "PTAB",   //page table 
+        "PERI",   //hardware component
+        "MWMR",   //MWMR channel
+        "LOCK",   //Lock
+        "BUFFER", //Any "no intialiasation needed" objects (stacks...)
+        "BARRIER" //Barrier
+    };
     const char* mode_str[] = { "____",
                                "___U", 
@@ -41 +53 @@
     unsigned int                pseg_id;
     unsigned int                vseg_id;
+    unsigned int                vobj_id;
     unsigned int                task_id;
 
@@ -47 +60 @@
     mapping_vspace_t*   vspace;
     mapping_vseg_t*     vseg;
+    mapping_vobj_t*     vobj;
     mapping_task_t*     task;
 
@@ -71 +85 @@
                                   MAPPING_VSPACE_SIZE*header->vspaces );
 
+    // computes the base adresss for vobjs array, 
+    vobj    = (mapping_vobj_t*)   ((char*)header +
+                                  MAPPING_HEADER_SIZE +
+                                  MAPPING_CLUSTER_SIZE*header->clusters +
+                                  MAPPING_PSEG_SIZE*header->psegs +
+                                  MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VSEG_SIZE*header->vsegs );
+
     // computes the base address for tasks array 
     task    = (mapping_task_t*)   ((char*)header +
@@ -77 +99 @@
                                   MAPPING_PSEG_SIZE*header->psegs +
                                   MAPPING_VSPACE_SIZE*header->vspaces +
+                                  MAPPING_VOBJ_SIZE*header->vobjs +
                                   MAPPING_VSEG_SIZE*header->vsegs );
 
@@ -89 +112 @@
     fprintf( fpout, "              ttys      = \"%d\"\n", header->ttys);
     fprintf( fpout, "              vspaces   = \"%d\"\n", header->vspaces);
-    fprintf( fpout, "              globals   = \"%d\"\n", header->globals);
-    fprintf( fpout, "              syspath   = \"%s\" >\n", header->syspath);
+    fprintf( fpout, "              globals   = \"%d\" />\n\n", header->globals);
 
     ///////////////////// clusters ///////////////////////////////////////////////
@@ -124 +146 @@
         fprintf( fpout, "        <vseg    name     = \"%s\"\n",      vseg[vseg_id].name);
         fprintf( fpout, "                 vbase    = \"0x%x\"\n",    vseg[vseg_id].vbase);
-        fprintf( fpout, "                 length   = \"0x%x\"\n",    vseg[vseg_id].length);
         fprintf( fpout, "                 mode     = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
         fprintf( fpout, "                 psegname = \"%s\"\n",      pseg[pseg_id].name);
-        fprintf( fpout, "                 ident    = \"%d\" />\n\n", vseg[vseg_id].ident);
+        fprintf( fpout, "                 ident    = \"%d\" >\n", vseg[vseg_id].ident);
+            for ( vobj_id = vseg[vseg_id].vobj_offset ;
+                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; vobj_id++ )
+            {
+                fprintf( fpout, "                 <vobj name     = \"%s\"\n",     vobj[vobj_id].name);
+                fprintf( fpout, "                       type     = \"%s\" \n", vobj_type[vobj[vobj_id].type]);
+                if(vobj[vobj_id].length)
+                    fprintf( fpout, "                       length   = \"0x%x\" \n",   vobj[vobj_id].length);
+                if(vobj[vobj_id].align)
+                    fprintf( fpout, "                       align    = \"%d\" \n",   vobj[vobj_id].align);
+                if(vobj[vobj_id].binpath[0]!='\0')
+                    fprintf( fpout, "                       binpath  = \"%s\" \n",   vobj[vobj_id].binpath);
+                fprintf( fpout, "                       />\n");
+            }
+            fprintf( fpout, "        </vseg>\n\n");
     }
     fprintf( fpout, "    </globalset>\n" );
@@ -136 +171 @@
     for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
+        unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].funcs_offset; 
         fprintf( fpout, "        <vspace  name    = \"%s\"\n",     vspace[vspace_id].name); 
-        fprintf( fpout, "                 binpath = \"%s\"\n",     vspace[vspace_id].binpath);
-        fprintf( fpout, "                 vsegs   = \"%d\"\n",     vspace[vspace_id].vsegs);
-        fprintf( fpout, "                 tasks   = \"%d\"\n",     vspace[vspace_id].tasks);
-        fprintf( fpout, "                 mwmrs   = \"%d\"\n",     vspace[vspace_id].mwmrs);
+        fprintf( fpout, "                 funcs   = \"%s\"\n",     vobj[func_id].name); 
         fprintf( fpout, "                 ttys    = \"%d\" >\n\n", vspace[vspace_id].ttys);
 
@@ -150 +183 @@
             fprintf( fpout, "                 <vseg name      = \"%s\"\n",      vseg[vseg_id].name);
             fprintf( fpout, "                       vbase     = \"0x%x\"\n",    vseg[vseg_id].vbase);
-            fprintf( fpout, "                       length    = \"0x%x\"\n",    vseg[vseg_id].length);
             fprintf( fpout, "                       mode      = \"%s\"\n", mode_str[vseg[vseg_id].mode]);
             fprintf( fpout, "                       psegname  = \"%s\"\n",      pseg[pseg_id].name);
-            fprintf( fpout, "                       mwmr      = \"%d\"\n",      vseg[vseg_id].mwmr);
-            fprintf( fpout, "                       ident     = \"%d\" />\n\n", vseg[vseg_id].ident);
+            fprintf( fpout, "                       ident     = \"%d\" >\n", vseg[vseg_id].ident);
+
+            for ( vobj_id = vseg[vseg_id].vobj_offset ;
+                  vobj_id < (vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs) ; vobj_id++ )
+            {
+                fprintf( fpout, "\t                 <vobj name     = \"%s\"\n",     vobj[vobj_id].name);
+                fprintf( fpout, "\t                       type     = \"%s\" \n", vobj_type[vobj[vobj_id].type]);
+                if(vobj[vobj_id].length)
+                    fprintf( fpout, "\t                       length   = \"0x%x\" \n",   vobj[vobj_id].length);
+                if(vobj[vobj_id].align)
+                    fprintf( fpout, "\t                       align    = \"%d\" \n",   vobj[vobj_id].align);
+                if(vobj[vobj_id].binpath[0]!='\0')
+                    fprintf( fpout, "\t                       binpath  = \"%s\" \n",   vobj[vobj_id].binpath);
+                fprintf( fpout, "\t                       />\n");
+            }
+            fprintf( fpout, "\t\t        </vseg>\n\n");
         }
         for ( task_id = vspace[vspace_id].task_offset ;
               task_id < (vspace[vspace_id].task_offset + vspace[vspace_id].tasks) ; task_id++ )
         {
-            unsigned int vseg_id = task[task_id].vseglocid + vspace[vspace_id].vseg_offset; 
+            unsigned int vobj_id = task[task_id].vobjlocid + vspace[vspace_id].vobj_offset; 
 
             fprintf( fpout, "                 <task name      = \"%s\"\n",      task[task_id].name);
             fprintf( fpout, "                       clusterid = \"%d\"\n",      task[task_id].clusterid);
             fprintf( fpout, "                       proclocid = \"%d\"\n",      task[task_id].proclocid);
-            fprintf( fpout, "                       stackname = \"%s\"\n",      vseg[vseg_id].name);
+            fprintf( fpout, "                       stackname = \"%s\"\n",      vobj[vobj_id].name);
             fprintf( fpout, "                       startid   = \"%d\"\n",      task[task_id].startid);
             fprintf( fpout, "                       ttylocid  = \"%d\" />\n\n", task[task_id].ttylocid);

soft/giet_vm/xml/xml_parser.c

@@ -18 +18 @@
 #include  <mapping_info.h>
 
-#define MAX_CLUSTERS            1024
+#define MAX_CLUSTERS    1024
 #define MAX_PSEGS               4096
 #define MAX_VSPACES             1024
@@ -24 +24 @@
 #define MAX_MWMRS               4096
 #define MAX_VSEGS               4096
+#define MAX_VOBJS               8192
 
 #define XML_PARSER_DEBUG        0
@@ -36 +37 @@
 mapping_vspace_t*       vspace[MAX_VSPACES];            // vspace array
 mapping_vseg_t*         vseg[MAX_VSEGS];                // vseg array
+mapping_vobj_t*         vobj[MAX_VOBJS];                // vobj array
 mapping_task_t*         task[MAX_TASKS];                // task array
 
@@ -46 +48 @@
 unsigned int            task_index     = 0;
 unsigned int            task_loc_index = 0;
-unsigned int            mwmr_index     = 0;
-unsigned int            mwmr_loc_index = 0;
+unsigned int            vobj_index     = 0;
+unsigned int            vobj_loc_index = 0;
+unsigned int            vobj_loc_vspace_index = 0;
+            
+char one_elf_found = 0;//bool: wether a first vobj of type elf was found
 
 //////////////////////////////////////////////////
@@ -132 +137 @@
 
 //////////////////////////////////////////
-int getVsegLocId( unsigned int  vspace_id,
+int getVobjLocId( unsigned int  vspace_id,
                   char*         str )
 {
-    unsigned int vseg_id;
-    unsigned int vseg_min = vspace[vspace_id]->vseg_offset;
-    unsigned int vseg_max = vseg_min + vspace[vspace_id]->vsegs;
-
-    for ( vseg_id = vseg_min ; vseg_id < vseg_max ; vseg_id++ )
-    {
-        if ( strcmp(vseg[vseg_id]->name, str) == 0 ) return (vseg_id - vseg_min);
+    unsigned int vobj_id;
+    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
+    unsigned int vobj_max = vobj_min + vobj_loc_vspace_index;
+
+    for ( vobj_id = vobj_min ; vobj_id < vobj_max ; vobj_id++ )
+    {
+        if ( strcmp(vobj[vobj_id]->name, str) == 0 )
+        {
+             return (vobj_id - vobj_min);
+        }
     }
     return -1;
@@ -218 +226 @@
     if ( ok )
     {
-        int index = getVsegLocId( vspace_index, str );
+        int index = getVobjLocId( vspace_index, str );
         if ( index >= 0 ) 
         {
@@ -225 +233 @@
 printf("      vsegid    = %d\n", index);
 #endif
-            task[task_index]->vseglocid = index;
+            task[task_index]->vobjlocid = index;
         }
         else              
@@ -283 +291 @@
 } // end taskNode()
 
-///////////////////////////////////////////////////////////////
-void  vsegNode ( xmlTextReaderPtr reader )
+void  vobjNode ( xmlTextReaderPtr reader )
 {
     unsigned int        ok;
@@ -292 +299 @@
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
 
+    if ( vobj_index >= MAX_VOBJS )
+    {
+        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VSEGS);
+        exit(1);
+    }
+
+    if(one_elf_found != 0)
+    {
+        printf("[XML ERROR] a vobj of the type ELF must be defined alone in a vseg (%d,%d)\n", 
+                vspace_index, vobj_loc_vspace_index);
+        exit(1);
+
+    }
+
+#if XML_PARSER_DEBUG
+printf("    vobj %d\n", vobj_loc_index);
+#endif
+
+    vobj[vobj_index] = (mapping_vobj_t*)malloc(sizeof(mapping_vobj_t));
+
+    ///////// get name attribute
+    str = getStringValue(reader, "name", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      name = %s\n", str);
+#endif
+        strncpy( vobj[vobj_index]->name, str, 31);
+    }
+    else
+    {
+        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n", 
+                vseg_index, vobj_loc_index);
+        exit(1);
+    }
+
+
+    // get type attribute
+    str = getStringValue(reader, "type", &ok);
+#if XML_PARSER_DEBUG
+printf("      type = %s\n", str);
+#endif
+    if (ok && (strcmp(str, "ELF") == 0)){
+        vobj[vobj_index]->type = ELF;
+        one_elf_found = 1;
+        if(vobj_loc_index != 0) //check that this vobj is the first
+        {
+            printf("[XML ERROR] a vobj of the type ELF must be defined alone in a vobj (%d,%d)\n", 
+                    vspace_index, vobj_loc_vspace_index);
+            exit(1);
+
+        }
+    }
+    else if (ok && (strcmp(str, "PTAB") == 0)) vobj[vobj_index]->type = PTAB;
+    else if (ok && (strcmp(str, "PERI") == 0)) vobj[vobj_index]->type = PERI;
+    else if (ok && (strcmp(str, "MWMR") == 0)) vobj[vobj_index]->type = MWMR;
+    else if (ok && (strcmp(str, "LOCK") == 0)) vobj[vobj_index]->type = LOCK;
+    else if (ok && (strcmp(str, "BUFFER") == 0)) vobj[vobj_index]->type = BUFFER;
+    else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = BARRIER;
+    else
+    {
+        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
+                vspace_index, vobj_loc_vspace_index);
+        exit(1);
+    }
+
+
+    ////////// get length attribute (0 if missing)
+    value = getIntValue(reader,"length", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      length = %d\n", value);
+#endif
+        vobj[vobj_index]->length = value;
+    }  
+    else
+    {
+        vobj[vobj_index]->length = 0;
+    }
+
+    ////////// get align attribute (0 if missing)
+    value = getIntValue(reader,"align", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      align = %d\n", value);
+#endif
+        vobj[vobj_index]->align = value;
+    }  
+    else
+    {
+        vobj[vobj_index]->align = 0;
+    }
+
+    ////////// get binpath attribute ('\0' if missing)
+    str = getStringValue(reader, "binpath", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("      binpath = %s\n", str);
+#endif
+        strncpy(vobj[vobj_index]->binpath, str, 63);
+    }  
+    else
+    {
+        vobj[vobj_index]->binpath[0] = '\0';
+    }
+    
+    vobj_index++;
+    vobj_loc_index++;
+    vobj_loc_vspace_index++;
+}
+
+
+///////////////////////////////////////////////////////////////
+void  vsegNode ( xmlTextReaderPtr reader )
+{
+    unsigned int        ok;
+    unsigned int        value;
+    char*               str;
+        vobj_loc_index = 0;
+        one_elf_found = 0;
+
+    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
+
     if ( vseg_index >= MAX_VSEGS )
     {
@@ -303 +436 @@
 
     vseg[vseg_index] = (mapping_vseg_t*)malloc(sizeof(mapping_vseg_t));
+    
+    ////////// set vobj_offset attributes
+    vseg[vseg_index]->vobj_offset = vobj_index;
+#if XML_PARSER_DEBUG
+printf("- vobj_offset = %d\n", vobj_index);
+#endif
 
     ///////// get name attribute
@@ -336 +475 @@
     }
 
-    ////////// get length attribute
-    value = getIntValue(reader,"length", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("      length = 0x%x\n", value);
-#endif
-        vseg[vseg_index]->length = value;
-    }  
-    else
-    {
-        printf("[XML ERROR] illegal or missing <length> attribute for vseg (%d,%d)\n", 
-                vspace_index, vseg_loc_index);
-        exit(1);
-    }
 
     ////////// get ident attribute (0 if missing)
@@ -366 +490 @@
     }
 
-    ////////// get mwmr attribute (0 if missing)
-    value = getIntValue(reader,"mwmr", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("      mwmr  = %d\n", value);
-#endif
-        vseg[vseg_index]->mwmr = value;
-        if ( value )
-        {
-            mwmr_index++;
-            mwmr_loc_index++;
-        }
-    }  
-    else
-    {
-        vseg[vseg_index]->mwmr = 0;
-    }
 
     ////////// get psegname attribute
@@ -440 +546 @@
     }
     
-    vseg_index++;
-    vseg_loc_index++;
+    
+    ////////// set the length attribute to 0
+    //the final value will be set by the VLoader
+    vseg[vseg_index]->length = value;
+
+    ////////// get vobjs
+    int status = xmlTextReaderRead ( reader );
+    while ( status == 1 ) 
+    {
+        const char* tag = (const char*)xmlTextReaderConstName(reader);
+
+        if      ( strcmp(tag,"vobj") == 0    ) vobjNode(reader);
+        else if ( strcmp(tag,"#text"  ) == 0 ) { }
+        else if ( strcmp(tag,"vseg") == 0  ) 
+        {
+            //  checking source file consistency?
+            vseg[vseg_index]->vobjs = vobj_loc_index;
+            vseg_index++;
+            vseg_loc_index++;
+            return;
+        }
+        else 
+        {
+            printf("[XML ERROR] Unknown tag %s",tag);
+            exit(1);
+        }
+        status = xmlTextReaderRead ( reader );
+    }
+    
+
 } // end vsegNode()
 
@@ -450 +584 @@
     unsigned int        ok;
     unsigned int        value;
+    vobj_loc_vspace_index = 0;
+        vseg_loc_index = 0;
+        task_loc_index = 0;
 
     if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
@@ -467 +604 @@
     vspace[vspace_index] = (mapping_vspace_t*)malloc(sizeof(mapping_vspace_t));
 
-    ////////// set vseg_offset and task_offset attributes
+    ////////// set vseg_offsetand task_offset attributes
     vspace[vspace_index]->vseg_offset = vseg_index;
+    vspace[vspace_index]->vobj_offset = vobj_index;
     vspace[vspace_index]->task_offset = task_index;
     
 #if XML_PARSER_DEBUG
 printf("- vseg_offset = %d\n", vseg_index);
+printf("- vobj_offset = %d\n", vobj_index);
 printf("- task_offset = %d\n", task_index);
 #endif
@@ -492 +631 @@
     }
 
-    /////////// get binpath attribute
-    str = getStringValue(reader, "binpath", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    binpath = %s\n", str);
-#endif
-        strncpy(vspace[vspace_index]->binpath, str, 63);
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <binpath> attribute for vspace %d", 
+    ////////// get funcs_entry attribute
+    str = getStringValue(reader, "funcs", &ok);
+    if ( ok )
+    {
+#if XML_PARSER_DEBUG
+printf("    name = %s\n", str);
+#endif
+        //used after parsing all the vobjs
+    }
+    else
+    {
+        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d", 
                  vspace_index);
         exit(1);
-    }
-
-    ////////// get vsegs attribute
-    value = getIntValue(reader,"vsegs",&ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    vsegs = %d\n", value);
-#endif
-        vspace[vspace_index]->vsegs = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <vsegs> attribute for vspace %d", 
-                 vspace_index);
-        exit(1);
-    }
-
-    // get tasks attribute
-    value = getIntValue(reader,"tasks", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    tasks = %d\n", value);
-#endif
-        vspace[vspace_index]->tasks = value;
-    }
-    else
-    {
-        printf("[XML ERROR] illegal or missing <tasks> attribute for vspace %d", 
-                  vspace_index);
-        exit(1);
-    }
-
-    // get mwmrs attribute
-    value = getIntValue(reader,"mwmrs", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("    mwmrs = %d\n", value);
-#endif
-        vspace[vspace_index]->mwmrs = value;
-    }
-    else
-    {
-        vspace[vspace_index]->mwmrs = 0;
     }
 
@@ -580 +673 @@
         else if ( strcmp(tag,"vspace") == 0  ) 
         {
-            // checking source file consistency
-            if ( vseg_loc_index != vspace[vspace_index]->vsegs )
+            vspace[vspace_index]->vobjs = vobj_loc_vspace_index;
+            vspace[vspace_index]->tasks = task_loc_index ;
+            vspace[vspace_index]->vsegs = vseg_loc_index ;
+            int index =  getVobjLocId( vspace_index, str );
+            if(index == -1)
             {
-                printf("[XML ERROR] Wrong number of vsegs in vspace %d\n", vspace_index);
-                exit(1);
+                printf("Error funcs entry vobj not found %s\n",str);
+                exit(-1);
             }
-            else if ( task_loc_index != vspace[vspace_index]->tasks )
-            {
-                printf("[XML ERROR] Wrong number of tasks in vspace %d\n", vspace_index);
-                exit(1);
-            }
-            else if ( mwmr_loc_index != vspace[vspace_index]->mwmrs )
-            {
-                printf("[XML ERROR] Wrong number of mwmrs in vspace %d\n", vspace_index);
-                exit(1);
-            }
-            else
-            {
-                vseg_loc_index = 0;
-                task_loc_index = 0;
-                mwmr_loc_index = 0;
-                vspace_index++;
-                return;
-            }
+            vspace[vspace_index]->funcs_offset = index;
+
+            vspace_index++;
+            return;
         }
         else 
@@ -898 +980 @@
             {
                 header->vsegs = vseg_index;
+                header->vobjs = vobj_index;
                 header->tasks = task_index;
                 return;
@@ -1033 +1116 @@
     {
         printf("[XML ERROR] illegal or missing <globals> attribute in mapping_info_header\n");
-        exit(1);
-    }
-
-    // get syspath attribute
-    name = getStringValue(reader, "syspath", &ok);
-    if ( ok )
-    {
-#if XML_PARSER_DEBUG
-printf("- syspath = %s\n\n", name);
-#endif
-        strncpy( header->syspath, name, 63);
-    }      
-    else
-    {
-        printf("[XML ERROR] illegal or missing <syspath> attribute in header\n");
         exit(1);
     }
@@ -1086 +1154 @@
     unsigned int    vspace_id;
     unsigned int    vseg_id;
+    unsigned int    vobj_id;
     unsigned int    task_id;
 
@@ -1142 +1211 @@
 #if XML_PARSER_DEBUG
 printf("write vspace %d\n", vspace_id);
+printf("vspace->vobj_offset: %d\n", vspace[vspace_id]->vobj_offset);
+printf("vspace->vobjs: %d\n", vspace[vspace_id]->vobjs);
+printf("header->vobjs: %d\n", header->vobjs);
 #endif
 
@@ -1163 +1235 @@
         {
             perror("write vseg");
+            exit(1);
+        }
+    }
+    
+    // write vobjs
+    for ( vobj_id = 0 ; vobj_id < header->vobjs ; vobj_id++ )
+    {
+        length = write(fdout, (char*)vobj[vobj_id], sizeof(mapping_vobj_t));
+    
+#if XML_PARSER_DEBUG
+printf("write vobj %d\n", vobj_id);
+printf("write vobj name %s\n", vobj[vobj_id]->name);
+printf("write vobj length %x\n", vobj[vobj_id]->length);
+printf("write vobj type %d\n", vobj[vobj_id]->type);
+#endif
+
+        if ( length != sizeof(mapping_vobj_t) )
+        {
+            perror("write vobj");
             exit(1);
         }