Пример #1
0
Файл: sosh.c Проект: gapry/AOS
static int
benchmark2() {
    char buf3200000[3200000];
    bm_read("read_test_3200000_1", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_1", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_2", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_2", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_3", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_3", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_4", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_4", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_5", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_5", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_6", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_6", (char*)buf3200000, 3200000);

    bm_read("read_test_3200000_7", (char*)buf3200000, 3200000);
    bm_write("write_test_3200000_7", (char*)buf3200000, 3200000);
    return 0;
}
Пример #2
0
Файл: sosh.c Проект: gapry/AOS
static int
benchmark(){
    /* Reads */
    printf("Reading\n");
    /* Reading with IO request changing*/
    printf("Reading with IO request changing\n");
    char buf1000[1001];
    char buf5000[5001];
    char buf10000[10000];
    char buf50000[50000];
    char buf100000[100000];
    char buf200000[200000];
    char buf400000[400000];
    char buf800000[800000];
    char buf1600000[1600000];
    char buf3200000[3200000];
    char buf100000_2[100000];
    char buf200000_2[200000];
    char buf400000_2[400000];
    bm_read("read_test_1000", (char*)buf1000,1000);
    bm_write("write_test_1000", (char*)buf1000,1000);

    bm_read("read_test_5000", (char*)buf5000,5000);
    bm_write("write_test_5000", (char*)buf5000,5000);

    bm_read("read_test_10000", (char*)buf10000,10000);
    bm_write("write_test_10000", (char*)buf10000,10000);

    bm_read("read_test_50000", (char*)buf50000,50000);
    bm_write("write_test_50000", (char*)buf50000,50000);

    bm_read("read_test_100000", (char*)buf100000,100000);
    bm_write("write_test_100000", (char*)buf100000,100000);

    bm_read("read_test_200000", (char*)buf200000,200000);
    bm_write("write_test_200000", (char*)buf200000,200000);

    bm_read("read_test_400000", (char*)buf400000,400000);
    bm_write("write_test_400000", (char*)buf400000,400000);

    bm_read("read_test_800000", (char*)buf800000,800000);
    bm_write("write_test_800000", (char*)buf800000,800000);

    bm_read("read_test_1600000", (char*)buf1600000,1600000);
    bm_write("write_test_1600000", (char*)buf1600000, 1600000);

    bm_read("read_test_3200000", (char*)buf3200000,3200000);
    bm_write("write_test_3200000", (char*)buf3200000, 3200000);

    bm_read("read_test_100000", (char*)buf100000_2,100000);
    bm_write("write_test_100000_2", (char*)buf100000_2,100000);

    bm_read("read_test_200000", (char*)buf200000_2,200000);
    bm_write("write_test_200000_2", (char*)buf200000_2,200000);

    bm_read("read_test_400000", (char*)buf400000_2,400000);
    bm_write("write_test_400000_2", (char*)buf400000_2,400000);

    /* Reading with packet changing */

    /* Writes */
    printf("Writing\n");
    /* Writing with IO request changing*/
    /* Writing with packet changing */
    return 0;
}
Пример #3
0
static void process_file(backend_t *b, const char *infile, const char *outfile, FILE *fin, FILE *fout) { 
  int r; 
  potrace_bitmap_t *bm = NULL; 
  imginfo_t imginfo;
  int eof_flag = 0;  /* to indicate premature eof */
  int count;         /* number of bitmaps successfully processed, this file */
  potrace_state_t *st;

  for (count=0; ; count++) {
    /* read a bitmap */
    r = bm_read(fin, info.blacklevel, &bm);
    switch (r) {
    case -1:  /* system error */
      fprintf(stderr, ""POTRACE": %s: %s\n", infile, strerror(errno));
      exit(2);
    case -2:  /* corrupt file format */
      fprintf(stderr, ""POTRACE": %s: file format error: %s\n", infile, bm_read_error);
      exit(2);
    case -3:  /* empty file */
      if (count>0) {  /* end of file */
	return;
      }
      fprintf(stderr, ""POTRACE": %s: empty file\n", infile);
      exit(2);
    case -4:  /* wrong magic */
      if (count>0) { 
	fprintf(stderr, ""POTRACE": %s: warning: junk at end of file\n", infile);
	return;
      }
      fprintf(stderr, ""POTRACE": %s: file format not recognized\n", infile);
      fprintf(stderr, "Possible input file formats are: pnm (pbm, pgm, ppm), bmp.\n");
      exit(2);
    case 1:  /* unexpected end of file */
      fprintf(stderr, ""POTRACE": warning: %s: premature end of file\n", infile);
      eof_flag = 1;
      break;
    }

    /* prepare progress bar, if requested */
    if (info.progress) {
      r = info.progress_bar->init(&info.param->progress, infile, count);
      if (r) {
	fprintf(stderr, ""POTRACE": %s\n", strerror(errno));
	exit(2);
      }
    } else {
      info.param->progress.callback = NULL;
    }

    if (info.invert) {
      bm_invert(bm);
    }

    /* process the image */
    st = potrace_trace(info.param, bm);
    if (!st || st->status != POTRACE_STATUS_OK) {
      fprintf(stderr, ""POTRACE": %s: %s\n", infile, strerror(errno));
      exit(2);
    }

    /* calculate image dimensions */
    imginfo.pixwidth = bm->w;
    imginfo.pixheight = bm->h;
    bm_free(bm);

    calc_dimensions(&imginfo, st->plist);

    r = b->page_f(fout, st->plist, &imginfo);
    if (r) {
      fprintf(stderr, ""POTRACE": %s: %s\n", outfile, strerror(errno));
      exit(2);
    }

    potrace_state_free(st);

    if (info.progress) {
      info.progress_bar->term(&info.param->progress);
    }

    if (eof_flag || !b->multi) {
      return;
    }
  }
  /* not reached */
}