예제 #1
0
파일: limit.c 프로젝트: shalstvedt/frozen
void        limit_machine_action(machine_t *machine, rule *rule){ // {{{
	limit_userdata        *userdata          = (limit_userdata *)machine->userdata;
	
	switch(rule->action){
		case ACTION_DESTROY:;
			// set machine mode to died
			limit_set_handler(machine, &limit_machine_request_died);
			
			if(userdata->perfork_childs != &userdata->perfork_childs_own){
				// kill childs for forked shops, keep for initial
				pipeline_destroy(machine->cnext);
			}
			
			break;
		case ACTION_REQUEST:;
			machine_pass(machine, rule->action_request);
			break;
		default:
			break;
	};
	
	// update parameter
	userdata->usage_parameter = limit_parameter_get(machine, userdata);
} // }}}
예제 #2
0
파일: read.c 프로젝트: digideskio/bwa
void pixz_read(bool verify, size_t nspecs, char **specs) {
    decode_index();
    if (verify)
        gFileIndexOffset = read_file_index(0);
    wanted_files(nspecs, specs);
    set_block_sizes();

#if DEBUG
    for (wanted_t *w = gWantedFiles; w; w = w->next)
        debug("want: %s", w->name);
#endif
    
    pipeline_create(block_create, block_free, read_thread, decode_thread);
    if (verify && gFileIndexOffset) {
        gArWanted = gWantedFiles;
        wanted_t *w = gWantedFiles, *wlast = NULL;
        bool lastmulti = false;
        off_t lastoff = 0;
        
        struct archive *ar = archive_read_new();
        archive_read_support_compression_none(ar);
        archive_read_support_format_tar(ar);
        archive_read_open(ar, NULL, tar_ok, tar_read, tar_ok);
        struct archive_entry *entry;
        while (true) {
            int aerr = archive_read_next_header(ar, &entry);
            if (aerr == ARCHIVE_EOF) {
                break;
            } else if (aerr != ARCHIVE_OK && aerr != ARCHIVE_WARN) {
                fprintf(stderr, "%s\n", archive_error_string(ar));
                die("Error reading archive entry");
            }
            
            off_t off = archive_read_header_position(ar);
            const char *path = archive_entry_pathname(entry);
            if (!lastmulti) {
                if (wlast && wlast->size != off - lastoff)
                    die("Index and archive show differing sizes for %s: %d vs %d",
                        wlast->name, wlast->size, off - lastoff);
                lastoff = off;
            }
            
            lastmulti = is_multi_header(path);
            if (lastmulti)
                continue;
            
            if (!w)
                die("File %s missing in index", path);
            if (strcmp(path, w->name) != 0)
                die("Index and archive differ as to next file: %s vs %s",
                    w->name, path);
            
            wlast = w;
            w = w->next;
        }
        if (w && w->name)
            die("File %s missing in archive", w->name);
        tar_write_last(); // write whatever's left
    } else {
        pipeline_item_t *pi;
        while ((pi = pipeline_merged())) {
            io_block_t *ib = (io_block_t*)(pi->data);
            fwrite(ib->output, ib->outsize, 1, gOutFile);
            queue_push(gPipelineStartQ, PIPELINE_ITEM, pi);
        }
    }
    
    pipeline_destroy();
    wanted_free(gWantedFiles);
}
예제 #3
0
파일: machine_t.c 프로젝트: samuell/frozen
static ssize_t data_machine_t_free(data_t *data, fastcall_free *fargs){ // {{{
	if(data->ptr)
		pipeline_destroy((machine_t *)data->ptr);
	return 0;
} // }}}
예제 #4
0
파일: read.c 프로젝트: blue119/pixz
void pixz_read(bool verify, size_t nspecs, char **specs) {
    if (decode_index()) {
	    if (verify)
	        gFileIndexOffset = read_file_index();
	    wanted_files(nspecs, specs);
		gExplicitFiles = nspecs;
    }

#if DEBUG
    for (wanted_t *w = gWantedFiles; w; w = w->next)
        debug("want: %s", w->name);
#endif
    
    pipeline_create(block_create, block_free,
		gIndex ? read_thread : read_thread_noindex, decode_thread);
    if (verify && gFileIndexOffset) {
        gArWanted = gWantedFiles;
        wanted_t *w = gWantedFiles, *wlast = NULL;
        bool lastmulti = false;
        off_t lastoff = 0;
        
        struct archive *ar = archive_read_new();
        archive_read_support_compression_none(ar);
        archive_read_support_format_tar(ar);
        archive_read_open(ar, NULL, tar_ok, tar_read, tar_ok);
        struct archive_entry *entry;
        while (true) {
            int aerr = archive_read_next_header(ar, &entry);
            if (aerr == ARCHIVE_EOF) {
                break;
            } else if (aerr != ARCHIVE_OK && aerr != ARCHIVE_WARN) {
                fprintf(stderr, "%s\n", archive_error_string(ar));
                die("Error reading archive entry");
            }
            
            off_t off = archive_read_header_position(ar);
            const char *path = archive_entry_pathname(entry);
            if (!lastmulti) {
                if (wlast && wlast->size != off - lastoff)
                    die("Index and archive show differing sizes for %s: %d vs %d",
                        wlast->name, wlast->size, off - lastoff);
                lastoff = off;
            }
            
            lastmulti = is_multi_header(path);
            if (lastmulti)
                continue;
            
            if (!w)
                die("File %s missing in index", path);
            if (strcmp(path, w->name) != 0)
                die("Index and archive differ as to next file: %s vs %s",
                    w->name, path);
            
            wlast = w;
            w = w->next;
        }
		archive_read_finish(ar);
        if (w && w->name)
            die("File %s missing in archive", w->name);
        tar_write_last(); // write whatever's left
    }
	if (!gExplicitFiles) {
		/* Heuristics for detecting pixz file index:
		 *    - Input must be streaming (otherwise read_thread does this) 
		 *    - Data must look tar-like
		 *    - Must have all sized blocks, followed by unsized file index */
		bool start = !gIndex && verify,
			 tar = false, all_sized = true, skipping = false;
		
		pipeline_item_t *pi;
        while ((pi = pipeline_merged())) {
            io_block_t *ib = (io_block_t*)(pi->data);
			if (skipping && ib->btype != BLOCK_CONTINUATION) {
				fprintf(stderr,
					"Warning: File index heuristic failed, use -t flag.\n");
				skipping = false;
			}
			if (!skipping && tar && !start && all_sized
					&& ib->btype == BLOCK_UNSIZED && taste_file_index(ib))
				skipping = true;
			if (start) {
				tar = taste_tar(ib);
				start = false;
			}
			if (ib->btype == BLOCK_UNSIZED)
				all_sized = false;
			
			if (!skipping)
				fwrite(ib->output, ib->outsize, 1, gOutFile);
            queue_push(gPipelineStartQ, PIPELINE_ITEM, pi);
        }
    }
    
    pipeline_destroy();
    wanted_free(gWantedFiles);
}
예제 #5
0
int
main(int argc, char **argv)
{
  pipeline_t                *pl;
  char                       line[1024];
  int                        n;
  int                        i;
  int                        stages;
  pipeline_stage_process_pf *stages_proc;
  int                        max_random;
  struct timeval             start;
  struct timeval             end;
  int                        start_num = 0;

  stages = atoi(argv[1]);
  max_random = atoi(argv[2]);
  if (argc == 4) {
    start_num = atoi(argv[3]);
    if (start_num <= 0) {
      printf("    usage: test_pipeline <stage_num> <max_random> [start_num]\n");
      return 1;
    }
  }

  if (stages<1 || max_random<1) {
    printf("    usage: test_pipeline <stage_num> <max_random> [start_num]\n");
    return 1;
  }

  stages_proc = malloc(stages * sizeof(pipeline_stage_process_pf));

  for (i = 0; i < stages-1; ++i)
    stages_proc[i] = _stage;
  stages_proc[stages-1] = _stage_tail;

  pl = pipeline_create(stages, stages_proc);
  free(stages_proc);

  if (start_num == 0)
    printf("input an integer, and end with a command named 'q'\n");

  while (1) {
    if (start_num == 0) {
      printf("data> ");
      if (fgets(line, sizeof(line), stdin) == NULL)
        break;

      line[strlen(line)-1] = 0;
      if (strcmp(line, "q") == 0)
        break;

      if (sscanf(line, "%d", &n) != 1) {
        printf("please input valid integer\n");
        continue;
      }
    }

//    int num = random() % max_random;
    g_random_count += max_random;

    gettimeofday(&start, NULL);

    for (i = max_random; i > 0; --i)
      pipeline_start(pl, (void *) (long) (n + i));

    pipeline_wait(pl, 0);

    gettimeofday(&end, NULL);
    test_time("pipeline", &start, &end);
    if (start_num != 0)
      break;
  }

  printf("\n\n---------------count is: %d[%d]\n\n", g_count, g_random_count);
  assert(g_count == g_random_count);

  pipeline_wait(pl, 1);
  pipeline_destroy(pl);
  return EXIT_SUCCESS;
}