c - 多线程->调度。核心转储

Question

我决定简化我的另一篇文章，简化代码，以便您更容易帮助我。

因此，代码的目标是仅使用 1 个核心运行 3 个线程，以便我可以使用它来调度任务，并测量计算和响应时间。每个线程都有不同的优先级，因此始终只有 1 个线程在运行。

相反，3 个线程同时运行，因此我可以得出结论，程序至少使用了 3 个核心。

代码如下: #定义_GNU_SOURCE ＃包括 ＃包括 ＃包括 ＃包括 ＃包括 ＃包括 ＃包括 ＃包括 ＃包括 #包括

    #define SCHED SCHED_FIFO

    #define NUM_THREADS 3
    #include "func.h"

    struct timespec start1;
    int result_code;

    void *ff1(void* arg){
            u_int64_t diff;
            struct timespec start, end;
            struct sched_param param;

            // Periority
            param.sched_priority=sched_get_priority_max(SCHED_FIFO);
            result_code = sched_setscheduler(0,SCHED,&param);
            assert(!result_code);

            printf("Running Task 1\n");

            clock_gettime(CLOCK_MONOTONIC, &start);
            f1(1,5);    
            clock_gettime(CLOCK_MONOTONIC, &end);

            diff = pow(10,9) * (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec);
        printf("1st Task elapsed time = %ld ns => %f s\n", diff, diff / (pow(10,9)));


        diff = pow(10,9) * (end.tv_sec - start1.tv_sec) + (end.tv_nsec - start1.tv_nsec);
        printf("1st Task response time = %ld ns => %f s\n", diff, diff / (pow(10,9)));

            printf("Task 1 finished\n");

    }

    void *ff2 (void* arg){
            u_int64_t diff;
            struct timespec start, end;
            struct sched_param param;

            // sched
            param.sched_priority=sched_get_priority_max(SCHED_FIFO)-1;
            result_code = sched_setscheduler(0,SCHED,&param);
            assert(!result_code);

            printf("Running Task 2\n");

            clock_gettime(CLOCK_MONOTONIC, &start);
            f2(1,5);    
            clock_gettime(CLOCK_MONOTONIC, &end);

            diff = pow(10,9) * (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec);
           printf("2nd Task elapsed time = %ld ns => %f s\n", diff, diff / (pow(10,9)));

           diff = pow(10,9) * (end.tv_sec - start1.tv_sec) + (end.tv_nsec - start1.tv_nsec);
           printf("2nd Task response time = %ld ns => %f s\n", diff, diff / (pow(10,9)));

            printf("Task 2 finished\n");
    }

    void *ff3 (void* arg){
            u_int64_t diff;
            struct timespec start, end;
            struct sched_param param;

            // sched
            param.sched_priority=sched_get_priority_max(SCHED_FIFO)-2;
            result_code = sched_setscheduler(0,SCHED,&param);
            assert(!result_code);

            printf("Running Task 3\n");

            clock_gettime(CLOCK_MONOTONIC, &start);
            f3(1,5);    
            clock_gettime(CLOCK_MONOTONIC, &end);

            diff = pow(10,9) * (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec);
           printf("3rd Task elapsed time = %ld ns => %f s\n", diff, diff / (pow(10,9)));

           // Cálculo do tempo de resposta da tarefa 2
           diff = pow(10,9) * (end.tv_sec - start1.tv_sec) + (end.tv_nsec - start1.tv_nsec);
           printf("3rd Task response time = %ld ns => %f s\n", diff, diff / (pow(10,9)));

            printf("Task 3 finished\n");

    }

    int main(){
            pthread_t threads[3];
            short i;


            // Affinity
            cpu_set_t mask;
            CPU_ZERO(&mask);
            CPU_SET(0,&mask);
            result_code = sched_setaffinity(0, sizeof(cpu_set_t), &mask);
            assert(!result_code);

            pthread_attr_t attr[3];


            // Start time
            clock_gettime(CLOCK_MONOTONIC, &start1);

            for (i = 0; i < 3; i++){
                result_code = pthread_attr_init(&attr[i]);
                assert(!result_code);

                result_code = pthread_attr_setaffinity_np(&attr[i], sizeof(cpu_set_t), &mask);
                assert(!result_code);
            }

            result_code=pthread_create(&threads[0],&attr[0],&ff1,NULL);
                assert(!result_code);
            result_code=pthread_create(&threads[1],&attr[1],&ff2,NULL);
                assert(!result_code);
            result_code=pthread_create(&threads[2],&attr[2],&ff3,NULL);
                assert(!result_code);

            //wait for each thread to complete
            for(i=0;i<NUM_THREADS;i++){
                result_code=pthread_join(threads[i],NULL);
                assert(!result_code);
            }

            printf("Main -> Finished\n");

            return(EXIT_SUCCESS);
    }

文件 func.h 具有以下函数:

f1(int, int);
f2(int, int);
f3(int, int);

目标文件是老师给的，所以我只能上传给大家下载。这些函数仅在几毫秒内执行某些任务。

func.o: https://ufile.io/uzhwf注意:我之前有一篇文章太困惑了(抱歉，第一次在 Stackoverflow 上发帖)。感谢所有花时间帮助我的人。

更新:更新了代码并上传了 func.o。UPDATE1:添加了一些错误检查并使用 sched_get_priority_max 更改了 sched_priority。现在我在 ff3(函数)的 sched_setscheduler 中得到了“核心转储”。

Answer 1

So, the objective of the code is to run 3 threads using only 1 core, so that i can use it to schedule tasks, and to measure computation and response times.

如果限制为一个核心，则一次最多运行一个线程。但这并不能阻止核心快速或缓慢地从一项任务切换到另一项任务。

Each one have different priorities so that there's always only 1 thread running.

这不是优先级的运作方式。如果您为某人分配三项任务并告诉他们其中一项任务的优先级较低，这并不意味着他们在其他任务完成之前不会执行该任务。这意味着当他们有选择时，他们会更愿意做其他任务。但有时他们别无选择。

在您的代码中，当一个线程处于 sleep 状态时，核心无法在该任务上取得进展，直到 sleep 完成。因此，它可能必须在优先级较低的任务上取得进展。如果您根本不希望某个任务在发生某些事情之前完成，请不要要求系统执行该任务，直到您希望它完成为止。

尚不清楚您的实际目标是什么，因此给您什么建议也不清楚。但是，如果您绝对必须阻止某些工作完成，则必须明确编写代码，通过在执行该代码之前等待其他事情发生来阻止该代码的执行。

如果您不希望其中一个线程在其他线程之一完成之前执行任何工作，那么创建三个线程似乎会适得其反。如果您想要纯粹串行完成工作，请使用相同的线程来完成。