Discussion :

[vodevil]

J'ai un problème avec Thread::Queue auquel je ne parvient pas a trouver de solution j'invoque ma classe comme ceci

Code :

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

1
2
3
4
5
6
7
8
9
10
sub new {
    my ($class, %cnf) = @_;
    my $gd     = delete $cnf{'gd'};
    my $list   = delete $cnf{'list'};
    my $self = bless {
        graph  => $gd,
        job    => $list
    }, $class;
    return $self;
}

en lui passant en paramètre deux références a Thread::Queue etant donnée que j'utilise deux files d'attente comme ceci

Code :

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

1
2
3
4
5
6
7
8
my $DataQueue  = Thread::Queue->new;
my $DataQueue2 = Thread::Queue->new;
 
 
my $vector = Vector->new( 
              gd      => \$DataQueue2,
              list    => \$DataQueue
);

j'ai essayé deux méthodes pour utiliser ces références dans ma classe rien n'y fait :

Code :

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

1
2
$self->{job}->enqueue("data");
${$self->{'job'}}->enqueue("data");

je ne voie vraiment pas d'ou vient le problème

thx

[Woufeil]

Je suis sûr de rien mais ptet bien que :

Code :

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

($self->{job})->enqueue("data");

ffonctionnera. Au pire, si ça marche pas, ceci :

Code :

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

1
2
my $var = $self->{job};
$var->enqueue("data");

devrait marcher.

En fait, l'opérateur -> est associatif à droite, je pense que Perl croit que enqueue est une variable de %self. Enfin bin, dit moi si ça marche

[vodevil]

merci Woufeil mai sa ne marche pas

[Woufeil]

Rhoooooo, j'avais même pas vu la grosse erreur

$DataQueue et $DataQueue2 sont déjà des références, pourquoi dans la table de hachage passé en paramètres à ton constructeur tu passes une référence à ces variables ? Là tu est en train de passer une référence de référence
Passe directement $DataQueue et $DataQueue2. J'ai testé, ça marche.

[Jedai]

J'ai un problème avec Thread::Queue auquel je ne parvient pas a trouver de solution j'invoque ma classe comme ceci

Code :

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

1
2
3
4
5
6
7
8
9
10
sub new {
    my ($class, %cnf) = @_;
    my $gd     = delete $cnf{'gd'};
    my $list   = delete $cnf{'list'};
    my $self = bless {
        graph  => $gd,
        job    => $list
    }, $class;
    return $self;
}

A quoi bon les delete ? %cnf étant lexical sera de toute façon détruit à la fin de l'appel.

en lui passant en paramètre deux références a Thread::Queue etant donnée que j'utilise deux files d'attente comme ceci

Code :

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

1
2
3
4
5
6
7
8
my $DataQueue  = Thread::Queue->new;
my $DataQueue2 = Thread::Queue->new;
 
 
my $vector = Vector->new( 
              gd      => \$DataQueue2,
              list    => \$DataQueue
);

Pourquoi passer des référence sur des références ? (un objet est déjà une référence)

j'ai essayé deux méthodes pour utiliser ces références dans ma classe rien n'y fait :

Code :

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

1
2
$self->{job}->enqueue("data");
${$self->{'job'}}->enqueue("data");

je ne voie vraiment pas d'ou vient le problème

thx

La deuxième syntaxe devrait fonctionner, ou peut-être :

Code :

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

1
2
 
(${$self->{'job'}})->enqueue("data");

Mais si tu fais ça dans un contexte multithread, rapelle toi que les objets ne peuvent pas être partagés. Ca peut expliquer ton problème.

--
Jedaï

[vodevil]

Aucune des solutions ne fonctionne c'est sans doute un problème avec les threads , je vais sans doute créer ma propore méthode de file d'attente

[vodevil]

J'a i fait un petit système de file d'attente qui marche meme avec des threads , mais voila j'ai un soucie d'un autre ordre je n'arrive pas a mettre une donnée en file d'attente puis a la récupérer de l'autre coté sans fermer la fonction principale . un exemple valant mieux qu'une longue et mauvaise explication voila mon code

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
package Vodevil::Resource::Queue;
 
sub new { 
  my $class = shift;
  my @queue = @_;
  return \@queue, $class;
}
 
