Discussion :

[djuju]

il plante en premier lieu au memcpy

Tu peux le remplacer par un t[1] = t[0], mais ça devrait fonctionner...

[arnoreffay]

voila ton code que j'ai recorriger. ce sont de betes struct

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <pthread.h>
 
 
struct structure {
 
  //int entier;
  int taille;
  int position;
  int nbRech;
  int *tab;
  int indice;
 
};
 
void *fonction (void * data)
{
 
  printf("thread cree\n");
  int fin = ((struct structure *)data)->taille;
  printf("%d\n", ((struct structure *)data)->taille);
  int i;
 
  for(i=0; i<fin && ((struct structure *)data)->position==-1;i++){
 
    if(((struct structure *)data)->tab[i]==((struct structure *)data)->nbRech)((struct structure *)data)->position=i+1;
  }
 
  pthread_exit(data);
}
 
int main()
{
  int i;
  int x=10;
  int nbUti;
 
  int *pti, *ptd;
  pti=(int*)malloc(sizeof(int)*x);
  if(pti!=NULL){
    ptd = pti;
    for(i=0;i<x;i++){
      *pti = random() % (100-1) +1;
      printf("%d\n", *pti);
      pti++;
    }
  }
 
  printf("Entrez un nombre a rechercher\n");
  scanf("%d", &nbUti);
  printf("%d\n", nbUti);
 
   pthread_attr_t attr;
        pthread_attr_init(&attr);
 
        pthread_t *  p;
 
        p = (pthread_t *  )calloc ( 2 , sizeof(pthread_t));
 
        struct structure *  t;
 
        t = calloc (2,sizeof(struct structure));
 
  // Attention ici, modif
  t[0].position = -1;
  t[0].tab=ptd;
  t[0].nbRech=nbUti;
  memcpy(&t[1], &t[0], sizeof(struct structure));
 
  t[0].taille = x/2;
  t[1].taille = x-(x/2);
 
  for (i=0;i<2;++i){
    // Attention ici, modif
    if  (pthread_create(p+i,&attr,fonction,(void *)(&t[i])) != 0)
    {
      perror("Rate:");
      exit(1);
    }
 
  }
 
  // Attention ici, modif
  //struct structure * * ret;
  //ret = calloc (2,sizeof(struct structure *));
 
  for(i=0;i<2;++i){
    // Attention ici, modif
    void *ret;
    pthread_join (p[i], &ret); // Attention ici, tu devrais vérifier la valeur de retour de ton join
 
    if(((struct structure*)ret)->position==-1)
      printf("le nombre entr� n'est pas dans le tableau\n");
    else
      printf("le nombre entr� se trouve en position : %d\n", t[i].position);
  }
 
  /* p++;
  ret++;
 
  pthread_join (*(p),(void**)(ret));*/
 
 
  // Attention ici, modif
  free(p);
  free(t);
 
  return(EXIT_SUCCESS);
}

[djuju]

ca yest j'ai reussi à compiler ton programme, mais il cherche que dans le premier tableau tout les deux. il fait de 0 a 4 ensuite il continue pas.

Tu n'as pas de 1ier et 2ieme tableau, ou il y a un truc que j'ai loupé... Pour moi tu n'as que pdt et tu le remplis mal (je viens de le voir)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
  int *pti, *ptd;
  pti=(int*)malloc(sizeof(int)*x);
  if(pti!=NULL){
    ptd = pti;
    for(i=0;i<x;i++){
      *pti = random() % (100-1) +1;
      printf("%d\n", *pti);
      // Faux !!
      //pti++;
      pti+=sizeof(int);
    }
  }

[djuju]

Note aussi que tu demande à tes deux threads de faire quasiment la même chose.
Ton thread 1 cherche de l'index 0 à x/2
Ton thread 2 cherche de l'index 0 à x-x/2 (donc soit x/2, soit x/2+1)

Si tu veux que thread 1 cherche de 0 à x/2 et thread 2 de x/2+1 à x-1, il faut que "structure" contienne les index de début et fin de ta recherche.

[arnoreffay]

