bool verbose = false;

bool dump = false;

bool jsonoutput = false;

bool forceoneiteration = false;

bool justdata = false;

#ifndef _MSC_VER

int c;

while ((c = getopt(argc, argv, "1vdt")) != -1)

switch (c) {

case 't':

justdata = true;

break;

case 'v':

verbose = true;

break;

case 'd':

dump = true;

break;

case 'j':

jsonoutput = true;

break;

case '1':

forceoneiteration = true;

break;

default:

abort();

}

#else

int optind = 1;

#endif

if (optind >= argc) {

cerr << "Usage: " << argv[0] << " <jsonfile>" << endl;

exit(1);

}

const char *filename = argv[optind];

if (optind + 1 < argc) {

cerr << "warning: ignoring everything after " << argv[optind + 1] << endl;

}

if (verbose)

cout << "[verbose] loading " << filename << endl;

std::string_view p;

try {

p = get_corpus(filename);

} catch (const std::exception &e) { // caught by reference to base

std::cout << "Could not load the file " << filename << std::endl;

return EXIT_FAILURE;

}

if (verbose)

cout << "[verbose] loaded " << filename << " (" << p.size() << " bytes)"

<< endl;

#if defined(DEBUG)

const uint32_t iterations = 1;

#else

const uint32_t iterations =

forceoneiteration ? 1 : (p.size() < 1 * 1000 * 1000 ? 1000 : 10);

#endif

vector<double> res;

res.resize(iterations);

#if !defined(__linux__)

#define SQUASH_COUNTERS

if (justdata) {

printf("justdata (-t) flag only works under linux.\n");

}

#endif

#ifndef SQUASH_COUNTERS

vector<int> evts;

evts.push_back(PERF_COUNT_HW_CPU_CYCLES);

evts.push_back(PERF_COUNT_HW_INSTRUCTIONS);

evts.push_back(PERF_COUNT_HW_BRANCH_MISSES);

evts.push_back(PERF_COUNT_HW_CACHE_REFERENCES);

evts.push_back(PERF_COUNT_HW_CACHE_MISSES);

LinuxEvents<PERF_TYPE_HARDWARE> unified(evts);

vector<unsigned long long> results;

results.resize(evts.size());

unsigned long cy0 = 0, cy1 = 0, cy2 = 0;

unsigned long cl0 = 0, cl1 = 0, cl2 = 0;

unsigned long mis0 = 0, mis1 = 0, mis2 = 0;

unsigned long cref0 = 0, cref1 = 0, cref2 = 0;

unsigned long cmis0 = 0, cmis1 = 0, cmis2 = 0;

#endif

bool isok = true;

for (uint32_t i = 0; i < iterations; i++) {

if (verbose)

cout << "[verbose] iteration # " << i << endl;

#ifndef SQUASH_COUNTERS

unified.start();

#endif

ParsedJson pj;

bool allocok = pj.allocateCapacity(p.size());

if (!allocok) {

std::cerr << "failed to allocate memory" << std::endl;

return EXIT_FAILURE;

}

#ifndef SQUASH_COUNTERS

unified.end(results);

cy0 += results[0];

cl0 += results[1];

mis0 += results[2];

cref0 += results[3];

cmis0 += results[4];

#endif

if (verbose)

cout << "[verbose] allocated memory for parsed JSON " << endl;

auto start = std::chrono::steady_clock::now();

#ifndef SQUASH_COUNTERS

unified.start();

#endif

isok = find_structural_bits(p.data(), p.size(), pj);

#ifndef SQUASH_COUNTERS

unified.end(results);

cy1 += results[0];

cl1 += results[1];

mis1 += results[2];

cref1 += results[3];

cmis1 += results[4];

if (!isok) {

cout << "Failed out during stage 1\n";

break;

}

unified.start();

#endif

isok = isok && unified_machine(p.data(), p.size(), pj);

#ifndef SQUASH_COUNTERS

unified.end(results);

cy2 += results[0];

cl2 += results[1];

mis2 += results[2];

cref2 += results[3];

cmis2 += results[4];

if (!isok) {

cout << "Failed out during stage 34\n";

break;

}

#endif

auto end = std::chrono::steady_clock::now();

std::chrono::duration<double> secs = end - start;

res[i] = secs.count();

}

