Changeset 2751


Ignore:
Timestamp:
Dec 4, 2012, 10:31:15 PM (6 years ago)
Author:
cameron
Message:

Update SAXCount; add Makefile.in

Location:
icXML/icXML-devel
Files:
2 added
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/samples/src/SAXCount/SAXCount.cpp

    r2726 r2751  
    3131#endif
    3232#include <xercesc/util/OutOfMemoryException.hpp>
     33#define BUFFER_PROFILING 1
     34//#define CODE_CLOCKER 1
     35#include <simd-lib/perflib/perfsec.h>
     36//#include <simd-lib/perflib/i386_timer.h>
     37#ifdef BUFFER_PROFILING
     38    BOM_Table * parser_timer;
     39#elif CODE_CLOCKER
     40    //#define NUM_EVENTS 1
     41    //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
     42    //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
     43    #define NUM_EVENTS 3
     44    int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_L1_TCM, PAPI_BR_MSP};
     45    //int Events[NUM_EVENTS] = {PAPI_LD_INS, PAPI_L2_TCM, PAPI_L3_TCM};
     46    int cal_size = 20;
     47    CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
     48#else
     49    void * parser_timer;
     50#endif
     51
     52
     53#include <sys/types.h>
     54#include <sys/stat.h>
     55#include <unistd.h>
     56
     57unsigned long GetFileSize(const char * fileName)
     58{
     59        struct stat filestatus;
     60        stat( fileName, &filestatus );
     61        return filestatus.st_size;
     62}
     63
    3364
    3465// ---------------------------------------------------------------------------
     
    3768void usage()
    3869{
    39     XERCES_STD_QUALIFIER cout << "\nUsage:\n"
    40             "    SAXCount [options] <XML file | List file>\n\n"
    41             "This program invokes the SAX Parser, and then prints the\n"
    42             "number of elements, attributes, spaces and characters found\n"
    43             "in each XML file, using SAX API.\n\n"
    44             "Options:\n"
    45             "    -l          Indicate the input file is a List File that has a list of xml files.\n"
    46             "                Default to off (Input file is an XML file).\n"
    47             "    -v=xxx      Validation scheme [always | never | auto*].\n"
    48             "    -n          Enable namespace processing. Defaults to off.\n"
    49             "    -s          Enable schema processing. Defaults to off.\n"
    50             "    -f          Enable full schema constraint checking. Defaults to off.\n"
    51             "    -locale=ll_CC specify the locale, default: en_US.\n"
    52                     "    -?          Show this help.\n\n"
    53             "  * = Default if not provided explicitly.\n"
    54         << XERCES_STD_QUALIFIER endl;
     70        XERCES_STD_QUALIFIER cout << "\nUsage:\n"
     71                        "    SAXCount [options] <XML file | List file>\n\n"
     72                        "This program invokes the SAX Parser, and then prints the\n"
     73                        "number of elements, attributes, spaces and characters found\n"
     74                        "in each XML file, using SAX API.\n\n"
     75                        "Options:\n"
     76                        "    -l          Indicate the input file is a List File that has a list of xml files.\n"
     77                        "                Default to off (Input file is an XML file).\n"
     78                        "    -v=xxx      Validation scheme [always | never | auto*].\n"
     79                        "    -n          Enable namespace processing. Defaults to off.\n"
     80                        "    -s          Enable schema processing. Defaults to off.\n"
     81                        "    -f          Enable full schema constraint checking. Defaults to off.\n"
     82                        "    -locale=ll_CC specify the locale, default: en_US.\n"
     83                        "    -?          Show this help.\n\n"
     84                        "  * = Default if not provided explicitly.\n"
     85                << XERCES_STD_QUALIFIER endl;
    5586}
    5687
     
    6293{
    6394
    64     // Check command line and extract arguments.
    65     if (argC < 2)
    66     {
    67         usage();
    68         return 1;
    69     }
    70 
    71     const char*              xmlFile = 0;
    72     SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
    73     bool                     doNamespaces       = false;
    74     bool                     doSchema           = false;
    75     bool                     schemaFullChecking = false;
    76     bool                     doList = false;
    77     bool                     errorOccurred = false;
    78     bool                     recognizeNEL = false;
    79     char                     localeStr[64];
    80     memset(localeStr, 0, sizeof localeStr);
    81 
    82     int argInd;
    83     for (argInd = 1; argInd < argC; argInd++)
    84     {
    85         // Break out on first parm not starting with a dash
    86         if (argV[argInd][0] != '-')
    87             break;
    88 
    89         // Watch for special case help request
    90         if (!strcmp(argV[argInd], "-?"))
    91         {
    92             usage();
    93             return 2;
    94         }
    95          else if (!strncmp(argV[argInd], "-v=", 3)
    96               ||  !strncmp(argV[argInd], "-V=", 3))
    97         {
    98             const char* const parm = &argV[argInd][3];
    99 
    100             if (!strcmp(parm, "never"))
    101                 valScheme = SAXParser::Val_Never;
    102             else if (!strcmp(parm, "auto"))
    103                 valScheme = SAXParser::Val_Auto;
    104             else if (!strcmp(parm, "always"))
    105                 valScheme = SAXParser::Val_Always;
    106             else
    107             {
    108                 XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
    109                 return 2;
    110             }
    111         }
    112          else if (!strcmp(argV[argInd], "-n")
    113               ||  !strcmp(argV[argInd], "-N"))
    114         {
    115             doNamespaces = true;
    116         }
    117          else if (!strcmp(argV[argInd], "-s")
    118               ||  !strcmp(argV[argInd], "-S"))
    119         {
    120             doSchema = true;
    121         }
    122          else if (!strcmp(argV[argInd], "-f")
    123               ||  !strcmp(argV[argInd], "-F"))
    124         {
    125             schemaFullChecking = true;
    126         }
    127          else if (!strcmp(argV[argInd], "-l")
    128               ||  !strcmp(argV[argInd], "-L"))
    129         {
    130             doList = true;
    131         }
    132          else if (!strcmp(argV[argInd], "-special:nel"))
    133         {
    134             // turning this on will lead to non-standard compliance behaviour
    135             // it will recognize the unicode character 0x85 as new line character
    136             // instead of regular character as specified in XML 1.0
    137             // do not turn this on unless really necessary
    138              recognizeNEL = true;
    139         }
    140          else if (!strncmp(argV[argInd], "-locale=", 8))
    141         {
    142              // Get out the end of line
    143              strcpy(localeStr, &(argV[argInd][8]));
    144         }
    145         else
    146         {
    147             XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
    148                 << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
    149         }
    150     }
    151 
    152     //
    153     //  There should at least one parameter left, and that
    154     //  should be the file name(s).
    155     //
    156     if (argInd == argC)
    157     {
    158         usage();
    159         return 1;
    160     }
    161 
    162     // Initialize the XML4C2 system
    163     try
    164     {
    165         if (strlen(localeStr))
    166         {
    167             XMLPlatformUtils::Initialize(localeStr);
    168         }
    169         else
    170         {
    171             XMLPlatformUtils::Initialize();
    172         }
    173 
    174         if (recognizeNEL)
    175         {
    176             XMLPlatformUtils::recognizeNEL(recognizeNEL);
    177         }
    178     }
    179 
    180     catch (const XMLException& toCatch)
    181     {
    182         XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
    183             << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
    184         return 1;
    185     }
    186 
    187     //
    188     //  Create a SAX parser object. Then, according to what we were told on
    189     //  the command line, set it to validate or not.
    190     //
    191     SAXParser* parser = new SAXParser;
    192 
    193     parser->setValidationScheme(valScheme);
    194     parser->setDoNamespaces(doNamespaces);
    195     parser->setDoSchema(doSchema);
    196     parser->setHandleMultipleImports (true);
    197     parser->setValidationSchemaFullChecking(schemaFullChecking);
    198 
    199     //
    200     //  Create our SAX handler object and install it on the parser, as the
    201     //  document and error handler.
    202     //
    203     SAXCountHandlers handler;
    204     parser->setDocumentHandler(&handler);
    205     parser->setErrorHandler(&handler);
    206 
    207 
    208     //
    209     //  Get the starting time and kick off the parse of the indicated
    210     //  file. Catch any exceptions that might propogate out of it.
    211     //
    212     unsigned long duration;
    213 
    214     XERCES_STD_QUALIFIER ifstream fin;
    215 
    216     // the input is a list file
    217     if (doList)
    218         fin.open(argV[argInd]);
    219 
    220     if (fin.fail()) {
    221         XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
    222         return 2;
    223     }
    224 
    225     while (true)
    226     {
    227         char fURI[1000];
    228         //initialize the array to zeros
    229         memset(fURI,0,sizeof(fURI));
    230 
    231         if (doList) {
    232             if (! fin.eof() ) {
    233                 fin.getline (fURI, sizeof(fURI));
    234                 if (!*fURI)
    235                     continue;
    236                 else {
    237                     xmlFile = fURI;
    238                     XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
    239                 }
    240             }
    241             else
    242                 break;
    243         }
    244         else {
    245             if (argInd < argC)
    246             {
    247                  xmlFile = argV[argInd];
    248                  argInd++;
    249             }
    250             else
    251                 break;
    252         }
    253 
    254         //reset error count first
    255         handler.resetErrors();
    256 
    257         try
    258         {
    259             const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
    260             parser->parse(xmlFile);
    261             const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
    262             duration = endMillis - startMillis;
    263         }
    264         catch (const OutOfMemoryException&)
    265         {
    266             XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
    267             errorOccurred = true;
    268             continue;
    269         }
    270         catch (const XMLException& e)
    271         {
    272             XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
    273                 << "Exception message is:  \n"
    274                 << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
    275             errorOccurred = true;
    276             continue;
    277         }
    278 
    279         catch (...)
    280         {
    281             XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
    282             errorOccurred = true;
    283             continue;
    284         }
    285 
    286 
    287         // Print out the stats that we collected and time taken
    288         if (!handler.getSawErrors())
    289         {
    290             XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
    291                 << handler.getElementCount() << " elems, "
    292                 << handler.getAttrCount() << " attrs, "
    293                 << handler.getSpaceCount() << " spaces, "
    294                 << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
    295         }
    296         else
    297             errorOccurred = true;
    298     }
    299 
    300     if (doList)
    301         fin.close();
    302 
    303     //
    304     //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    305     //
    306     delete parser;
    307 
    308     // And call the termination method
    309     XMLPlatformUtils::Terminate();
    310 
    311     if (errorOccurred)
    312         return 4;
    313     else
    314         return 0;
     95        // Check command line and extract arguments.
     96        if (argC < 2)
     97        {
     98                usage();
     99                return 1;
     100        }
     101
     102        const char*              xmlFile = 0;
     103        SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
     104        bool                     doNamespaces       = false;
     105        bool                     doSchema           = false;
     106        bool                     schemaFullChecking = false;
     107        bool                     doList = false;
     108        bool                     errorOccurred = false;
     109        bool                     recognizeNEL = false;
     110        char                     localeStr[64];
     111        memset(localeStr, 0, sizeof localeStr);
     112
     113        int argInd;
     114        for (argInd = 1; argInd < argC; argInd++)
     115        {
     116                // Break out on first parm not starting with a dash
     117                if (argV[argInd][0] != '-')
     118                        break;
     119
     120                // Watch for special case help request
     121                if (!strcmp(argV[argInd], "-?"))
     122                {
     123                        usage();
     124                        return 2;
     125                }
     126                 else if (!strncmp(argV[argInd], "-v=", 3)
     127                          ||  !strncmp(argV[argInd], "-V=", 3))
     128                {
     129                        const char* const parm = &argV[argInd][3];
     130
     131                        if (!strcmp(parm, "never"))
     132                                valScheme = SAXParser::Val_Never;
     133                        else if (!strcmp(parm, "auto"))
     134                                valScheme = SAXParser::Val_Auto;
     135                        else if (!strcmp(parm, "always"))
     136                                valScheme = SAXParser::Val_Always;
     137                        else
     138                        {
     139                                XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
     140                                return 2;
     141                        }
     142                }
     143                 else if (!strcmp(argV[argInd], "-n")
     144                          ||  !strcmp(argV[argInd], "-N"))
     145                {
     146                        doNamespaces = true;
     147                }
     148                 else if (!strcmp(argV[argInd], "-s")
     149                          ||  !strcmp(argV[argInd], "-S"))
     150                {
     151                        doSchema = true;
     152                }
     153                 else if (!strcmp(argV[argInd], "-f")
     154                          ||  !strcmp(argV[argInd], "-F"))
     155                {
     156                        schemaFullChecking = true;
     157                }
     158                 else if (!strcmp(argV[argInd], "-l")
     159                          ||  !strcmp(argV[argInd], "-L"))
     160                {
     161                        doList = true;
     162                }
     163                 else if (!strcmp(argV[argInd], "-special:nel"))
     164                {
     165                        // turning this on will lead to non-standard compliance behaviour
     166                        // it will recognize the unicode character 0x85 as new line character
     167                        // instead of regular character as specified in XML 1.0
     168                        // do not turn this on unless really necessary
     169                         recognizeNEL = true;
     170                }
     171                 else if (!strncmp(argV[argInd], "-locale=", 8))
     172                {
     173                         // Get out the end of line
     174                         strcpy(localeStr, &(argV[argInd][8]));
     175                }
     176                else
     177                {
     178                        XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
     179                                << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
     180                }
     181        }
     182
     183        //
     184        //  There should at least one parameter left, and that
     185        //  should be the file name(s).
     186        //
     187        if (argInd == argC)
     188        {
     189                usage();
     190                return 1;
     191        }
     192
     193        // Initialize the XML4C2 system
     194        try
     195        {
     196                if (strlen(localeStr))
     197                {
     198                        XMLPlatformUtils::Initialize(localeStr);
     199                }
     200                else
     201                {
     202                        XMLPlatformUtils::Initialize();
     203                }
     204
     205                if (recognizeNEL)
     206                {
     207                        XMLPlatformUtils::recognizeNEL(recognizeNEL);
     208                }
     209        }
     210
     211        catch (const XMLException& toCatch)
     212        {
     213                XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
     214                        << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
     215                return 1;
     216        }
     217
     218        //
     219        //  Create a SAX parser object. Then, according to what we were told on
     220        //  the command line, set it to validate or not.
     221        //
     222        SAXParser* parser = new SAXParser;
     223
     224        parser->setValidationScheme(valScheme);
     225        parser->setDoNamespaces(doNamespaces);
     226        parser->setDoSchema(doSchema);
     227        parser->setHandleMultipleImports (true);
     228        parser->setValidationSchemaFullChecking(schemaFullChecking);
     229
     230        //
     231        //  Create our SAX handler object and install it on the parser, as the
     232        //  document and error handler.
     233        //
     234        SAXCountHandlers handler;
     235        parser->setDocumentHandler(&handler);
     236        parser->setErrorHandler(&handler);
     237
     238
     239        //
     240        //  Get the starting time and kick off the parse of the indicated
     241        //  file. Catch any exceptions that might propogate out of it.
     242        //
     243        //timestamp_t totalCycles;
     244        PERF_SEC_BIND(1);
     245
     246        PERF_SEC_INIT(parser_timer);
     247
     248
     249
     250        XERCES_STD_QUALIFIER ifstream fin;
     251
     252        // the input is a list file
     253        if (doList)
     254                fin.open(argV[argInd]);
     255
     256        if (fin.fail()) {
     257                XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
     258                return 2;
     259        }
     260
     261        while (true)
     262        {
     263                char fURI[1000];
     264                //initialize the array to zeros
     265                memset(fURI,0,sizeof(fURI));
     266
     267                if (doList) {
     268                        if (! fin.eof() ) {
     269                                fin.getline (fURI, sizeof(fURI));
     270                                if (!*fURI)
     271                                        continue;
     272                                else {
     273                                        xmlFile = fURI;
     274                                        XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
     275                                }
     276                        }
     277                        else
     278                                break;
     279                }
     280                else {
     281                        if (argInd < argC)
     282                        {
     283                                 xmlFile = argV[argInd];
     284                                 argInd++;
     285                        }
     286                        else
     287                                break;
     288                }
     289
     290                //reset error count first
     291                handler.resetErrors();
     292
     293                try
     294                {
     295                        //const timestamp_t startCycles = read_cycle_counter();
     296                        PERF_SEC_START(parser_timer);
     297
     298                        parser->parse(xmlFile);
     299
     300                        PERF_SEC_END(parser_timer, (long double)GetFileSize(xmlFile));
     301
     302                        //const timestamp_t endCycles = read_cycle_counter();
     303                        //totalCycles = endCycles - startCycles;
     304                }
     305                catch (const OutOfMemoryException&)
     306                {
     307                        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
     308                        errorOccurred = true;
     309                        continue;
     310                }
     311                catch (const XMLException& e)
     312                {
     313                        XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
     314                                << "Exception message is:  \n"
     315                                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
     316                        errorOccurred = true;
     317                        continue;
     318                }
     319
     320                catch (...)
     321                {
     322                        XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
     323                        errorOccurred = true;
     324                        continue;
     325                }
     326
     327
     328
     329
     330                // Print out the stats that we collected and time taken
     331                if (!handler.getSawErrors())
     332                {
     333                        XERCES_STD_QUALIFIER cout << xmlFile << ": " //<< ((long double)totalCycles / (long double)GetFileSize(xmlFile)) << " cycles/byte ("
     334                                << handler.getElementCount() << " elems, "
     335                                << handler.getAttrCount() << " attrs, "
     336                                << handler.getSpaceCount() << " spaces, "
     337                                << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
     338
     339                        PERF_SEC_DUMP(parser_timer);
     340                }
     341
     342                else
     343                        errorOccurred = true;
     344        }
     345        PERF_SEC_DESTROY(parser_timer);
     346
     347        if (doList)
     348                fin.close();
     349
     350        //
     351        //  Delete the parser itself.  Must be done prior to calling Terminate, below.
     352        //
     353        delete parser;
     354
     355        // And call the termination method
     356        XMLPlatformUtils::Terminate();
     357
     358        if (errorOccurred)
     359                return 4;
     360        else
     361                return 0;
    315362
    316363}
Note: See TracChangeset for help on using the changeset viewer.