oui, je suis d'accord. y a qu'un tableau, je me suis mal exprimé mais il le remplit bien, il m'affcihe bien un tableau de 10 cases avec des int aléatoires. cependant le premier thread cherche de 0 à 4 et le second de 5 à 9. Ici il fait deux fois de 0 à 4

[arnoreffay]

c ce que je me disais faire un indice dans la structure qui continue l'incrémentation sans recommencer à 0, j'ai essayé mais il recommence à 0.
la je fais ca car si l'uti demande 11 cases, le premier thread fera de 0 à 4 et l'autre de 5 à 11.
car normalement c'est l'utilisateur qui rentre la taille du tableau. mais la pour essayer j'ai mis une taille fixe

[djuju]

oui, je suis d'accord. y a qu'un tableau, je me suis mal exprimé mais il le remplit bien, il m'affcihe bien un tableau de 10 cases avec des int aléatoires. cependant le premier thread cherche de 0 à 4 et le second de 5 à 9. Ici il fait deux fois de 0 à 4

C'est une vue de l'esprit. En fait, comme tu alloue ton tableau avec malloc, chaque cellule contient une valeur aléatoire (celle qui était déjà là).
Mais comme tu fais pti++, tu ne fais avancé ton pointer que d'un byte et pas de 4 (qui est la taille d'un int).

Par ex., ton premier rand te donne 622237156.
La premier itération de ton for met bien la valeur 622237156 (0x251695E4) dans la première cellule.
En mémoire, tu as donc:
ptd = [0x251695E4, 0x????????, 0x????????....]
2ieme itération, tu tire 890406308 (0x351285A4) et tu l'écris à ptd + 1
En mémoire, tu as donc:
ptd = [0x25351285, 0xA4??????, 0x????????....]
Ton premier index vaut maintenant: 624235141
Et ton deuxième, t'en sais rien, ca dépend de ce qu'il y avait dans ta mémoire.

[djuju]

Et comme ça, ? C'est mieux non

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <pthread.h>
 
 
struct structure {
 
  //int entier;
  int taille;
  int position;
  int positionDepart;
  int positionFin;
  int nbRech;
  int *tab;
  int indice;
 
};
 
void *fonction (void * data)
{
 
  printf("thread cree\n");
  int fin = ((struct structure *)data)->taille;
  printf("%d\n", ((struct structure *)data)->taille);
  int i;
 
  for(i=((struct structure *)data)->positionDepart; i<((struct structure *)data)->positionFin && i<((struct structure *)data)->taille && ((struct structure *)data)->position==-1;i++){
 
    if(((struct structure *)data)->tab[i]==((struct structure *)data)->nbRech)((struct structure *)data)->position=i+1;
  }
 
  pthread_exit(data);
}
 
int main()
{
  int i;
  int x=10;
  int nbUti;
 
  int *pti, *ptd;
  pti=(int*)malloc(sizeof(int)*x);
  if(pti!=NULL){
    ptd = pti;
    for(i=0;i<x;i++){
      *pti = random() % (100-1) +1;
      printf("%d\n", *pti);
      pti++;
    }
  }
 
  printf("Entrez un nombre a rechercher\n");
  scanf("%d", &nbUti);
  printf("%d\n", nbUti);
 
   pthread_attr_t attr;
        pthread_attr_init(&attr);
 
        pthread_t *  p;
 
        p = (pthread_t *  )calloc ( 2 , sizeof(pthread_t));
 
        struct structure *  t;
 
        t = calloc (2,sizeof(struct structure));
 
  // Attention ici, modif
  t[0].position = -1;
  t[0].tab=ptd;
  t[0].nbRech=nbUti;
  t[0].taille = x;
  memcpy(&t[1], &t[0], sizeof(struct structure));
 
  t[0].positionDepart = 0;
  t[0].positionFin = x/2;
 
  t[1].positionDepart = x/2;
  t[1].positionFin = x;
 
  for (i=0;i<2;++i){
    // Attention ici, modif
    if  (pthread_create(p+i,&attr,fonction,(void *)(&t[i])) != 0)
    {
      perror("Rate:");
      exit(1);
    }
 
  }
 
  // Attention ici, modif
  //struct structure * * ret;
  //ret = calloc (2,sizeof(struct structure *));
 
  for(i=0;i<2;++i){
    // Attention ici, modif
    void *ret;
    pthread_join (p[i], &ret); // Attention ici, tu devrais vérifier la valeur de retour de ton join
 
    if(((struct structure*)ret)->position==-1)
      printf("le nombre entr� n'est pas dans le tableau\n");
    else
      printf("le nombre entr� se trouve en position : %d\n", t[i].position);
  }
 
  /* p++;
  ret++;
 
  pthread_join (*(p),(void**)(ret));*/
 
 
  // Attention ici, modif
  free(p);
  free(t);
 
  return(EXIT_SUCCESS);
}

