L'Affinité CPU Masques (Mettre des Threads sur les Processeurs différents)

J'ai 4 fils, et je suis en train de mettre le thread 1 à exécuter sur le PROCESSEUR 1, le thread 2 sur le PROCESSEUR 2, etc.
Cependant, lorsque je lance mon code ci-dessous, les masques d'affinité sont de retour les valeurs correctes, mais quand je fais un sched_getcpu() sur les fils, ils retournent tous qu'ils sont en cours d'exécution sur le PROCESSEUR 4.

Ce que quelqu'un sait ce que mon problème, c'est?

Merci d'avance!

#define _GNU_SOURCE
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>

void *pthread_Message(char *message)
{
    printf("%s is running on CPU %d\n", message, sched_getcpu());
}

int main()
{
    pthread_t thread1, thread2, thread3, thread4;
    pthread_t threadArray[4];
    cpu_set_t cpu1, cpu2, cpu3, cpu4;
    char *thread1Msg = "Thread 1";
    char *thread2Msg = "Thread 2";
    char *thread3Msg = "Thread 3";
    char *thread4Msg = "Thread 4";
    int thread1Create, thread2Create, thread3Create, thread4Create, i, temp;

    CPU_ZERO(&cpu1);
    CPU_SET(1, &cpu1);
    temp = pthread_setaffinity_np(thread1, sizeof(cpu_set_t), &cpu1);
    printf("Set returned by pthread_getaffinity_np() contained:\n");
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu1))
            printf("CPU1: CPU %d\n", i);

    CPU_ZERO(&cpu2);
    CPU_SET(2, &cpu2);
    temp = pthread_setaffinity_np(thread2, sizeof(cpu_set_t), &cpu2);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu2))
            printf("CPU2: CPU %d\n", i);

    CPU_ZERO(&cpu3);
    CPU_SET(3, &cpu3);
    temp = pthread_setaffinity_np(thread3, sizeof(cpu_set_t), &cpu3);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu3))
            printf("CPU3: CPU %d\n", i);

    CPU_ZERO(&cpu4);
    CPU_SET(4, &cpu4);
    temp = pthread_setaffinity_np(thread4, sizeof(cpu_set_t), &cpu4);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu4))
            printf("CPU4: CPU %d\n", i);

    thread1Create = pthread_create(&thread1, NULL, (void *)pthread_Message, thread1Msg);
    thread2Create = pthread_create(&thread2, NULL, (void *)pthread_Message, thread2Msg);
    thread3Create = pthread_create(&thread3, NULL, (void *)pthread_Message, thread3Msg);
    thread4Create = pthread_create(&thread4, NULL, (void *)pthread_Message, thread4Msg);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    pthread_join(thread4, NULL);

    return 0;
}

OriginalL'auteur hahuang65 | 2010-04-01

16

Vous essayez de définir l'affinité de threads que vous n'avez pas initialisé.

Edit: Ok, laissez-moi vous donner quelques infos:

Ne pas mélanger des poignées de thread (la chose que vous stockez dans le pthread_t variable) et ce qu'ils représentent (un thread d'exécution qui exécute quelque part). Ce que vous essayiez de le faire est de fixer une propriété d'un fil avant qu'il ne commence, avec une API qui requiert l'objet thread. Comme il arrive pthread_create crée l'objet et commence l'exécution dans le même temps, afin d'essayer d'utiliser pthread_setaffinity_np n'est pas la bonne façon de faire (ce qui est utile si vous souhaitez changement l'affinité d'un thread en cours d'exécution).

Mais... pthread_create a un paramètre d'attribut (que vous êtes en passant NULL). C'est le stockage de l'information de la façon dont vous souhaitez que le thread d'être créé.

Affinité est l'un des attributs que vous pouvez définir à travers ce paramètre. Voir l'homme-page de documentation pour pthread_attr_init et pthread_attr_setaffinity_np pour comment exactement

j'ai donc à pthread_create() en premier? Mais que l'exécution de la fonction spécifiée... je ne suis pas trop sûr de comprendre ce concept. Donc je devrais mettre le setaffinity fonction dans ma pthread_Message() la fonction?
Vous n'avez pas besoin d'exécuter le thread pour très long, c'est à dire qu'il pourrait être la première chose que le nouveau thread. Cela signifierait qu'il obtient reportée, si le nouveau cpu masque ne comprend pas son cpu actuel.
Je ne comprends toujours pas... je veux mettre le masque d'affinité APRÈS pthread_create(), au COURS de la fonction pthread_create() appelle, ou AVANT pthread_create()?
J'ai ajouté un peu plus d'info, espérons que cette aide.

OriginalL'auteur Bahbar

Voici ce que vous cherchez. Je sais que c'est une réponse tardive, mais cela peut aider les autres.

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>

#include <unistd.h>

int   getNumberOfCpus( void )
{
    long nprocs       = -1;
    long nprocs_max   = -1;

    # ifdef _SC_NPROCESSORS_ONLN
    nprocs = sysconf( _SC_NPROCESSORS_ONLN );
    if ( nprocs < 1 )
    {
        //std::cout << "Could not determine number of CPUs on line. Error is  " << strerror( errno ) << std::endl;
        return 0;
    }

    nprocs_max = sysconf( _SC_NPROCESSORS_CONF );

    if ( nprocs_max < 1 )
    {
        //std::cout << "Could not determine number of CPUs in host. Error is  " << strerror( errno ) << std::endl;
        return 0;
    }

    //std::cout << nprocs < " of " << nprocs_max << " online" << std::endl;
    return nprocs; 

#else
    //std::cout << "Could not determine number of CPUs" << std::endl;
    return 0;
#endif
}

void *pthread_Message( void *ptr )
{
    sleep(10);
    char *message;
    message = (char *) ptr;
    printf("%s \n", message);
    cpu_set_t      l_cpuSet;
    int            l_maxCpus;
    int            j;
    unsigned long  l_cpuBitMask;

    CPU_ZERO( &l_cpuSet );
    printf("get affinity %d\n",pthread_getaffinity_np(pthread_self()  , sizeof( cpu_set_t ), &l_cpuSet ));
    //printf("cpuset %d\n",l_cpuSet);
    printf (" thread id %u\n", pthread_self());      

    if ( pthread_getaffinity_np(pthread_self()  , sizeof( cpu_set_t ), &l_cpuSet ) == 0 )
        for (int i = 0; i < 4; i++)
            if (CPU_ISSET(i, &l_cpuSet))
                printf("XXXCPU: CPU %d\n", i);
    for (long i=0; i< 10000000000; ++i);
}

int main()
{
    pthread_t thread1, thread2, thread3, thread4;
    pthread_t threadArray[4];
    cpu_set_t cpu1, cpu2, cpu3, cpu4;
    const char *thread1Msg = "Thread 1";
    const char *thread2Msg = "Thread 2";
    const char *thread3Msg = "Thread 3";
    const char *thread4Msg = "Thread 4";
    int thread1Create, thread2Create, thread3Create, thread4Create, i, temp;

    thread1Create = pthread_create(&thread1, NULL, &pthread_Message, (void*)thread1Msg);
    sleep(1);
    thread2Create = pthread_create(&thread2, NULL, &pthread_Message, (void*)thread2Msg);
    sleep(1);
    thread3Create = pthread_create(&thread3, NULL, &pthread_Message, (void*)thread3Msg);
    sleep(1);
    thread4Create = pthread_create(&thread4, NULL, &pthread_Message, (void*)thread4Msg);


    CPU_ZERO(&cpu1);
    CPU_SET(0, &cpu1);
    temp = pthread_setaffinity_np(thread1, sizeof(cpu_set_t), &cpu1);
    printf("setaffinity=%d\n", temp);
    printf("Set returned by pthread_getaffinity_np() contained:\n");
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu1))
            printf("CPU1: CPU %d\n", i);

    CPU_ZERO(&cpu2);
    CPU_SET(1, &cpu2);
    temp = pthread_setaffinity_np(thread2, sizeof(cpu_set_t), &cpu2);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu2))
            printf("CPU2: CPU %d\n", i);

    CPU_ZERO(&cpu3);
    CPU_SET(2, &cpu3);
    temp = pthread_setaffinity_np(thread3, sizeof(cpu_set_t), &cpu3);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu3))
            printf("CPU3: CPU %d\n", i);

    CPU_ZERO(&cpu4);
    CPU_SET(3, &cpu4);
    temp = pthread_setaffinity_np(thread4, sizeof(cpu_set_t), &cpu4);
    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &cpu4))
            printf("CPU4: CPU %d\n", i);

    //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpu1);



    //pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpu1);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    pthread_join(thread4, NULL);

    return 0;
}

OriginalL'auteur John Samson

2

Je pense que le plus simple serait de donner le CPU masque comme un paramètre pour chaque thread et ont le thread demande étant donné l'affinité de lui-même, comme dans l'exemple ici: pthread_setaffinity_np(3).

Comment puis-je savoir quel thread (dans mon cas, thread1, thread2, thread3, ou thread4) appelle pthread_self()?
Je pense que Bahbar déjà répondu à cette utilisation de la fonction de thread paramètre, ce qui pourrait vraiment le point à quelque chose, dire une structure qui contient le masque d'affinité le thread demande pour lui-même. Attention cependant à ne pas partager la même structure exemple entre les threads de travail.

OriginalL'auteur Nikolai Fetissov

Vous devez vous connecter pour publier un commentaire.