C++ (Cpp) basicsort примеры использования

Пример #1

Файл: multisort-omp-dependencies.c Проект: AlbertSuarez/PAR-Labs

void multisort(long n, T data[n], T tmp[n]) {
    if (n >= MIN_SORT_SIZE*4L) {
        // Recursive decomposition
        
        #pragma omp task depend(out:data[0:n/4L])
        multisort(n/4L, &data[0], &tmp[0]);
        
        #pragma omp task depend(out:data[n/4L:n/4L])
        multisort(n/4L, &data[n/4L], &tmp[n/4L]);
        
        #pragma omp task depend(out:data[n/2L:n/4L])
        multisort(n/4L, &data[n/2L], &tmp[n/2L]);
        
        #pragma omp task depend(out:data[3L*n/4L:n/4L])
        multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);

        
        
        #pragma omp task depend(in:data[0:n/4L], data[n/4L:n/4L]) depend(out:tmp[0:n/2L])
        merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);
            
        #pragma omp task depend(in:data[n/2L:n/4L], data[3L*n/4L:n/4L]) depend(out:tmp[n/2L:n/2L])
        merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);
        
        #pragma omp task depend(in:tmp[0:n/2L], tmp[n/2L:n/2L])
        merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);
        
        #pragma omp taskwait
        
    } else {
        // Base case
        basicsort(n, data);
    }
}

Пример #2

Файл: multisort.c Проект: mfarrera/ompss-tests

void multisort(long n, T data[n], T tmp[n])
{
	if (n >= MIN_SORT_SIZE*4L) {
		// Recursive decomposition
		#pragma omp task 
		multisort(n/4L, &data[0], &tmp[0]);
		#pragma omp task 
		multisort(n/4L, &data[n/4L], &tmp[n/4L]);
		#pragma omp task 
		multisort(n/4L, &data[n/2L], &tmp[n/2L]);
		#pragma omp task 
		multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);


		#pragma omp task 
		merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);
		#pragma omp task 
		merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);
		

		#pragma omp task 
		merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);
	} else {
		// Base case
		basicsort(n, data);
	}
}

Пример #3

Файл: multisort-tareador.c Проект: Fibernalia/PAR

void multisort(long n, T data[n], T tmp[n]) {
       
        if (n >= MIN_SORT_SIZE*4L) {
                // Recursive decomposition

	        tareador_start_task("RecursiveMultisort");
	       
                multisort(n/4L, &data[0], &tmp[0]);

                multisort(n/4L, &data[n/4L], &tmp[n/4L]);

                multisort(n/4L, &data[n/2L], &tmp[n/2L]);

                multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);

                merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);
                merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);

                merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);

	        tareador_end_task("RecursiveMultisort");;

	} else {
		// Base case
                tareador_start_task("BaseCaseMultisort");
		basicsort(n, data);
                tareador_end_task("BaseCaseMultisort");
	}

}

Пример #4

Файл: multisort-omp-task-dependence-tree.c Проект: AlbertSuarez/PAR-Labs

void multisort(long n, T data[n], T tmp[n]) {
        if (n >= MIN_SORT_SIZE*4L) {
                // Recursive decomposition


		#pragma omp task depend(out: data[0:n/4L])
                multisort(n/4L, &data[0], &tmp[0]);
		#pragma omp task depend(out: data[n/4L:n/4L])
                multisort(n/4L, &data[n/4L], &tmp[n/4L]);
		#pragma omp task depend(out: data[n/2L:n/4L])
                multisort(n/4L, &data[n/2L], &tmp[n/2L]);
		#pragma omp task depend(out: data[3L*n/4L:n/4L])
                multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);

		#pragma omp task depend(in: data[0:n/4L], data[n/4L:n/4L]) depend(out: tmp[0:n/2L])
                merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);
		#pragma omp task depend(in: data[n/2L:n/4L], data[3L*n/4L:n/4L]) depend(out: tmp[n/2L:n/2L])
                merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);

		#pragma omp task depend(in: tmp[0:n/2L], tmp[n/2L:n/2L])
                merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);
		#pragma omp taskwait
	} else {
		// Base case
#if _EXTRAE_
		Extrae_event(PROGRAM, SORT);
#endif
		basicsort(n, data);
#if _EXTRAE_
		Extrae_event(PROGRAM, END);
#endif
	}
}

