예제 #1
0
DEF_TEST(Sort, reporter) {
    /** An array of random numbers to be sorted. */
    int randomArray[500];
    /** The reference sort of the random numbers. */
    int sortedArray[SK_ARRAY_COUNT(randomArray)];
    /** The random numbers are copied into this array, sorted by an SkSort,
        then this array is compared against the reference sort. */
    int workingArray[SK_ARRAY_COUNT(randomArray)];
    SkRandom    rand;

    for (int i = 0; i < 10000; i++) {
        int count = rand.nextRangeU(1, SK_ARRAY_COUNT(randomArray));
        rand_array(rand, randomArray, count);

        // Use qsort as the reference sort.
        memcpy(sortedArray, randomArray, sizeof(randomArray));
        qsort(sortedArray, count, sizeof(sortedArray[0]), compare_int);

        memcpy(workingArray, randomArray, sizeof(randomArray));
        SkTHeapSort<int>(workingArray, count);
        check_sort(reporter, "Heap", workingArray, sortedArray, count);

        memcpy(workingArray, randomArray, sizeof(randomArray));
        SkTQSort<int>(workingArray, workingArray + count - 1);
        check_sort(reporter, "Quick", workingArray, sortedArray, count);
    }
}
예제 #2
0
int main(void) {
  scheduler_begin();

  struct array * A = rand_array(1000000);
  seq_threshold = 100;

  printf("before sort: %s\n", check_sort(A));
  par_mergesort(A);
  printf("after sort: %s\n", check_sort(A));

  scheduler_end();
  return 0;
}
예제 #3
0
extern "C" void _start (
    )
{
    int length = sizeof(global_arr) / sizeof(int);

    heapify(global_arr, length);
    sort(global_arr, length);

    for (int i = 0; i < TEST_ARRAY_SIZE; i++) {
        test_array[i] = TEST_ARRAY_SIZE - i;
    }

    heapify(test_array, TEST_ARRAY_SIZE);
    sort(test_array, TEST_ARRAY_SIZE);

    _exit(check_sort(global_arr, length) && check_sort(test_array, TEST_ARRAY_SIZE) ? 0 : -1);
}
예제 #4
0
extern "C" void _start (
    )
{
    int array[] = {499, -688, -758, -871, -30, 37, -844, 99, -637, -24, 1, -813, -289, 719, 477, 579, -212, -250, 790, -620, 298, -358, 296, 354, 165, 840, 85, -818, 435, 959, 637, 389, 441, 528, 172, -735, -605, -264, -863, 425, -451, 985, 248, 233, -581, 472, 761, 939, 41, -152, 739, 603, -313, -97, -863, -649, -866, 733, 767, -771, -271, -905, -778, 302, 431, -680, 824, -779, -590, 531, 248, -811, 118, 213, 140, -343, 626, -140, 183, -218, 879, -101, -463, 413, -677, 357, 444, -361, -271, 653, -695, 938, -582, -800, 752, -887, -584, 692, 561, 665, 120, -41, 894, 134, 767, -585, -2, -548, -827, -670, 420, -334, -465, 667, 398, -940, 240, 144, 918, -467, 504, -645, 831, 929, -661, 551, 949, 960, 340, 330, 678, 492, -295, 527, -879, 814, -503, 824, -886, 104, -665, 511, 535, -170, 798, 157, 347, -130, 418, -902, -428, 134, 619, 986, 263, -655, -504, 343, -948, -810, -282, 899, 361, 288, 241, 308, 688, 984, -345, 766, -51};
    int* aux_array;
    int length = sizeof(array) / sizeof(int);

    aux_array = new int[((sizeof(array) / sizeof(int)) / 2 + 1)];
    if (!aux_array) {
        _exit(-1);
    }

    sort(array, length, aux_array);

    _exit(check_sort(array, length) ? 0 : -1);
}
예제 #5
0
파일: algo.c 프로젝트: Galathorn/Project
void			basic_sort(t_box *box)
{
	while (box->size_a != 0)
	{
		box->locat = little_number(A, box->size_a, &box->val_min);
		if (A[0] > A[1] && A[1] < A[2])
			swap_a(box);
		if (check_sort(A, box->size_a))
			break ;
		if (box->locat < (box->size / 2))
			while (A[0] != box->val_min)
				rot_a(box);
		else
			while (A[0] != box->val_min)
				revrot_a(box);
		push_b(box);
	}
	while (box->size_b != 0)
		push_a(box);
}
예제 #6
0
파일: algo.c 프로젝트: Galathorn/Project
void			test_sort(t_box *box)
{
	if (A[0] > A[1] && A[1] > A[2])
	{
		rot_a(box);
		swap_a(box);
	}
	else if (A[0] > A[1] && A[1] < A[2])
		swap_a(box);
	if (A[box->size - 2] > A[box->size - 1])
	{
		revrot_a(box);
		revrot_a(box);
		swap_a(box);
		rot_a(box);
		rot_a(box);
	}
	else if (A[0] > A[1] && !(check_sort(A, box->size)))
		rot_a(box);
}
예제 #7
0
파일: ra.c 프로젝트: finet-f/git
int	*ra(int *l_a, int k, int kb)
{
  int	tmp;
  int	i;
  int	j;

  tmp = l_a[0];
  i = 1;
  j = 0;
  while (i < k)
    {
      l_a[j] = l_a[i];
      i++;
      j++;
    }
  l_a[j] = tmp;
  my_printf("ra");
  if (check_sort(l_a, k) != 1 || kb != 0)
    my_putchar(' ');
  return (l_a);
}
예제 #8
0
파일: algo.c 프로젝트: Galathorn/Project
void			pre_sort(t_box *box)
{
	int		error;
	int		locat;

	error = amount_error(box, &locat);
	if (error == 0)
		return ;
	if (A[0] > A[1] && locat == 0 && A[box->size - 2] > A[box->size - 1])
		swap_a(box);
	else if (locat >= (box->size / 2) && error == 1)
		test_sort(box);
	else if (A[0] > A[1] && error == 1)
		test_sort(box);
	else if (box->size <= 3)
		test_sort(box);
	if (!(check_sort(A, box->size)))
		basic_sort(box);
	if (box->b_op == 1)
		print_nbop(box);
}
예제 #9
0
 void operator()(var * n) { 
     if (!m_quantifiers)
         fail("logic does not support quantifiers");
     check_sort(m.get_sort(n));
 }