ParsedJson pj = build_parsed_json(p); // do the parsing again to get the stats

if (!pj.isValid()) {

std::cerr << "Could not parse. " << std::endl;

return EXIT_FAILURE;

}

#ifndef SQUASH_COUNTERS

unsigned long total = cy0 + cy1 + cy2;

if (justdata) {

float cpb0 = (double)cy0 / (iterations * p.size());

float cpb1 = (double)cy1 / (iterations * p.size());

float cpb2 = (double)cy2 / (iterations * p.size());

float cpbtotal = (double)total / (iterations * p.size());

char *newfile = (char *)malloc(strlen(filename) + 1);

if (newfile == NULL)

return EXIT_FAILURE;

::strcpy(newfile, filename);

char *snewfile = ::basename(newfile);

size_t nl = strlen(snewfile);

for (size_t j = nl - 1; j > 0; j--) {

if (snewfile[j] == '.') {

snewfile[j] = '\0';

break;

}

}

printf("\"%s\"\t%f\t%f\t%f\t%f\n", snewfile, cpb0, cpb1, cpb2,

cpbtotal);

free(newfile);

} else {

printf("number of bytes %ld number of structural chars %u ratio %.3f\n",

p.size(), pj.n_structural_indexes,

(double)pj.n_structural_indexes / p.size());

printf("mem alloc instructions: %10lu cycles: %10lu (%.2f %%) ins/cycles: "

"%.2f mis. branches: %10lu (cycles/mis.branch %.2f) cache accesses: "

"%10lu (failure %10lu)\n",

cl0 / iterations, cy0 / iterations, 100. * cy0 / total,

(double)cl0 / cy0, mis0 / iterations, (double)cy0 / mis0,

cref1 / iterations, cmis0 / iterations);

printf(" mem alloc runs at %.2f cycles per input byte.\n",

(double)cy0 / (iterations * p.size()));

printf("stage 1 instructions: %10lu cycles: %10lu (%.2f %%) ins/cycles: "

"%.2f mis. branches: %10lu (cycles/mis.branch %.2f) cache accesses: "

"%10lu (failure %10lu)\n",

cl1 / iterations, cy1 / iterations, 100. * cy1 / total,

(double)cl1 / cy1, mis1 / iterations, (double)cy1 / mis1,

cref1 / iterations, cmis1 / iterations);

printf(" stage 1 runs at %.2f cycles per input byte.\n",

(double)cy1 / (iterations * p.size()));

printf("stage 2 instructions: %10lu cycles: %10lu (%.2f %%) ins/cycles: "

"%.2f mis. branches: %10lu (cycles/mis.branch %.2f) cache "

"accesses: %10lu (failure %10lu)\n",

cl2 / iterations, cy2 / iterations, 100. * cy2 / total,

(double)cl2 / cy2, mis2 / iterations, (double)cy2 / mis2,

cref2 / iterations, cmis2 / iterations);

printf(" stage 2 runs at %.2f cycles per input byte and ",

(double)cy2 / (iterations * p.size()));

printf("%.2f cycles per structural character.\n",

(double)cy2 / (iterations * pj.n_structural_indexes));

printf(" all stages: %.2f cycles per input byte.\n",

(double)total / (iterations * p.size()));

}

#endif

double min_result = *min_element(res.begin(), res.end());

if (!justdata)

cout << "Min: " << min_result << " bytes read: " << p.size()

<< " Gigabytes/second: " << (p.size()) / (min_result * 1000000000.0)

<< "\n";

if (jsonoutput) {

isok = isok && pj.printjson(std::cout);

}

if (dump) {

isok = isok && pj.dump_raw_tape(std::cout);

}

aligned_free((void *)p.data());

if (!isok) {

fprintf(stderr, " Parsing failed. \n ");

return EXIT_FAILURE;

}

return EXIT_SUCCESS;