Пример #5

Файл: success_regions_04.c Проект: yundantianchang/AutomaticParallelization

void multisort(long n, T data[n], T tmp[n]) {
	if (n >= MIN_SORT_SIZE*4L) {
		// Recursive decomposition
		multisort(n/4L, (T *) &data[0], (T *) &tmp[0]);
		multisort(n/4L, (T *) &data[n/4L], (T *) &tmp[n/4L]);
		multisort(n/4L, (T *) &data[n/2L], (T *) &tmp[n/2L]);
		multisort(n/4L, (T *) &data[3L*n/4L], (T *) &tmp[3L*n/4L]);   
        
		merge_rec(n/4L, (T *) &data[0], (T *) &data[n/4L], (T *) &tmp[0], 0, n/2L);
		merge_rec(n/4L, (T *) &data[n/2L], (T *) &data[3L*n/4L], (T *) &tmp[n/2L], 0, n/2L);
        
		merge_rec(n/2L, (T *) &tmp[0], (T *) &tmp[n/2L], (T *) &data[0], 0, n);
        
    } else {
		// base case
		basicsort(n, (T *) &data[0]);
    }
}

Пример #6

Файл: multisort-omp-task-tree.c Проект: AlbertSuarez/PAR-Labs

void multisort(long n, T data[n], T tmp[n]) {
        if (n >= MIN_SORT_SIZE*4L) {
                // Recursive decomposition

		#pragma omp taskgroup
		{
		#pragma omp task
                multisort(n/4L, &data[0], &tmp[0]);
		#pragma omp task
                multisort(n/4L, &data[n/4L], &tmp[n/4L]);
		#pragma omp task
                multisort(n/4L, &data[n/2L], &tmp[n/2L]);
		#pragma omp task
                multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);
		}

		#pragma omp taskgroup
		{
		#pragma omp task
                merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);
		#pragma omp task
                merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);
		}

                merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);
	} else {
		// Base case
#if _EXTRAE_
		Extrae_event(PROGRAM, SORT);
#endif
		basicsort(n, data);
#if _EXTRAE_
		Extrae_event(PROGRAM, END);
#endif
	}
}

Пример #7

Файл: multisort.c Проект: CristianDavila/Par

void multisort(long n, T data[n], T tmp[n]) {       
 if (n >= MIN_SORT_SIZE*4L) {
                // Recursive decomposition

		// Una tasca de tareador por cada llamada
#if _TAREADOR_
		tareador_start_task("multisort1");
#endif
                multisort(n/4L, &data[0], &tmp[0]);
#if _TAREADOR_
		tareador_end_task();
		tareador_start_task("multisort2");
#endif
                multisort(n/4L, &data[n/4L], &tmp[n/4L]);
#if _TAREADOR_
		tareador_end_task();
		tareador_start_task("multisort3");
#endif
                multisort(n/4L, &data[n/2L], &tmp[n/2L]);

#if _TAREADOR_
		tareador_end_task();
		tareador_start_task("multisort4");
#endif
                multisort(n/4L, &data[3L*n/4L], &tmp[3L*n/4L]);
#if _TAREADOR_
		tareador_end_task();
		tareador_start_task("merge1");
#endif
                merge(n/4L, &data[0], &data[n/4L], &tmp[0], 0, n/2L);

#if _TAREADOR_
                tareador_end_task();
                tareador_start_task("merge2");    
#endif
                merge(n/4L, &data[n/2L], &data[3L*n/4L], &tmp[n/2L], 0, n/2L);
#if _TAREADOR_
                tareador_end_task();
                tareador_start_task("merge3");    
#endif
                merge(n/2L, &tmp[0], &tmp[n/2L], &data[0], 0, n);
#if _TAREADOR_
                tareador_end_task();    
#endif

	} else {
		// Base case
#if _EXTRAE_
		Extrae_event(PROGRAM, SORT);
#endif
#if _TAREADOR_
		tareador_start_task("basesort");
#endif
		basicsort(n, data);
#if _TAREADOR_
		tareador_end_task();
#endif
#if _EXTRAE_
		Extrae_event(PROGRAM, END);
#endif
	}
}