Petit soucis avec Thread::Queue et une classe

Version imprimable

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

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:

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:

1 2 $self->{job}->enqueue("data"); ${$self->{'job'}}->enqueue("data");
je ne voie vraiment pas d'ou vient le problème :aie:

thx

05/06/2006, 00h02
Woufeil
Je suis sûr de rien mais ptet bien que :

Code:

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

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

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 ;)
05/06/2006, 00h17
vodevil

merci Woufeil mai sa ne marche pas :?
05/06/2006, 09h58
Woufeil

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

$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.

Citation:
Envoyé par 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:

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.
Citation:
Envoyé par vodevil
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:

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)
Citation:
Envoyé par vodevil
j'ai essayé deux méthodes pour utiliser ces références dans ma classe rien n'y fait :
Code:

1 2 $self->{job}->enqueue("data"); ${$self->{'job'}}->enqueue("data");
je ne voie vraiment pas d'ou vient le problème :aie:

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

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ï

05/06/2006, 12h46
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 :roll:

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 :aie: . un exemple valant mieux qu'une longue et mauvaise explication voila mon code
Code:

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:

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

07/06/2006, 17h56
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
07/06/2006, 19h33
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ï
07/06/2006, 21h42
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.

Ce code fonctionne-t-il sur ta machine ?

Code:

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ï

08/06/2006, 15h43
vodevil

Oui ce code fonctionne parfaitement 8-)

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:

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__

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

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 :aie:
Code:

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:

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();

J'ai trouvé la solution :lol: il faut forker 8-) ,

Code:

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:

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é

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:

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ï

09/06/2006, 21h41
scaleo

Effectivement c'est bien plus propre et conçis 8-)