execution du code de sum d’une matrice N*N

nor@nor-HP-EliteBook-x360-1030-G2:~/ana$ gcc sum.c -pthread

sum.c: In function ‘func’:
sum.c:14:6: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
14 | row =(int)arg;
| ^
sum.c: In function ‘main’:
sum.c:42:37: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
42 | pthread_create(&thread[i],NULL,func,(void *)i);
| ^
sum.c:47:66: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
47 | printf("Main: joined with %d [%lu] : status =%d \n", i,thread[i],(int)status);
| ^
nor@nor-HP-EliteBook-x360-1030-G2:~/ana$ ./sum
bash: ./sum: No such file or directory
nor@nor-HP-EliteBook-x360-1030-G2:~/ana$ ./sum.c
bash: ./sum.c: Permission denied
nor@nor-HP-EliteBook-x360-1030-G2:~/ana$ ./a.out
Main : initialize A matrix
1 2 3 4 0
5 6 7 8 0
9 10 11 12 0
13 14 15 16 0
Main: create 4 threads
Thread 0 [139820629378816] computes sum of row 0
Threads 0 [139820629378816] done: sum[0] =10
Thread 1 [139820620986112] computes sum of row 1
Threads 1 [139820620986112] done: sum[1] =26
Thread 2 [139820612593408] computes sum of row 2
Threads 2 [139820612593408] done: sum[2] =42
Main: try to join with threads
Thread 3 [139820469982976] computes sum of row 3
Threads 3 [139820469982976] done: sum[3] =58
Main: joined with 0 [139820629378816] : status =0
Main: joined with 1 [139820620986112] : status =0
Main: joined with 2 [139820612593408] : status =0
Main: joined with 3 [139820469982976] : status =0
Main : compute and print total sum: tatal = 136
 CODE:
#include<stdio.h>
#include<stdlib.h>

#include<pthread.h>

#define N 4

int A[N][N], sum[N];

void *func(void *arg){

int j , row;
pthread_t tid = pthread_self();
row =(int)arg;
printf("Thread %d [%lu] computes sum of row %d \n",row,tid,row);
for(j=0 ; j<N ;j++)
sum[row] += A[row][j];
printf("Threads %d [%lu] done: sum[%d] =%d \n", row , tid , row , sum[row]);
pthread_exit((void*)0);

int main(int argc , char *argv[])

{
pthread_t thread[N];
int i,j,r,total=0;
void *status;
printf("Main : initialize A matrix\n");
for(i=0 ; i<N ; i++){
sum[i]=0;
for( j=0 ; j<N ; j++){
A[i][j]=i*N+j+1;
printf("%4d" , A[i][j]);

}
printf("%4d" ,A[i][j]);

printf("\n");
}
printf("Main: create %d threads\n",N);
for(i=0;i<N;i++){
pthread_create(&thread[i],NULL,func,(void *)i);
}
printf("Main: try to join with threads\n");
for( i=0 ; i<N ; i++){
pthread_join(thread[i],&status);
printf("Main: joined with %d [%lu] : status =%d \n", i,thread[i],(int)status);
}
printf("Main : compute and print total sum: ");
for(i=0;i<N;i++)
total += sum[i];

printf("tatal = %d\n",total);
pthread_exit(NULL);

------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------

Voici un exemple de programme en C qui crée autant de threads qu'il y a de processeurs sur la
machine où il est exécuté :
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// Fonction exécutée par chaque thread

void *thread_function(void *arg)
{
printf("Je suis le thread %ld\n", (long)arg);
return NULL;
}

int main(void)
{
int nb_processors = sysconf(_SC_NPROCESSORS_ONLN); // Nombre de processeurs
printf("Il y a %d processeurs sur cette machine\n", nb_processors);

pthread_t threads[nb_processors]; // Tableau de threads

long i;
for (i = 0; i < nb_processors; i++) {
// Création du thread i
int res = pthread_create(&threads[i], NULL, thread_function, (void *)i);
if (res != 0) {
perror("Erreur lors de la création du thread");
return 1;
}
}

// Attente de la fin de chaque thread

for (i = 0; i < nb_processors; i++) {
int res = pthread_join(threads[i], NULL);
if (res != 0) {
perror("Erreur lors de l'attente de la fin du thread");
return 1;
}
}

return 0;
}

Le programme utilise la fonction sysconf pour obtenir le nombre de processeurs sur la machine,
puis crée autant de threads à l'aide de la fonction pthread_create. Chaque thread exécute la
 fonction thread_function, qui affiche simplement un message indiquant son numéro de
thread. Enfin, le programme attend la fin de chaque thread à l'aide de la fonction pthread_join.

Il est important de noter que chaque thread partage les mêmes ressources (variables globales,
fichiers, etc.) que le thread principal. Il faut donc être vigilant lorsque plusieurs threads accèdent
simultanément à ces ressources et mettre en place des mécanismes de synchronisation si nécessaire.

-
=======================================================================
ecrire un programme en c qui demarre autant de threads qu'il y a de processeurs .chaque thread se
place sur un processeurs distinct

Il est impossible de garantir que chaque thread sera exécuté sur un processeur distinct. En effet, c'est
le système d'exploitation qui décide sur quel processeur chaque thread sera exécuté, en fonction de
nombreux facteurs tels que la charge de chaque processeur et la stratégie de planification utilisée.
Toutefois, il est possible de spécifier que chaque thread doit être exécuté sur un processeur distinct
en utilisant la fonction pthread_attr_setaffinity_np. Cette fonction permet de définir les
processeurs sur lesquels le thread peut être exécuté.
Voici un exemple de programme qui crée autant de threads qu'il y a de processeurs et qui essaie de
faire en sorte que chaque thread soit exécuté sur un processeur distinct :
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

// Fonction exécutée par chaque thread

void *thread_function(void *arg)
{
printf("Je suis le thread %ld\n", (long)arg);
return NULL;
}

int main(void)
{
int nb_processors = sysconf(_SC_NPROCESSORS_ONLN); // Nombre de processeurs
printf("Il y a %d processeurs sur cette machine\n", nb_processors);

pthread_t threads[nb_processors]; // Tableau de threads

pthread_attr_t attr;
pthread_attr_init(&attr); // Initialisation des attributs du thread

long i;
for (i = 0; i < nb_processors; i++) {
// Affectation du processeur i au thread
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(i, &cpuset);
int res = pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t),
&cpuset);
if (res != 0) {
 perror("Erreur lors de l'affectation du processeur au thread");
return 1;
}

// Création du thread i
res = pthread_create(&threads[i], &attr, thread_function, (void *)i);
if (res != 0) {
perror("Erreur lors de la création du thread");
return 1;
}
}

// Attente de la fin de chaque thread

for (i = 0; i < nb_processors; i++) {
int res = pthread_join(threads[i], NULL);
if (res != 0) {
perror("Erreur lors de l'attente de la fin du thread");
return 1;
}
}

return 0;
}