[arnoreffay]

Merci mec, ca marche, je te dois une fière chandelle merci en tout cas
t'assure.
pour pti++;
c'est mon profs qui m'a conseillé de faire ca. mais je savais qu'un int ne valait pas toujours 4bytes. comme c'est une vue d'esprit
je te dois une bouteille
bonne soirée, je passe au rapport

[djuju]

Merci mec, ca marche, je te dois une fière chandelle merci en tout cas
t'assure.
pour pti++;
c'est mon profs qui m'a conseillé de faire ca. mais je savais qu'un int ne valait pas toujours 4bytes. comme c'est une vue d'esprit
je te dois une bouteille
bonne soirée, je passe au rapport

Note qu'un int (en c++) fait tjrs 4B : http://msdn.microsoft.com/en-us/libr...=vs.80%29.aspx

Oublis pas de noter le post comme "résolut" STP.

Contant de t'avoir aidé !
Bonne chance dans tes études !

[Kirilenko]

Salut,

Je sais que le sujet est résolu, mais il serait peut-être bon de prendre de bonnes habitudes de codage.
Avant de continuer, tu devrais mettre à plat ton code, prendre un papier et un crayon, et dégager les différents composants de ton code. Ici, on peut dégager trois grands traitements :

1. Génération d'un tableau aléatoirement par le thread principal.
2. Recherche du premier thread dans la première moitié du tableau.
3. Recherche du deuxième thread dans la deuxième moitié du tableau.

Commençons par l'étape 1. Au vu de l'énoncé, on se rend compte qu'on peut dégager une fonction, disons fill_array, qui, à partir d'une taille donnée, retourne un tableau rempli aléatoirement. Pour faire en sorte que le code soit ré-entrant, on indique dans la documentation la nécessité d'initialisation de la graine de génération aléatoire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdlib.h>
 
/*
 * The `fill_array` function fills the array `array` of `size` elements with
 * pseudo-random integers generated by `rand`. An initialisation of `rand`
 * seed is required (man srand(3)).
 */
static void fill_array(int *array, size_t size)
{
	size_t i;
	for (i = 0; i < size; ++i)
		array[i] = rand();
}

On remarque par ailleurs que les traitements 2 et 3 peuvent être regroupés. Il suffira d'envoyer à la routine du thread les indices de début et de fin de recherche. Définissons donc une fonction, dont le prototype est compatible avec l'argument de pthread_create, qui recherche une valeur dans une partie donnée du tableau, et retourne l'indice de la première occurrence de la valeur en question.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <pthread.h>
 
/*
 * The `struct search` data type defines a set of data required to do a
 * multi-threaded search by using the `search_array` function. The following
 * members shall be initialized: `array` (the array where the research
 * should be done),  `val` (the element value to search), `start` (the index
 * of search start) and `end` (the index of search end).
 */
struct search {
	int *array;
	int val;
	size_t start;
	size_t end;
};
 
/*
 * The `search_array` function performs a search with the meta-datas included
 * in the `struct search` data type. Doesn't use the heap since the return value
 * is an `int`.
 */
static void *search_array(void *p)
{
	struct search *data = p;
	int first_occ = -1;
	size_t i;
 
	for (i = data->start; i < data->end; ++i) {
		if (data->array[i] == data->val) {
			first_occ = (int)i;
			break;
		}
	}
 
	pthread_exit((void *)first_occ);
}

À partir des deux fonctions et du type de donnée définis, on peut aisément ordonnancer le tout.

Bonne soirée.