예제 #10
0
파일: tris.c 프로젝트: acekat/PPAR
int main(int argc, char* argv[])
{
	if (argc != 3) {
		fprintf(stderr, "%s\n", usage);
		return 0;
	}

	/* Initialisation */
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
	MPI_Comm_size(MPI_COMM_WORLD, &nb_proc);
	
	MPI_Status  status;

	int nb_elem = atoi(argv[1]);	// nombre d'éléments total
	int sort_type = atoi(argv[2]);	// type de l'algorithme de tri

	k = nb_elem / nb_proc;

	int *tab_sort = (int *)malloc(k*sizeof(int));
	int *tab_tmp = (int *)malloc(k*sizeof(int));
	
	if ((tab_tmp == NULL) || (tab_sort == NULL)) {
		fprintf(stderr, "Erreur allocation mémoire du tableau \n");
		MPI_Finalize();
		exit(1);
	}

	int left = my_rank-1;
	int right = my_rank+1;

	// initialise le tableau local
	P0 printf("Initialisation du tableau...");
	switch (sort_type) {
		case 1:	
		case 2: init_rand(tab_tmp, k); break;
		case 3:
		case 4:
		case 5: init_rand(tab_sort, k); break;
	}
	P0 printf(" OK!\n");

	P0 printf("Calcul...\n");

	// début du chronométrage
	double start, end;
	start = MPI_Wtime();
	
	// choix de l'algorithme de tri
	switch (sort_type) {
		case 1: PRAM(tab_tmp, tab_sort); break;
		case 2: PRAM_omp(tab_tmp, tab_sort); break;
		case 3: quick_sort(tab_sort, k); break;
		case 4: quick_sort_omp(tab_sort, k); break;
		case 5: qsort(tab_sort, k, sizeof(int), compare); break;
	}

	// tri pair-impair
	int step;
	for (step = 0; step < nb_proc; step++) {
		if ((my_rank%2) - (step%2) == 0) {
			if (my_rank != nb_proc-1) {
				MPI_Recv(tab_tmp, k, MPI_INT, right, TAG_TAB, MPI_COMM_WORLD, &status);
				merge_sort(tab_sort, tab_tmp);
				MPI_Send(tab_tmp, k, MPI_INT, right, TAG_TAB, MPI_COMM_WORLD);
			}
		}
		else {
			if (my_rank != 0) {
				MPI_Send(tab_sort, k, MPI_INT, left, TAG_TAB, MPI_COMM_WORLD);
				MPI_Recv(tab_sort, k, MPI_INT, left, TAG_TAB, MPI_COMM_WORLD, &status);
			}
		}
	}
	
	// fin du chronométrage
	end = MPI_Wtime();

	print_results(end - start);

	// écriture dans le fichier 	
	if (nb_elem <= NMAX) {
		P0 printf("Ecriture du fichier...");

		MPI_File file; 
		MPI_Offset my_offset;
		char filename[strlen("/Vrac/ppar_cassat_ducamain_sort")+1];
		strcpy(filename, "/Vrac/ppar_cassat_ducamain_sort");	

		my_offset = my_rank * sizeof(int) * k;
		MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE | MPI_MODE_RDWR, MPI_INFO_NULL, &file);
		MPI_File_write_at(file, my_offset, tab_sort, k, MPI_INT, &status);
		// printf("(%d) a écrit: ", my_rank);
		// print_tab(tab_sort, k);
		
		// attends que tous aient écrit
		MPI_Barrier(MPI_COMM_WORLD);
		
		MPI_File_read_ordered(file, tab_sort, k, MPI_INT, &status);
		MPI_File_close(&file);
		// printf("(%d) a lu: ", my_rank);
		// print_tab(tab_sort, k);

		P0 printf(" OK!\n");
	}

	// Vérification du tri
	P0 printf("Vérification du tri...\n");

	if (!check_sort(tab_sort, k) && (my_rank == 0))
		printf("\tTri correct!\n");

	#ifdef BENCH
	P0 fprintf(stderr, "\t%d\t%d\t%d", sort_type, nb_elem, nb_proc);

	#ifdef _OPENMP
	#pragma omp parallel
	{
		if ((my_rank == 0) && (omp_get_thread_num() == 0))
			fprintf(stderr, "\t%d", omp_get_num_threads());
	}
	#endif
	
	P0 fprintf(stderr, "\n");
	#endif 

	free(tab_sort);
	free(tab_tmp);

	/* Desactivation */
	MPI_Finalize();
	return 0;
}