sub enqueue {
  my $q = shift;
  push( @$q, @_);
}
 
sub dequeue { 
  my $q = shift;
  return shift @$q;
}
 
sub flush {
 my $q = shift;
 @$q = ();
}
 
sub count {
 my $q = shift;
 return scalar ( @$q );
}

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
#!/usr/bin/perl -w
package teste;
 
sub new {
    my ($class, %cnf) = @_;
    my $list   = $cnf{'list'};
    my $self = bless {
        job    => $list
    }, $class;
    return $self;
}
 
 
 
sub mettre {
my $self = shift;
 for (0..1000000) {
   $self->{job}->enqueue( $_ );
 }
}
 
 
package main;
use Vodevil::Resource::Queue;
import teste;
 
my $queue = Vodevil::Resource::Queue->new();
 
my $teste = teste->new(
              list => $queue
            );
 
   $teste->mettre();
 
 
sub evalqueue {
 while ( scalar( @$queue ) > 0 ) {
   my $element = $queue->dequeue;
   print "$element\n";
 }
 sleep(1);
 evalqueue();
}
 
evalqueue();

Enfaite le problème est que je doit attendre l'ensemble des données soit chargés par mettre() et que celui ci ce finisse pour pouvoir lire la file d'attente ce qui pose problème . Quelqu'un aurait il une idée pour pallier a ce problème ?

merci

[scaleo]

As tu essayé de forker le fils lance la fonction principale qui remplie la file et le père lui récupère les données

[Jedai]

C'est une blague ? Tu ne crées même pas de thread, à quoi t'attendais-tu ? En plus tu es en train de faire de grosses bétises : recréer une classe pour les queues est inutile, je ne vois pas ce que ta classe apporte de plus (en fait elle a même moins de capacités) et en plus elle est complètement buguée (tu ne lockes jamais rien et tu es donc totalement ouvert à toutes les problèmes de synchronisations des threads...).

Dis nous plutôt ce que tu veux faire, que nous t'expliquions quelle méthode employer.

--
Jedaï

[vodevil]

En fait je veut juste passer des données d'un thread a l'autre, je n'y suis pas arrivé j'ai donc fait ce module pour voir d'ou pourrais bien venir le problème.

[Jedai]

Ce code fonctionne-t-il sur ta machine ?

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
 
#! /usr/bin/perl
use strict; use warnings;
 
use threads;
use Thread::Queue;
 
my $q = Thread::Queue->new();
 
my $t = threads->create(\&hello);
my $t2 = threads->create(\&world);
 
sub hello {
        $q->enqueue( "Hello", "World" );
}
 
sub world {
        print $q->dequeue();
        print " ";
        print $q->dequeue();
        print "\n";
}
 
$t->join();
$t2->join();
__END__

--
Jedaï

[vodevil]

Oui ce code fonctionne parfaitement

[scaleo]

Si j'ai bien compris sa ne marche pas avec du récursif et deux files d'attente ?

voila une piste j'ai fait un essaie 30s juste pour voir si sa marchais

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
#! /usr/bin/perl
use strict;
use warnings;
 
use threads;
use Thread::Queue;
 
my $q = Thread::Queue->new();
 
my $t = threads->create(\&hello);
my $n = threads->create(\&hello2);
my $t2 = threads->create(\&world);
my $n2 = threads->create(\&world2);
 
sub hello {
        $q->enqueue( "Hello", "World" );
 sleep(1); # juste pour éviter un deep recurs
 hello();
}
 
 
sub hello2 {
        $q->enqueue( "bonjour", "le monde" );
 sleep(1); # juste pour éviter un deep recurs
 hello2();
}
 
sub world {
        print $q->dequeue();
        print " ";
        print $q->dequeue();
        print "\n";
  sleep(1);
  world();
}
 
sub world2 {
        print $q->dequeue();
        print " ";
        print $q->dequeue();
        print "\n";
  sleep(1);
  world2();
}
 
$t->join();
$t2->join();
$n->join();
$n2->join();
__END__

[scaleo]

J'ai relu ton post, parce que j'avais un doute sur ma réponse .

En fait tu as un script qui appel une classe a laquel tu passe les files d'attente et dans ton script principale tu récupère les données qui y ont été mises par la classe.

