int main (int argc, char* argv[]){
int nodecount, *num_in_links, *num_out_links;
int err = get_node_stat(&nodecount, &num_in_links, &num_out_links);
if (err != 0) {
return err;
}
node_t *nodehead;
err = node_init(&nodehead, num_in_links, num_out_links, 0, nodecount);
if (err != 0) {
return err;
}
double start, end;
GET_TIME(start);
double damp_const = (1.0 - DAMPING_FACTOR) / nodecount;
double *r = init_result_vector(nodecount, false);
double *r_pre = init_result_vector(nodecount, true);
page_rank(r, r_pre, num_out_links, num_in_links, nodecount, nodehead, damp_const);
free(r_pre);
GET_TIME(end);
double delay = end - start;
Lab4_saveoutput(r, nodecount, delay);
node_destroy(nodehead, nodecount);
free(num_in_links);
free(num_out_links);
free(r);
}
int main(int argc, char* argv[]) {
if (argc != 2)
fprintf(stderr, "Usage: Requires number of threads.");
thread_count = atoi(argv[1]);
Lab3LoadInput(&A, &size);
x = CreateVec(size);
double start, end;
int i = 0;
GET_TIME(start);
# pragma omp parallel num_threads(thread_count) \
shared(A)
{
gaussian_elimination();
jordan_elimination();
# pragma omp for
for (i = 0; i < size; ++i) {
x[i] = A[i][size] / A[i][i];
}
}
GET_TIME(end);
Lab3SaveOutput(x, size, end-start);
printf("time is: %e\n", end-start);
DestroyVec(x);
DestroyMat(A, size);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]){
int t; //result;
double inicio, fim, delta1; //delta2, delta3;
FILE *arquivo;
char nomeArquivo[100];
// Parte de Inicialização
GET_TIME(inicio);
//Validando e recebendo a entrada
if(argc < 2) {
printf("Use: %s <arquivo entrada>\n", argv[0]);
exit(EXIT_FAILURE);
}
arquivo =fopen("");
//Alocando memoria e inicializando o vetor da entrada
vet = malloc (sizeof(float) * tam);
if(vet==NULL) {
printf("--ERRO: malloc()\n"); exit(-1);
}
for(t=0; t<tam; t++) {
vet[t] = t;
}
GET_TIME(fim);
delta1 = fim - inicio;
/*int mat1[3][3]={{3,0,2},{9,1,7},{1,0,1}};
int mat2[3][3]={{1,0,-2},{-2,1,-3},{-1,0,3}};
int mat3[3][3];
int M1L=3, M2C=3;
for(linha=0; linha<M1L; linha++){
for(coluna=0; coluna<M2C; coluna++){
result=0;
for(i=0; i<M1L; i++) result+=mat1[linha][i]*mat2[i][coluna];
mat3[linha][coluna]=result;
}
}
for(linha=0; linha<M1L; linha++){
for(coluna=0; coluna<M2C; coluna++)
printf("%d ", mat3[linha][coluna]);
printf("\n");
}*/
printf("Tempo inicializacoes: %.8lf\n", delta1);
return 0;
}
int main(int argc, char* argv[]) {
pthread_t* thread_handles;
long thread;
double start, finish;
if (argc != 3) Usage(argv[0]);
thread_count = strtol(argv[1], NULL, 10);
n = strtol(argv[2], NULL, 10);
thread_handles = malloc(thread_count*sizeof(pthread_t));
sem_init(&my_semaphore, 0, 1);
GET_TIME(start);
for (thread = 0; thread < thread_count; thread++)
pthread_create(&thread_handles[thread], NULL, Lock_and_unlock,
(void*) thread);
for (thread = 0; thread < thread_count; thread++)
pthread_join(thread_handles[thread], NULL);
GET_TIME(finish);
printf("Total number of times my_semaphore was locked and unlocked: %d\n",
total);
printf("Elapsed time = %e seconds\n", finish-start);
sem_destroy(&my_semaphore);
free(thread_handles);
return 0;
} /* main */
/*--------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
long thread, i;
pthread_t* thread_handles;
double start, finish;
if (argc != 2)
Usage(argv[0]);
thread_count = strtol(argv[1], NULL, 10);
thread_handles = malloc (thread_count*sizeof(pthread_t));
for (i = 0; i < BARRIER_COUNT; i++)
barrier_thread_counts[i] = 0;
pthread_mutex_init(&barrier_mutex, NULL);
GET_TIME(start);
for (thread = 0; thread < thread_count; thread++)
pthread_create(&thread_handles[thread], NULL,
Thread_work, (void*) thread);
for (thread = 0; thread < thread_count; thread++) {
pthread_join(thread_handles[thread], NULL);
}
GET_TIME(finish);
printf("Elapsed time = %e seconds\n", finish - start);
pthread_mutex_destroy(&barrier_mutex);
free(thread_handles);
return 0;
} /* main */
int main(int argc, char* argv[])
{
long i;
int key, success, attempts;
pthread_t* thread_handles;
int inserts_in_main;
unsigned seed = 1;
double inicio, fin;
if (argc != 2) Usage(argv[0]);
thread_count = strtol(argv[1], NULL, 10);
Get_input(&inserts_in_main);
i = attempts = 0;
pthread_mutex_init(&head_mutex, NULL);
while ( i < inserts_in_main && attempts < 2*inserts_in_main )
{
key = my_rand(&seed) % MAX_KEY;
success = Insert(key);
attempts++;
if (success) i++;
}
printf("%ld keys insertadas\n", i);
# ifdef OUTPUT
printf("Antes de crear hilos, lista = \n");
Print();
printf("\n");
# endif
thread_handles = malloc(thread_count*sizeof(pthread_t));
pthread_mutex_init(&count_mutex, NULL);
GET_TIME(inicio);
for (i = 0; i < thread_count; i++)
pthread_create(&thread_handles[i], NULL, Thread_work, (void*) i);
for (i = 0; i < thread_count; i++)
pthread_join(thread_handles[i], NULL);
GET_TIME(fin);
printf("Tiempo de ejecución = %e segundos\n", fin - inicio);
printf("Total operaciones = %d\n", total_ops);
printf("Operaciones miembro = %d\n", total_miembro);
printf("Operaciones insertar = %d\n", total_insertar);
printf("Operaciones borrado = %d\n", total_borrado);
# ifdef OUTPUT
printf("Despues de terminar los hilos, lista = \n");
Print();
printf("\n");
# endif
Free_list();
pthread_mutex_destroy(&head_mutex);
pthread_mutex_destroy(&count_mutex);
free(thread_handles);
return 0;
}
void* Trapezoid( void* rank )
{
double start = 0.0;
double end = 0.0;
sem_wait( &sem_count );
if( counter != thread_count - 1 )
{
counter++;
sem_post( &sem_count );
sem_wait( &sem_barrier );
}
else
{
counter = 0;
sem_post( &sem_count );
long i;
for( i = 0; i < thread_count-1; i++ )
sem_post( &sem_barrier );
}
GET_TIME( start );
double h = (b-a) / n;
long my_rank = (long)rank;
long local_n = n / thread_count;
double local_a = a + my_rank * local_n * h;
double local_b = local_a + local_n * h;
double my_sum = ( F(local_a) + F(local_b) ) / 2.0;
long i;
for( i = 1; i < local_n; i++ )
{
double x;
x = local_a + i * h;
my_sum += F(x);
}
my_sum *= h;
GET_TIME( end );
double elapsed = end - start;
sem_wait( &sem_timer );
printf( "%2ld | Elapsed time = %e\n", my_rank, elapsed );
if( elapsed > max_elapsed )
max_elapsed = elapsed;
sem_post( &sem_timer );
sem_wait( &sem_sum );
printf( "Add from rank # %ld | my_sum = %10.6f\n", my_rank, my_sum );
sum += my_sum;
sem_post( &sem_sum );
return NULL;
}
/**
* Conversion function. They deal with data-types in 3 ways, always making local copies.
* In order to allow performance testings, there are 3 functions:
* - one copying directly from one memory location to another one using the
* data-type copy function.
* - one which use a 2 convertors created with the same data-type
* - and one using 2 convertors created from different data-types.
*
*/
static int local_copy_ddt_count( opal_datatype_t const * const pdt, int count )
{
OPAL_PTRDIFF_TYPE lb, extent;
size_t malloced_size;
char *odst, *osrc;
void *pdst, *psrc;
TIMER_DATA_TYPE start, end;
long total_time;
int errors = 0;
malloced_size = compute_memory_size(pdt, count);
opal_datatype_get_extent( pdt, &lb, &extent );
odst = (char*)malloc( malloced_size );
osrc = (char*)malloc( malloced_size );
{
for( size_t i = 0; i < malloced_size; i++ )
osrc[i] = i % 128 + 32;
memcpy(odst, osrc, malloced_size);
}
pdst = odst - lb;
psrc = osrc - lb;
cache_trash(); /* make sure the cache is useless */
GET_TIME( start );
if( OPAL_SUCCESS != opal_datatype_copy_content_same_ddt( pdt, count, pdst, psrc ) ) {
printf( "Unable to copy the datatype in the function local_copy_ddt_count."
" Is the datatype committed ?\n" );
}
GET_TIME( end );
total_time = ELAPSED_TIME( start, end );
printf( "direct local copy in %ld microsec\n", total_time );
if(outputFlags & VALIDATE_DATA) {
for( size_t i = 0; i < malloced_size; i++ ) {
if( odst[i] != osrc[i] ) {
printf("error at position %lu (%d != %d)\n",
(unsigned long)i, (int)(odst[i]), (int)(osrc[i]));
errors++;
if(outputFlags & QUIT_ON_FIRST_ERROR) {
opal_datatype_dump(pdt);
assert(0); exit(-1);
}
}
}
if( 0 == errors ) {
printf("Validation check succesfully passed\n");
} else {
printf("Found %d errors. Giving up!\n", errors);
exit(-1);
}
}
free( odst );
free( osrc );
return (0 == errors ? OPAL_SUCCESS : errors);
}
// Rotina Principal do programa
int main(int argc, char **argv) {
double start, finish;
int i;
if(argc != 2){
printf("Usage: %s <number of particles>\n",argv[0]);
return 0;
}
// Recebe o número de partículas que devem ser processadas
// e posteriormente renderizadas
nParticulas = atoi(argv[1]);
// Define a quantidade de partículas que não estão no chão (inicialmente nenhuma delas está)
nParticulasAux = nParticulas;
// Define posição inicial das particulas
iniciarParticula();
// Funções necessárias para inicializar o OpenGL
// e criar a janela que ficará renderizando
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,640);
glutCreateWindow("Trabalho Final - Computação Paralela");
glEnable(GL_DEPTH_TEST);
// Inicializa a contagem do tempo
GET_TIME(start);
// Registrando CallBacks
glutDisplayFunc(renderScene);
glutReshapeFunc(changeSize);
glutIdleFunc(renderScene);
// Função que mantém o loop do evento de renderização
// funcionado
// Foi escolhido a função glutMainLoopEvent ao invés de glutMainLoop
// pelo simples fato de que a segunda não pára até o programa finalizar
// e a que escolhemos funciona como apenas uma iteração dessa função
while(!Flag)
{
glutMainLoopEvent();
renderScene();
}
// Finaliza o timer
GET_TIME(finish);
// Printa o tempo
printf("Tempo gasto: %f\n", (finish - start));
free(vetor2);
return 1;
}
int main(int argc, char * argv[]){
int threads = parse_number_threads(argc, argv);
double **A; int size;
Lab3LoadInput(&A, &size);
double storage[size];
// Initialize Times
double start_time;
double end_time;
GET_TIME(start_time);
int k;
for (k = 0; k < size; k++){
int max_indice = find_max_indice(k, A, size);
swap_rows(A, k, max_indice);
int i;
int j;
//printf("Current k value: %d \n",k);
//printf("----------------------------\n");
for (i = k+1; i < size; i++){
//printf("Current Row: %d \n",i);
double subtrahend_coefficient = (A[i][k]/A[k][k]);
//printf("Subtrahend Coefficient: %f \n",subtrahend_coefficient);
for (j = k; j < size + 1; j++){
//printf("Current Col: %d \n",j);
A[i][j] = A[i][j] - (subtrahend_coefficient* A[k][j]);
}
}
}
//Lab2_saveoutput(A, size, 10, "Gauss.txt");
for (k = size-1; k > 0; k--){
int i;
for (i = 0; i < k; i++){
//double result = A[i][size] - ( (A[i][k] / A[k][k]) * A[k][size]);;
//printf("A[%d][%d] = %f \n", i, size, result);
A[i][size] = A[i][size] - ( (A[i][k] / A[k][k]) * A[k][size]);
A[i][k] = A[i][k] - ( (A[i][k] / A[k][k]) * A[k][k]);
}
}
//Lab2_saveoutput(A, size, 10, "Jordan.txt");
// Retrieve elapsed time
GET_TIME(end_time);
get_result(storage, A, size);
printf("Total Time: %f \n",end_time-start_time);
Lab3SaveOutput(storage, size, end_time - start_time);
return 0;
}
int main(int argc, char **argv)
{
int i;
int model, model_min, model_max;
testobj_t *keep_arr;
GC_INIT();
GC_init_finalized_malloc();
keep_arr = GC_MALLOC(sizeof(void *)*KEEP_CNT);
if (argc == 2 && strcmp(argv[1], "--help") == 0) {
fprintf(stderr,
"Usage: %s [FINALIZATION_MODEL]\n"
"\t0 -- original finalization\n"
"\t1 -- finalization on reclaim\n"
"\t2 -- no finalization\n", argv[0]);
return 1;
}
if (argc == 2) {
model_min = model_max = atoi(argv[1]);
if (model_min < 0 || model_max > 2)
exit(2);
}
else {
model_min = 0;
model_max = 2;
}
printf("\t\t\tfin. ratio time/s time/fin.\n");
for (model = model_min; model <= model_max; ++model) {
double t = 0.0;
free_count = 0;
# ifdef CLOCK_TYPE
CLOCK_TYPE tI, tF;
GET_TIME(tI);
# endif
for (i = 0; i < ALLOC_CNT; ++i) {
int k = rand() % KEEP_CNT;
keep_arr[k] = testobj_new(model);
}
GC_gcollect();
# ifdef CLOCK_TYPE
GET_TIME(tF);
t = MS_TIME_DIFF(tF, tI)*1e-3;
# endif
if (model < 2)
printf("%20s: %12.4lf %12lg %12lg\n", model_str[model],
free_count/(double)ALLOC_CNT, t, t/free_count);
else
printf("%20s: %12.4lf %12lg %12s\n",
model_str[model], 0.0, t, "N/A");
}
return 0;
}
int main(int argc, char **argv)
{
int correctsum=0, result = 0;
pthread_t tid[MAXTHREADS];
int i, myid[MAXTHREADS];
struct timespec t0, t1, t2, t3;
unsigned long sec, nsec;
float comp_time, total_time; // in milli seconds
GET_TIME(t0);
if (argc != 2) {
printf("Usage: %s <numthreads>\n", argv[0]);
exit(0);
}
numthreads = atoi(argv[1]);
if (numthreads > MAXTHREADS) {
printf("numthreads > MAXTHREADS (%d)\n", MAXTHREADS);
exit(0);
}
for (i=0; i < N; i++) {
vector[i] = i % 3; // also test with random() % 3;
correctsum += vector[i];
}
GET_TIME(t1);
//total_time = elapsed_time_msec(&t0, &t1, &sec, &nsec);
//printf("InitTime(ms)=%8.1f: ", total_time);
for (i = 0; i < numthreads; i++) {
myid[i] = i;
psum[i] = 0;
pthread_create(&tid[i], NULL, sum, &myid[i]);
}
for (i = 0; i < numthreads; i++) {
pthread_join(tid[i], NULL);
}
GET_TIME(t2);
// For checking: add up the partial sums computed by each thread
for (i = 0; i < numthreads; i++)
result += psum[i];
correctsum = REPEAT * correctsum;
if (result != correctsum || (correctsum != sumtotal) )
printf("# Error! : correctsum=%d, result=%d, sumtotal=%d\n", correctsum, result, sumtotal);
GET_TIME(t3);
comp_time = elapsed_time_msec(&t1, &t2, &sec, &nsec);
total_time = elapsed_time_msec(&t0, &t3, &sec, &nsec);
#ifdef BAD_FS
if (numthreads == 1) {
printf("# PSumVector: Good : N=%d : Threads=%d : CompTime(ms)=%.2f : CompTime/TotalTime=%.1f%%\n", \
N, numthreads, comp_time, 100.0*comp_time/total_time);
return 0;
}
#endif
printf(MSG, N, numthreads, comp_time, 100.0*comp_time/total_time);
return 0;
}
int calculate(double *r, node *A) {
int i, j;
double *r_pre;
double damp_const;
damp_const = (1.0 - DAMPING_FACTOR) / n;
int my_rank, comm_sz, local_n;
double start = 0, end = 0; // for time
MPI_Init(NULL, NULL);
/* Get my process rank */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Find out how many processes are being used */
MPI_Comm_size(MPI_COMM_WORLD, &comm_sz);
r_pre = malloc(n * sizeof(double));
local_n = n / comm_sz;
double still_err = 1;
double *local_r = malloc(local_n * sizeof(double));
if (my_rank == 0) {
GET_TIME(start);
}
while (still_err > EPSILON) {
backup_vec(r, r_pre, n);
for ( i = local_n * my_rank; i < local_n * (my_rank + 1); i++) {
local_r[i - local_n * my_rank] = 0.0;
for ( j = 0; j < A[i].size_Di; ++j) {
local_r[i - local_n * my_rank] += r_pre[A[i].Di[j]] / A[A[i].Di[j]].li;
}
local_r[i - local_n * my_rank] *= DAMPING_FACTOR;
local_r[i - local_n * my_rank] += damp_const;
}
MPI_Gather(local_r, local_n, MPI_DOUBLE, r, local_n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
if (my_rank == 0) {
still_err = rel_err(r, r_pre, n);
}
MPI_Bcast(&still_err, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(r, n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
}
if (my_rank == 0) {
GET_TIME(end);
printf("%f\n", end-start);
Lab4_saveoutput(r, n, end-start);
}
free(r_pre);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int totalcount=0, numthreads, i;
pthread_t main_tid, tid[MAXTHREADS];
int myid[MAXTHREADS];
struct timespec t0, t1, t2, t3;
unsigned long sec, nsec;
float comp_time, total_time; // in milli seconds
GET_TIME(t0);
if (argc != 2) { //if the number of threads in not specified
printf("Usage: %s <num_threads> (max threads = %d)\n", argv[0],MAXTHREADS);
exit(0);
}
numthreads = atoi(argv[1]); //convert number of threads into int
if (numthreads > MAXTHREADS) { //print number of threads
printf("nthreads > MAXTHREADS (16)\n");
exit(0);
}
sem_init(&mutexA, 0, 1);
sem_init(&mutexB, 0, 1);
GET_TIME(t1);
for (i = 0; i < numthreads; i++) {
myid[i] = i;
pthread_create(&tid[i], NULL, (void *) &handler, &myid[i]);
}
for (i = 0; i < numthreads; i++) {
pthread_join(tid[i], NULL);
}
GET_TIME(t2);
sem_destroy(&mutexA);
sem_destroy(&mutexB);
if(counter1 != counter2){
printf("# Error! : counter1(%d) != counter2(%d) \n", counter1, counter2);
}
GET_TIME(t3);
comp_time = elapsed_time_msec(&t1, &t2, &sec, &nsec);
total_time = elapsed_time_msec(&t0, &t3, &sec, &nsec);
printf(MSG, N, numthreads, comp_time, 100.0*comp_time/total_time);
return 0;
}
/* returns TME_FALSE if the entry is not found */
uint32 normal_lut_wo_insert(uint8 *key, TME_DATA *data, MEM_TYPE *mem_ex, struct time_conv *time_ref)
{
uint32 i;
uint32 tocs=0;
uint32 *key32=(uint32*) key;
uint32 shrinked_key=0;
uint32 index;
RECORD *records=(RECORD*)data->lut_base_address;
uint8 *offset;
uint32 key_len=data->key_len;
/*the key is shrinked into a 32-bit value */
for (i=0; i<key_len;i++)
shrinked_key^=key32[i];
/*the first index in the table is calculated*/
index=shrinked_key % data->lut_entries;
while (tocs<=data->filled_entries)
{
if (records[index].block==0)
{ /*out of table, insertion is not allowed*/
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
/*offset contains the absolute pointer to the block*/
/*associated with the current entry */
offset=mem_ex->buffer+SW_ULONG_AT(&records[index].block,0);
for (i=0; (i<key_len) && (key32[i]==ULONG_AT(offset,i*4)); i++);
if (i==key_len)
{
/*key in the block matches the one provided, right entry*/
GET_TIME((struct timeval *)(offset+4*key_len),time_ref);
data->last_found=(uint8*)&records[index];
return TME_TRUE;
}
else
{
/*wrong entry, rehashing*/
index=(index+data->rehashing_value) % data->lut_entries;
tocs++;
}
}
/*nothing found, last found= out of lut*/
GET_TIME((struct timeval *)(data->shared_memory_base_address+4*key_len),time_ref);
data->last_found=NULL;
return TME_FALSE;
}
/*------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
double start, finish;
if (argc != 4) Usage(argv[0]);
thread_count = strtol(argv[1], NULL, 10);
m = strtol(argv[2], NULL, 10);
n = strtol(argv[3], NULL, 10);
# ifdef DEBUG
printf("thread_count = %d, m = %d, n = %d\n", thread_count, m, n);
# endif
thread_handles = malloc(thread_count*sizeof(pthread_t));
sem_init(&sem, 0, 1); /* Initial value is 1 */
A = malloc(m*n*sizeof(double));
x = malloc(n*sizeof(double));
y = malloc(m*sizeof(double));
srandom(1);
Gen_matrix(A, m, n);
# ifdef DEBUG
Print_matrix("We generated", A, m, n);
# endif
Gen_vector(x, n);
# ifdef DEBUG
Print_vector("We generated", x, n);
# endif
GET_TIME(start);
for (thread = 0; thread < thread_count; thread++)
pthread_create(&thread_handles[thread], NULL,
Pth_mat_vect, (void*) thread);
for (thread = 0; thread < thread_count; thread++)
pthread_join(thread_handles[thread], NULL);
GET_TIME(finish);
# ifdef DEBUG
Print_vector("The product is", y, m);
# endif
printf("Elapsed time = %e seconds\n", finish - start);
free(A);
free(x);
free(y);
sem_destroy(&sem);
free(thread_handles);
return 0;
} /* main */
int main (int argc, char *argv[]){
MPI_Comm comm;
int p, my_rank;
long long int n;
long long int local_n;
float ans=0;
long long int in_circle=0;
double start, finish, elapsed;
float pi,err;
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &p);
MPI_Comm_rank(comm, &my_rank);
if (my_rank == 0){
if (argc>1) {
n = strtol(argv[1], NULL, 10);
}
else {
n = 0;
}
}
MPI_Bcast(&n, 1, MPI_LONG_LONG, 0, comm);
if (n <= 0){
if (my_rank == 0){
printf("Enter the value for n: mpiexec -n <number of nodes> ");
printf("./mpi_monte_carlo_pi <value for n>. \nProgram will Terminate\n");
}
MPI_Finalize();
}
GET_TIME(start);
local_n = n/p;
in_circle = monte_carlo_pi(local_n, my_rank, in_circle);
ans = global_calc(n, in_circle, my_rank, comm, p, ans);
pi = pi_val();
err = pi - ans;
GET_TIME(finish);
elapsed = finish-start;
if (my_rank ==0){
printf ("Estimated Value of Pi for %lld 'darts': %f\n",n,ans);
printf ("Actual Value of Pi: %f\n", pi);
printf ("Difference between Estimated and Actual: %f\n",err);
printf ("Time: %f\n", elapsed);
}
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int i, result = 0;
pthread_t main_tid, tid[MAXTHREADS];
int myid[MAXTHREADS], status;
struct timespec t0, t1, t2, t3;
unsigned long sec, nsec;
float comp_time, total_time; // in milli seconds
GET_TIME(t0);
if (argc != 2) {
printf("Usage: %s <num_threads> (max threads = 16)\n", argv[0]);
exit(0);
}
numthreads = atoi(argv[1]);
if (numthreads > MAXTHREADS) {
printf("nthreads > MAXTHREADS (16)\n");
exit(0);
}
for (i=0; i< N; i++)
x[i] = random(); // not optimized
GET_TIME(t1);
//total_time = elapsed_time_msec(&t0, &t1, &sec, &nsec);
//printf("InitTime(ms)=%8.1f: ", total_time);
for (i = 0; i < numthreads; i++) {
myid[i] = i;
count[i] = 0;
pthread_create(&tid[i], NULL, pcount, &myid[i]);
}
for (i = 0; i < numthreads; i++) {
pthread_join(tid[i], NULL);
}
GET_TIME(t2);
for (i=0; i < numthreads; i++)
result += count[i];
if (result != totalcount) printf("# Error! : result(%d) != totalcount(%d)\n", result, totalcount);
GET_TIME(t3);
comp_time = elapsed_time_msec(&t1, &t2, &sec, &nsec);
total_time = elapsed_time_msec(&t0, &t3, &sec, &nsec);
#ifdef BAD_FS
if (numthreads == 1) {
printf("# PCount: Good : N=%d : Threads=%d : CompTime(ms)=%.2f : CompTime/TotalTime=%.1f%%\n", \
N, numthreads, comp_time, 100.0*comp_time/total_time);
return 0;
}
#endif
printf(MSG, N, numthreads, comp_time, 100.0*comp_time/total_time);
//pthread_exit(NULL);
return 0;
}
int main(int argc, char* argv[]) {
long thread_i;
pthread_t* thread_handles;
double start, end;
if (argc != 2) {
fprintf(stderr, "Please indicate the number of threads!\n");
exit(EXIT_FAILURE);
}
thread_count_ = strtol(argv[1], NULL, 10);
thread_handles = malloc(thread_count_ * sizeof *thread_handles);
Lab2_loadinput(&dp_, &city_count_);
int i, j, k;
sem_array = malloc(city_count_ * sizeof *sem_array);
for (i = 0; i < city_count_; ++i) {
sem_array[i] = malloc(city_count_ * sizeof *sem_array[i]);
for (j = 0; j < city_count_; ++j) {
sem_array[i][j] = malloc(city_count_ * sizeof *sem_array[i][j]);
for (k = 0; k < city_count_; ++k) {
sem_init(&sem_array[i][j][k],
0, // shared == 0; shared between threads
0);// init_value is set to zero
}
}
}
for (i = 0; i < city_count_; ++i) {
for (j = 0; j < city_count_; ++j) {
sem_post(&sem_array[i][j][0]);
}
}
GET_TIME(start);
for (thread_i = 0; thread_i < thread_count_; ++thread_i)
pthread_create( &thread_handles[thread_i],
NULL,
thread_subcal,
(void*)thread_i);
for (thread_i = 0; thread_i < thread_count_; ++thread_i)
pthread_join(thread_handles[thread_i], NULL);
GET_TIME(end);
Lab2_saveoutput(dp_, city_count_, end-start);
printf("Time taken: %f\n", end-start);
return EXIT_SUCCESS;
}
void* pthread_mul_matrix(void* _tid) {
int tid = *((int*) _tid);
double start;
double finish;
GET_TIME(start);
multiply_matrix(tid);
GET_TIME(finish);
printf("Thread_%02d,%lf,%lf\n", tid, start - start_time, finish - start_time);
//printf("Thread: %d finish - %lf\n", tid, finish - start_time);
return NULL;
}
int main(int argc, char** argv){
if(argc > 1) {
matrix_size = atoi(argv[1]);
}
else {
matrix_size = 3;
}
srand(time(NULL));
alloc_matrices();
init_matrix(matrix_a);
init_matrix(matrix_b);
pthread_t* threads = (pthread_t*) malloc(matrix_size * sizeof(pthread_t));
int* tids = (int*) malloc(matrix_size * sizeof(int));
double start;
double finish;
double elapsed;
GET_TIME(start);
start_time = start;
for(int thread_id = 0; thread_id < matrix_size; thread_id++) {
tids[thread_id] = thread_id;
pthread_create(threads + thread_id, NULL, pthread_mul_matrix, (void*) (tids + thread_id));
}
for(int thread_id = 0; thread_id < matrix_size; thread_id++) {
pthread_join(threads[thread_id], NULL);
}
GET_TIME(finish);
elapsed = finish - start;
//printf("%lf\n", elapsed);
// printf("A = ");
// print_matrix(matrix_a);
// printf("B = ");
// print_matrix(matrix_b);
// printf("C = ");
// print_matrix(matrix_c);
// puts("A * B - C");
return 0;
}
int main(int argc, char* argv[]) {
char greeting[MAX_STRING]; /* String storing message */
char received_greet[MAX_STRING]; /* String storing message */
int comm_sz; /* Number of processes */
int my_rank; /* My process rank */
int size;
double start, finish, elapsed;
/* Start up MPI */
MPI_Init(&argc, &argv);
/* Get the number of processes */
MPI_Comm_size(MPI_COMM_WORLD, &comm_sz);
/* Get my rank among all the processes */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
if (my_rank != 0) {
/* Create message */
//sprintf(greeting, "Greetings from process %d of %d!",my_rank, comm_sz);
/* Send message to process 0 */
for(size=0; size<MAX_STRING ; size++){
greeting[size] = 'x';
greeting[size+1] = '\0';
GET_TIME(start);
MPI_Send(greeting, size, MPI_CHAR, 0, 0,MPI_COMM_WORLD);
MPI_Recv(received_greet, size, MPI_CHAR, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
GET_TIME(finish);
elapsed = finish - start;
printf("The message (%d sized) to be timed took %e seconds\n",size, elapsed);
}
} else {
/* Print my message */
printf("Greetings from process %d of %d!\n", my_rank, comm_sz);
/* Receive message from process q */
for(size=0; size<MAX_STRING ; size++){
MPI_Recv(received_greet, size, MPI_CHAR, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Send(greeting, size, MPI_CHAR, 1, 0,MPI_COMM_WORLD);
}
}
/* Shut down MPI */
MPI_Finalize();
return 0;
} /* main */
/*------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
FILE* digraph_file;
tour_t tour;
double start, finish;
if (argc != 2) Usage(argv[0]);
digraph_file = fopen(argv[1], "r");
if (digraph_file == NULL) {
fprintf(stderr, "Can't open %s\n", argv[1]);
Usage(argv[0]);
}
Read_digraph(digraph_file);
fclose(digraph_file);
# ifdef DEBUG
Print_digraph();
# endif
avail = Init_stack();
best_tour = Alloc_tour();
Init_tour(best_tour, INFINITY);
# ifdef DEBUG
Print_tour(best_tour, "Best tour");
printf("City count = %d\n", City_count(best_tour));
printf("Cost = %d\n\n", Tour_cost(best_tour));
# endif
tour = Alloc_tour();
Init_tour(tour, 0);
# ifdef DEBUG
Print_tour(tour, "Starting tour");
printf("City count = %d\n", City_count(tour));
printf("Cost = %d\n\n", Tour_cost(tour));
# endif
GET_TIME(start);
Iterative_dfs(tour);
GET_TIME(finish);
Free_tour(tour);
Print_tour(best_tour, "Best tour");
printf("Cost = %d\n", best_tour->cost);
printf("Elapsed time = %e seconds\n", finish-start);
free(best_tour->cities);
free(best_tour);
Free_avail();
free(digraph);
return 0;
} /* main */
void get_cpu_time (Time* usrT, Time* sysT) {
//
// Get the user and/or system cpu times in a system independent way.
time_struct_t ts;
GET_TIME(ts);
if (usrT != NULL) {
SET_TIME(usrT, USR_TIME(ts));
if (usrT->seconds < lastU.seconds)
usrT->seconds = lastU.seconds;
if ((usrT->seconds == lastU.seconds) && (usrT->uSeconds < lastU.uSeconds))
usrT->uSeconds = lastU.uSeconds;
lastU = *usrT;
}
if (sysT != NULL) {
SET_TIME(sysT, SYS_TIME(ts));
if (sysT->seconds < lastS.seconds)
sysT->seconds = lastS.seconds;
if ((sysT->seconds == lastS.seconds) && (sysT->uSeconds < lastS.uSeconds))
sysT->uSeconds = lastS.uSeconds;
lastS = *sysT;
}
}
LRESULT AutoSearchFrame::onAdd(WORD , WORD , HWND , BOOL& ) {
SearchPageDlg dlg;
dlg.expireTime = SETTING(AUTOSEARCH_EXPIRE_DAYS) > 0 ? GET_TIME() + (SETTING(AUTOSEARCH_EXPIRE_DAYS)*24*60*60) : 0;
if(dlg.DoModal() == IDOK) {
string search = dlg.searchString + "\r\n";
string::size_type j = 0;
string::size_type i = 0;
while((i = search.find("\r\n", j)) != string::npos) {
string str = search.substr(j, i-j);
j = i +2;
if(str.size() >= 5) { //dont accept shorter search strings than 5 chars
AutoSearchPtr as = new AutoSearch(true, str, (SearchManager::TypeModes)dlg.fileType, (AutoSearch::ActionType)dlg.action, dlg.remove,
dlg.target, dlg.targetType, (StringMatcher::Type)dlg.matcherType, dlg.matcherString, dlg.userMatch, dlg.searchInterval, dlg.expireTime, dlg.checkQueued, dlg.checkShared);
as->startTime = dlg.startTime;
as->endTime = dlg.endTime;
as->searchDays = dlg.searchDays;
AutoSearchManager::getInstance()->addAutoSearch(as);
} else if(search.size() < 5) { // dont report if empty line between/end when adding multiple
//MessageBox(_T("Not adding the auto search: ") + Text::toT(str).c_str());
MessageBox(CTSTRING(LINE_EMPTY_OR_TOO_SHORT));
}
}
}
return 0;
}
SessionPtr WebUserManager::authenticate(const string& aUserName, const string& aPassword, bool aIsSecure, uint64_t aMaxInactivityMinutes, bool aUserSession) noexcept {
auto u = getUser(aUserName);
if (!u) {
return nullptr;
}
if (u->getPassword() != aPassword) {
return nullptr;
}
u->setLastLogin(GET_TIME());
u->addSession();
fire(WebUserManagerListener::UserUpdated(), u);
auto uuid = boost::uuids::random_generator()();
auto session = std::make_shared<Session>(u, boost::uuids::to_string(uuid), aIsSecure, server, aMaxInactivityMinutes, aUserSession);
{
WLock l(cs);
sessionsRemoteId.emplace(session->getAuthToken(), session);
sessionsLocalId.emplace(session->getId(), session);
}
if (aUserSession) {
ActivityManager::getInstance()->updateActivity();
}
return session;
}
bool CryptoManager::checkCertificate(int minValidityDays) noexcept{
auto x509 = ssl::getX509(SETTING(TLS_CERTIFICATE_FILE).c_str());
if (!x509) {
return false;
}
ASN1_INTEGER* sn = X509_get_serialNumber(x509);
if (!sn || !ASN1_INTEGER_get(sn)) {
return false;
}
X509_NAME* name = X509_get_subject_name(x509);
if (!name) {
return false;
}
string cn = getNameEntryByNID(name, NID_commonName);
if (cn != ClientManager::getInstance()->getMyCID().toBase32()) {
return false;
}
ASN1_TIME* t = X509_get_notAfter(x509);
if (t) {
time_t minValid = GET_TIME() + 60 * 60 * 24 * minValidityDays;
if (X509_cmp_time(t, &minValid) < 0) {
return false;
}
}
return true;
}
pair<double, bool> ListFilter::prepareTime() const {
size_t end;
time_t multiplier;
auto hasType = [&end, this](string&& id) {
end = Util::findSubString(matcher.pattern, id, matcher.pattern.size() - id.size());
return end != string::npos;
};
bool hasMatch = true;
if (hasType("y")) {
multiplier = 60 * 60 * 24 * 365;
} else if (hasType("m")) {
multiplier = 60 * 60 * 24 * 30;
} else if (hasType("w")) {
multiplier = 60 * 60 * 24 * 7;
} else if (hasType("d")) {
multiplier = 60 * 60 * 24;
} else if (hasType("h")) {
multiplier = 60 * 60;
} else if (hasType("min")) {
multiplier = 60;
} else if (hasType("s")) {
multiplier = 1;
} else {
hasMatch = false;
multiplier = 1;
}
if (end == tstring::npos) {
end = matcher.pattern.length();
}
time_t ret = Util::toInt64(matcher.pattern.substr(0, end)) * multiplier;
return make_pair(ret > 0 ? GET_TIME() - ret : ret, hasMatch);
}
void UploadQueueItemInfo::update()
{
setText(COLUMN_FILE, Text::toT(Util::getFileName(getQi()->getFile())));
setText(COLUMN_PATH, Text::toT(Util::getFilePath(getQi()->getFile())));
setText(COLUMN_NICK, getQi()->getUser()->getLastNickT()); // [1] https://www.box.net/shared/plriwg50qendcr3kbjp5
setText(COLUMN_HUB, WinUtil::getHubNames(getQi()->getHintedUser()).first); // [!] IRainman fix: hintedUser
setText(COLUMN_TRANSFERRED, Util::formatBytesW(getQi()->getPos()) + _T(" (") + Util::toStringW((double)getQi()->getPos() * 100.0 / (double)getQi()->getSize()) + _T("%)"));
setText(COLUMN_SIZE, Util::formatBytesW(getQi()->getSize()));
setText(COLUMN_ADDED, Text::toT(Util::formatDigitalClock(getQi()->getTime())));
setText(COLUMN_WAITING, Util::formatSecondsW(GET_TIME() - getQi()->getTime()));
setText(COLUMN_SHARE, Util::formatBytesW(getQi()->getUser()->getBytesShared())); //[+]PPA
setText(COLUMN_SLOTS, Util::toStringW(getQi()->getUser()->getSlots())); //[+]PPA
// !SMT!-IP
if (!m_location.isSet() && !m_ip.empty()) // [!] IRainman opt: Prevent multiple repeated requests to the database if the location has not been found!
{
m_location = Util::getIpCountry(m_ip);
setText(COLUMN_IP, Text::toT(m_ip));
}
if (m_location.isKnown())
{
setText(COLUMN_LOCATION, m_location.getDescription());
}
#ifdef PPA_INCLUDE_DNS
// [!] IRainman opt.
if (m_dns.empty())
{
m_dns = Socket::nslookup(m_ip);
setText(COLUMN_DNS, Text::toT(m_dns)); // todo: paint later if not resolved yet
}
// [~] IRainman opt.
#endif
}
/*
* Reclaim all small blocks waiting to be reclaimed.
* Abort and return FALSE when/if (*stop_func)() returns TRUE.
* If this returns TRUE, then it's safe to restart the world
* with incorrectly cleared mark bits.
* If ignore_old is TRUE, then reclaim only blocks that have been
* recently reclaimed, and discard the rest.
* Stop_func may be 0.
*/
GC_INNER GC_bool GC_reclaim_all(GC_stop_func stop_func, GC_bool ignore_old)
{
word sz;
unsigned kind;
hdr * hhdr;
struct hblk * hbp;
struct obj_kind * ok;
struct hblk ** rlp;
struct hblk ** rlh;
# ifndef SMALL_CONFIG
CLOCK_TYPE start_time = 0; /* initialized to prevent warning. */
CLOCK_TYPE done_time;
if (GC_print_stats == VERBOSE)
GET_TIME(start_time);
# endif
for (kind = 0; kind < GC_n_kinds; kind++) {
ok = &(GC_obj_kinds[kind]);
rlp = ok -> ok_reclaim_list;
if (rlp == 0) continue;
for (sz = 1; sz <= MAXOBJGRANULES; sz++) {
rlh = rlp + sz;
while ((hbp = *rlh) != 0) {
if (stop_func != (GC_stop_func)0 && (*stop_func)()) {
return(FALSE);
}
hhdr = HDR(hbp);
*rlh = hhdr -> hb_next;
if (!ignore_old || hhdr -> hb_last_reclaimed == GC_gc_no - 1) {
/* It's likely we'll need it this time, too */
/* It's been touched recently, so this */
/* shouldn't trigger paging. */
GC_reclaim_small_nonempty_block(hbp, FALSE);
}
}
}
}
# ifndef SMALL_CONFIG
if (GC_print_stats == VERBOSE) {
GET_TIME(done_time);
GC_log_printf("Disposing of reclaim lists took %lu msecs\n",
MS_TIME_DIFF(done_time,start_time));
}
# endif
return(TRUE);
}