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

Question

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

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

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

有代码： #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include

#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 1n");
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 sn", 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 sn", diff, diff / (pow(10,9)));
printf("Task 1 finishedn");
}
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 2n");
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 sn", 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 sn", diff, diff / (pow(10,9)));
printf("Task 2 finishedn");
}
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 3n");
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 sn", 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 sn", diff, diff / (pow(10,9)));
printf("Task 3 finishedn");
}
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 -> Finishedn");
return(EXIT_SUCCESS);
}

文件 func.h 获得了以下函数：

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

目标文件是由老师提供的，所以我所能做的就是上传它供你们下载。这些函数仅在几毫秒内执行某些任务。

功能：https://ufile.io/uzhwf 注意：我之前的帖子太混乱了(对不起，第一次在Stackoverflow上发帖(。感谢所有花时间帮助我的人。

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

Answer 1

因此，代码的目标是仅使用 1 个内核运行 3 个线程，以便我可以使用它来调度任务，并测量计算和响应时间。

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

每个线程都有不同的优先级，因此始终只有 1 个线程在运行。

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

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

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

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