====================================================================

Pour récupérer les arguments dans le programme C, on utilise les paramètres argc et
argv
du main. L’entier argc donne le nombre d’arguments rentrés dans la ligne de
commande plus
1, et le paramètre argv est un tableau de chaînes de caractères qui contient comme
éléments :
• Le premier élément argv[0] est une chaîne qui contient le nom du fichier executable
du programme ;
• Les éléments suivants argv[1], argv[2],etc... . sont des chaînes de caractères qui
contiennent les arguments passés en ligne de commande.
=============================================================
Voici comment vous pouvez écrire un programme en C qui crée un thread, lit des
valeurs en C et les passe à un autre thread qui fait la somme de ces valeurs et affiche
le résultat de la somme par un troisième thread sans structure :
1. Incluez les fichiers d'en-tête nécessaires pour utiliser les threads en C :
#include <pthread.h>

2. Déclarez les trois threads et les variables partagées entre les threads :
pthread_t thread1, thread2, thread3;
int values[100]; // tableau pour stocker les valeurs lues
int sum = 0; // variable pour stocker la somme des valeurs
 3. Écrivez la fonction pour le premier thread qui lit les valeurs en C :
void* read_values(void* arg) {
// lire les valeurs et les stocker dans le tableau values
// ...
return NULL;
}

4. Écrivez la fonction pour le deuxième thread qui fait la somme des valeurs :
void* compute_sum(void* arg) {
for (int i = 0; i < 100; i++) {
sum += values[i];
}
return NULL;
}

5. Écrivez la fonction pour le troisième thread qui affiche le résultat de la somme :

void* print_sum(void* arg) {
printf("La somme des valeurs est %d\n", sum);
return NULL;
}

6. Dans la fonction main(), créez les trois threads en appelant pthread_create() et

attendez qu'ils se terminent en appelant pthread_join() :
int main() {
pthread_create(&thread1, NULL, read_values, NULL);
pthread_create(&thread2, NULL, compute_sum, NULL);
pthread_create(&thread3, NULL, print_sum, NULL);

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

return 0;
}

Voilà comment vous pouvez écrire un programme en C qui crée des threads, lit des valeurs en C,
fait la somme de ces valeurs et affiche le résultat de la somme par un troisième thread sans utiliser
de structure.