Example #1
0
int main(int argc, char *argv[])
{
  i64 i,n;
  CSA csa;
  mytimestruct before,after;
  double t;

   if (argc<2) {
      fprintf(stderr, "syntax: suftest file\n");
      return 1;
   }

   csa_read(&csa,argc,argv);
   n = csa.n;

   mygettime(&before);
   {
     int m;
     FILE *out;
     out = fopen("output.dec","w");
     i = 0;
     while (i < n) {
       if ((i/PAGE) % PAGE == 0) {
         fprintf(stderr,"%ld \r",i/PAGE);  fflush(stderr);
       }
       m = PAGE;
       if (i+m >= n) m = n-i;
       csa.text(buf,&csa,i,i+m-1);
       fwrite(buf,1,m,out);
       i += m;
     }
     fwrite(buf,1,0,out);
     fclose(out);
   }
   mygettime(&after);
   t = mylaptime(&before,&after);
   fprintf(stderr,"time %f sec\n",t);
   return 0;
}
Example #2
0
static int
run(int validate_utf8)
{
    long long times = 0; 
    double starttime;
    unsigned long long sumsize = 0;

    starttime = mygettime();

    /* allocate a parser */
    for (;;) {
		int i;
        {
            double now = mygettime();
            if (now - starttime >= PARSE_TIME_SECS) break;
        }

        for (i = 0; i < 100; i++) {
            yajl_handle hand = yajl_alloc(NULL, NULL, NULL);
            yajl_status stat;        
            const char ** d;

            yajl_config(hand, yajl_dont_validate_strings, validate_utf8 ? 0 : 1);

            for (d = get_doc(times % num_docs()); *d; d++) {
                size_t size = strlen(*d);
                sumsize += size;
                stat = yajl_parse(hand, (unsigned char *) *d, size);
                if (stat != yajl_status_ok) break;
            }
            
            stat = yajl_complete_parse(hand);

            if (stat != yajl_status_ok) {
                unsigned char * str =
                    yajl_get_error(hand, 1,
                                   (unsigned char *) *d,
                                   (*d ? strlen(*d) : 0));
                fprintf(stderr, "%s", (const char *) str);
                yajl_free_error(hand, str);
                return 1;
            }
            yajl_free(hand);
            times++;
        }
    }

    /* parsed doc 'times' times */
    {
        double throughput;
        double now;
        const char * all_units[] = { "B/s", "KB/s", "MB/s", (char *) 0 };
        const char ** units = all_units;

        now = mygettime();

        throughput = sumsize / (now - starttime);
        
        while (*(units + 1) && throughput > 1024) {
            throughput /= 1024;
            units++;
        }
        
        printf("Parsing speed: %g %s\n", throughput, *units);
    }

    return 0;
}
Example #3
0
void test_approxsearch(CSA *SA)
{
   long i,n_pos;
   int keylen;
   double t, t1, t2;
   unsigned char key[4096];
   char *buf,*c_ptr;
   mytimestruct before,after;
   approx_list *list, *list0;
   int max_error;

   while (!feof(stdin)) {
#if 1
      printf("\ninput error len pos ");  fflush(stdout);
      scanf(" %d %d %ld",&max_error, &keylen, &i);
//      i = rand() % (SA->n-keylen-1) + 1;
      SA->substring(key, SA, i, keylen);
//      i = 200000;
      printf("error = %d len = %d pos = %ld\n", max_error, keylen, i);
      SA->text(key,SA,i,i+keylen-1);
      key[keylen] = 0;
      printf("key %s\n",key);
#endif
#if 0
      printf("\ninput key error ");  fflush(stdout);
      scanf(" %s %d",key, &max_error);
      keylen = strlen(key);
      for (i=0; i<keylen; i++) key[i] = tolower(key[i]);
      printf("key %s\n",key);
#endif
#if 1
      mygettime(&before);
      list = csa_approxsearch(key, keylen, max_error, SA);
      mygettime(&after);
      t1 = mylaptime(&before,&after);
      printf("search1 %f sec\n",t1);
      approx_list_print(SA, list, key, keylen);
#endif
#if 1
      mygettime(&before);
      list0 = csa_approxsearch2(key, keylen, max_error, SA);
      mygettime(&after);
      t2 = mylaptime(&before,&after);
//      approx_list_print(SA, list0, key, keylen);
      printf("search2 %f sec\n",t2);
#endif
#if 0
  if (list0->num != list->num) {
    printf("list0 %d list %d\n", list0->num, list->num);
  }
  for (i=0; i<list0->num && i<list->num; i++) {
    approx_set *p0, *p;
    p0 = &list0->p[i];  p = & list->p[i];
    if (p0->error != p->error || p0->len != p->len || p0->l != p->l || p0->r != p->r) {
      printf("list0 error = %d len = %d [%ld,%ld]\n", p0->error, p0->len, p0->l, p0->r);
      approx_set_print(SA, p0, key, keylen);
      printf("list  error = %d len = %d [%ld,%ld]\n", p->error, p->len, p->l, p->r);
      approx_set_print(SA, p, key, keylen);
    }
  }
  if (list0->num > list->num) {
    approx_set *p0;
    for (i=list->num; i<list0->num; i++) {
      p0 = &list0->p[i];
      printf("list0[%d] error = %d len = %d [%ld,%ld]\n", i, p0->error, p0->len, p0->l, p0->r);
      approx_set_print(SA, &list0->p[i], key, keylen);
    }
  }
  if (list0->num < list->num) {
    approx_set *p;
    for (i=list0->num; i<list->num; i++) {
      p = &list->p[i];
      printf("list[%d] error = %d len = %d [%ld,%ld]\n", i, p->error, p->len, p->l, p->r);
      approx_set_print(SA, &list->p[i], key, keylen);
    }
  }
#endif


//      printf("search results\n");
//      approx_list_print(SA, list, key, keylen);

//      approx_list_free(list);
      //break;
   }
}