调度与section与稀疏矩阵乘法

#pragma omp parallel sections
{
    #pragma omp section
    {
        producer();
    }
    #pragma omp section
    {
        consumer();
    }
}

#pragma omp parallel num_threads(p_count + c_count)
{
    int id = omp_get_thread_num();
    #pragma omp parallel sections
    {
        #pragma omp section
        {
            if (id < p_count)
                producer(id);
        }
        #pragma omp section
        {
            if (id >= p_count)
                consumer(id);
        }
    }
}

void consume(int i, int id) {
    printf("source %d is consumed by thread %d.\n", i, id);
}

void producer(int id) {
    while (true) {
        int x = produce();   
        sem_wait(&s);
        source.push(x);
        printf("source %d is produced by thread %d.\n", x, id);
        sem_post(&s);
        sem_post(&n);
    }
}

void consumer(int id) {
    while (true) {
        int x;
        sem_wait(&n);
        sem_wait(&s);
        x = source.front();
        source.pop();
        sem_post(&s);
        consume(x, id);
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <omp.h>

void dummy(int t) {
    Sleep(t);
}

int main() {
    clock_t start, finish;
    double Total_time;
    FILE *fp1 = fopen("static.txt", "w");
    FILE *fp2 = fopen("dynamic.txt", "w");
    FILE *fp3 = fopen("guided.txt", "w");

    for (int p = 1; p <= 5; p++) {
        // static, p
        start = clock();
        #pragma omp parallel for schedule(static, p) num_threads(4)
        for (int i = 0; i < 10; i++)
            dummy(i * 100);
        finish = clock();
        Total_time = (double)(finish - start);
        fprintf(fp1, "%f\n", Total_time);
        
        // dynamic, p
        start = clock();
        #pragma omp parallel for schedule(dynamic, p) num_threads(4)
        for (int i = 0; i < 10; i++)
            dummy(i * 100);
        finish = clock();
        Total_time = (double)(finish - start);
        fprintf(fp2, "%f\n", Total_time);

        // guided, p
        start = clock();
        #pragma omp parallel for schedule(guided, p) num_threads(4)
        for (int i = 0; i < 10; i++)
            dummy(i * 100);
        finish = clock();
        Total_time = (double)(finish - start);
        fprintf(fp3, "%f\n", Total_time);
    }

    printf("static\n");
#pragma omp parallel for schedule(static, 2) num_threads(4)
    for (int i = 0; i < 10; i++) {
        dummy(i * 100);
        printf("i = %d calls from thread %d\n", i, omp_get_thread_num());
    }
    
    printf("dynamic\n");
#pragma omp parallel for schedule(dynamic, 2) num_threads(4)
    for (int i = 0; i < 10; i++) {
        dummy(i * 100);
        printf("i = %d calls from thread %d\n", i, omp_get_thread_num());
    }

    printf("guided\n");
#pragma omp parallel for schedule(guided, 2) num_threads(4)
    for (int i = 0; i < 10; i++) {
        dummy(i * 100);
        printf("i = %d calls from thread %d\n", i, omp_get_thread_num());
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <windows.h>
#include <omp.h>
#include <cassert>
#include <semaphore.h>
using namespace std;

sem_t n, s;
queue <int> source;

int produce() {
    Sleep(0.05);
    if (source.empty())
        return 1;
    else
        return source.back() + 1;
}

void consume(int i, int id) {
    printf("source %d is consumed by thread %d.\n", i, id);
}

void producer(int id) {
    while (true) {
        int x = produce();   
        sem_wait(&s);
        source.push(x);
        printf("source %d is produced by thread %d.\n", x, id);
        sem_post(&s);
        sem_post(&n);
    }
}

void consumer(int id) {
    while (true) {
        int x;
        sem_wait(&n);
        sem_wait(&s);
        x = source.front();
        source.pop();
        sem_post(&s);
        consume(x, id);
    }
}

int main() {
    sem_init(&n, 0, 0);
    sem_init(&s, 0, 1);
    
    // a varying number of producers and consumers
    int p_count = 4;
    int c_count = 4;
    // a single producer task and a single consumer task
    // int p_count = 1;
    // int c_count = 1;

	#pragma omp parallel num_threads(p_count + c_count)
	{
	    int id = omp_get_thread_num();
        printf("%d\n", id);
	    #pragma omp parallel sections
	    {
            #pragma omp section
            {
                int qwq = omp_get_thread_num();
                assert(qwq == id);
                exit(0);
                if (id < p_count)
                    producer(id);
            }
            #pragma omp section
            {
                int qwq = omp_get_thread_num();
                assert(qwq == id);
                exit(0);
                if (id >= p_count)
                    consumer(id);
            }
	    }
	}
}

#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#define BUFLEN 1000000

char buf[BUFLEN];

int main(int argc, char **argv)
{ 
    int my_id = 0;
    int p;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &my_id);
    MPI_Comm_size(MPI_COMM_WORLD, &p);
    MPI_Status status_p;
    MPI_Barrier(MPI_COMM_WORLD);
    double my_start,my_end,my_elapsed,elapsed;
    my_start = MPI_Wtime();
    if(my_id == 0){
        for(int i = 1;i < p;i++){
            MPI_Send(buf,BUFLEN,MPI_CHAR,i,i,MPI_COMM_WORLD);
        }
    }
    else{
        MPI_Recv(buf,BUFLEN,MPI_CHAR,0,my_id,MPI_COMM_WORLD,&status_p);
    }
    my_end = MPI_Wtime();

    my_elapsed = my_end - my_start;

    MPI_Reduce(&my_elapsed,&elapsed,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD);
    if(my_id == 0){
	printf("Time delay is %f s\n",elapsed);
        printf("Bandwidth is %f Mbit/s\n", BUFLEN * 1.0 / (1048576* elapsed));
    }
    MPI_Finalize();


    return 0;
}