J'ai fait un script pour comprendre ton problème et je doit avouer qu'il est très heu chiant

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
#!/usr/bin/perl -w
package teste;
use threads;
use Thread::Queue;
 
sub new {
    my ($class, %cnf) = @_;
    my $l    = delete $cnf{'gd'};
    my $self = bless {
        t => $l
    }, $class;
    return $self;
}
 
my $self;
 
sub hello {
   $self = shift unless defined $self;
   $self->{t}->enqueue( "Hello", "World" );
 #sleep(1);
 #hello();
}
 
 
package main;
use strict;
use warnings;
import teste;
use threads;
use Thread::Queue;
 
my $q = Thread::Queue->new();
 
my $i = teste->new( gd => $q );
 
   $i->hello();
 
#my $t = threads->create(\&hello);
my $t2 = threads->create(\&world);
sub world {
        print $q->dequeue();
        print " ";
        print $q->dequeue();
        print "\n";
 world();
}
 
#$t->join();
$t2->join();

Tel quel ce code fonctionne mais et si on change la fonction hello() comme cela :

Code :

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

1
2
3
4
5
6
sub hello {
   $self = shift unless defined $self;
   $self->{t}->enqueue( "Hello", "World" );
 sleep(1);
 hello();
}

le script bloque car il n'y a jamais de valeur de retour a $i->hello();

[scaleo]

J'ai trouvé la solution il faut forker ,

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
#!/usr/bin/perl -w
package teste;
#use threads;
#use Thread::Queue;
 
sub new {
    my ($class, %cnf) = @_;
    my $l    = delete $cnf{'gd'};
    my $self = bless {
        t => $l
    }, $class;
    return $self;
}
 
my $self;
 
sub hello {
  $self = shift unless defined $self;
  $self->{t}->enqueue( "Hello", "World" );
 sleep(1);
 hello();
}
 
 
package main;
use strict;
use warnings;
import teste;
use threads;
use Thread::Queue;
 
my $q = Thread::Queue->new();
 
my $i = teste->new( gd => $q );
 my $pid = fork;
 
 if ( $pid == 0 )
 {
     $i->hello();
 }
  else
 {
    my $t2 = threads->create(\&world);
       $t2->join();
  }
 
 
sub world {
        print $q->dequeue();
        print " ";
        print $q->dequeue();
        print "\n";
 world();
}

Donc si comme tu fait tu utilise deux files d'attente il faut forker deux fois

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
 
 if ( $pid == 0 ) {
     $i->hello();
 }
  else {
   # le thread n'a plus vraiment d'interet
   # my $t2 = threads->create(\&world);
   #   $t2->join();
 
    my $uid = fork;
    if ($uid == 0 ) {
     main->world();
   }
     else {
     main->filedeux();
   }
  }

Ont peut sans doute faire plus propre mais j'ai pas trouvé

[Jedai]

On peut faire plus propre, en fait je ne vois même pas pourquoi tu voudrais forker (ce qui foutra la pagaille dans les threads !) ... Par ailleurs tes codes sont plus qu'hasardeux, utiliser deux Thread::Queue ne pose pas de problème particulier par rapport à l'usage d'un seul... Ce code fonctionne très bien :

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
#!/usr/bin/perl -w
package teste;
 
sub new {
    my ($class, %cnf) = @_;
    my $list   = $cnf{'list'};
    my $self = bless {
        job    => $list
    }, $class;
    return $self;
}
 
 
 
sub mettre {
my $self = shift;
 for (0..1000000) {
   $self->{job}->enqueue( $_ );
 }
 $self->{job}->enqueue( 'end');
}
 
 
package main;
use strict; use warnings;
 
use threads;
use Thread::Queue;
 
my $queue = Thread::Queue->new();
 
my $teste = teste->new(
              list => $queue
            );
 
my $t1 = threads->create( sub { $teste->mettre() } );
my $t2 = threads->create( \&evalqueue );
 
sub evalqueue {
 while ( $queue->pending() > 0 ) {
   my $element = $queue->dequeue();
   return if( $element eq 'end' ); 
   print "$element\n";
 }
 sleep(1);
 evalqueue();
}
 
$t2->join();
$t1->join();
__END__

--
Jedaï

[scaleo]

Effectivement c'est bien plus propre et conçis