Thread : Invalid value for shared scalar

Version imprimable

01/03/2010, 12h43
ITCsoft54

Thread : Invalid value for shared scalar

Bonjour,

Je développe actuellement un script Perl multi-thread.

Je voudrais utiliser une hashtable d'objets entre plusieurs thread, Cependant lorsque je veux utiliser la hashtable pour stocker mes objets j'obtiens "Invalid value for shared scalar".

Après une recherche google j'ai cru comprendre qu'il fallait utiliser des références d'objet.

J'ai essayé plusieurs syntaxes mais j'ai toujours la même erreur : "Invalid value for shared scalar"

J'ai essayé en autre de faire :
$ma_hashtable{$key}=$mon_objet; (en declarant mon objet my $obj)
$ma_hashtable{$key}={$mon_objet}; (en declarant mon objet my $obj)
$ma_hashtable{$key}=\$mon_objet; (en declarant mon objet my $obj)
$ma_hashtable{$key}=\%mon_objet; (en declarant mon objet my %obj)

au passage un bête $ma_hashtable{$key}="toto" ne pose pas de problème !
01/03/2010, 13h06
Mr6

Je suppose que tu utilises le module qui va bien (threads et threads::shared) ?
Tu as bien déclaré ton hash ? ( my %ma_hashtable :shared )
Si tu ne partages que certaines clés, je crois que tu dois les partager - donc les déclarer - avant usage.

@+
Mr6

J'ai crée un exemple de ce que je fais, c'est vraiment simplifié mais ce n'est que l'exemple. c'est exactement le comportement que je dois avoir (mise a part le fait que la fonction boucle sur une condition d'arrêt normalement.)

fichier main.pl :

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
 
#!/usr/bin/perl
 
use strict;
 
use threads;
use threads::shared;
use obj_class;
 
my %my_hashtable : shared;
 
sub main{
	print "Creation du thread";
	threads->create(\&corp_fonction)->join();
}
 
sub corp_fonction{
	print "Debut d'execution ...";
	my $obj;
 
	# creation de la clef
	my ( $key1, $key2, $key3 ) = ( 1, 2, 3 );
 
	# creation des l'objet
 
	$obj = new my_obj( { p1 => 'val1', p2 => 'val2' } );
 
	# ajout a la hashtable;
 
	$my_hashtable{$key1} = $obj; # <= plante ici
 
		$obj = new my_obj( { p1 => 'val3', p2 => 'val4' } );
 
	# ajout a la hashtable;
 
	$my_hashtable{$key2} = $obj;
 
		$obj = new my_obj( { p1 => 'val5', p2 => 'val6' } );
 
	# ajout a la hashtable;
 
	$my_hashtable{$key3} = $obj;
 
}
 
&main;

fichier obj_class.pm

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
package my_obj;
 
sub to_string {
	my $self = shift;
	my $ret  = "["
	  . __PACKAGE__;
	my $key;
	foreach $key ( sort keys( %{$self} ) ) {
		$ret .= "\n\t$key:(" . $self->{$key} . ")";
	}
	return $ret;
}
 
# param
sub new {
	my ( $class, $ref_arg ) = @_;
	$class = ref($class) || $class;
 
	my $self = {};
	bless( $self, $class );
 
	# attributs
	$self->{_P1}       = $ref_arg->{p1};
	$self->{_P2}       = $ref_arg->{p2};
	$self->{_P3}       = $ref_arg->{p3};
	print "=== " . __PACKAGE__ . " === : new : [" . $self . "]\n";
	return $self;
}
 
# destructor
sub DESTROY {
	my $self = shift;
	print "=== " . __PACKAGE__ . " === : DESTROY : [" . $self . "]\n";
}
 
use overload q{""} => 'to_string';
 
1;    # do not forget
__END__ # compilator do not read after !

le resulta de l'execution :

Code:

1
2
3
4
5
6
7
8
9
10
11
Creation du thread
Debut d'execution ...
=== my_obj === : new : [[my_obj
	_P1:(val1)
	_P2:(val2)
	_P3:()]
Invalid value for shared scalar at ./main.pl line 29.
=== my_obj === : DESTROY : [[my_obj
	_P1:(val1)
	_P2:(val2)
	_P3:()]

Bon j'ai réussi à trouver une partie de la solution que je vais poster si ça intéresse d'autres,

En suivant les exemples de http://docs.activestate.com/activepe...ds/shared.html, en autre j'ai réussi à partager mes objects, cependant l'overload d'operateur ne marche plus !

voici les codes utilisés :

fichier main.pl :

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
#!/usr/bin/perl
 
use strict;
 
use threads;
use threads::shared;
use obj_class;
 
my %my_hashtable : shared;
 
sub main{
	print "Creation du thread\n";
	threads->create(\&corp_fonction)->join();
	my $key;
	foreach $key ( sort keys( %my_hashtable ) ) {
		print $key ." => ". ref($my_hashtable{$key})." => ".$my_hashtable{$key}."\n";
	}
}
 
sub corp_fonction{
	print "Debut d'execution ...\n";
	my $obj;
 
	# creation de la clef
	my ( $key1, $key2, $key3 ) = ( 1, 2, 3 );
 
	# creation de l'objet
	# ajout a la hashtable;
 
	$my_hashtable{$key1} = new my_obj( { p1 => 'val1', p2 => 'val2' } );
 
	# ajout a la hashtable;
 
	$my_hashtable{$key2} = new my_obj( { p1 => 'val3', p2 => 'val4' } );
 
	# ajout a la hashtable;
 
	$my_hashtable{$key3} = new my_obj( { p1 => 'val5', p2 => 'val6' } );
}
 
&main;

fichier obj_class.pm

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
package my_obj;
 
use threads;
use threads::shared;
 
sub to_string {
	my $self = shift;
	my $ret  = "["
	  . __PACKAGE__;
	my $key;
	foreach $key ( sort keys( %{$self} ) ) {
		$ret .= "\n\t$key:(" . $self->{$key} . ")";
	}
	return $ret;
}
 
# param
sub new {
	my ( $class, $ref_arg ) = @_;
	$class = ref($class) || $class;
 
	my $self : shared = shared_clone({});
	bless( $self, $class );
 
	# attributs
	$self->{_P1}       = $ref_arg->{p1};
	$self->{_P2}       = $ref_arg->{p2};
	$self->{_P3}       = $ref_arg->{p3};
	print "=== " . __PACKAGE__ . " === : new : [" . $self . "]\n";
	return $self;
}
 
# destructor
sub DESTROY {
	my $self = shift;
	print "=== " . __PACKAGE__ . " === : DESTROY : [" . $self . "]\n";
}
 
use overload q{""} => 'to_string';
 
1;    # do not forget
__END__ # compilator do not read after !

Resultat :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
yannick@MIHARU:~/adistaworkspace/DemoThreadShared$ ./main.pl 
Creation du thread
Debut d'execution ...
=== my_obj === : new : [[my_obj
	_P1:(val1)
	_P2:(val2)
	_P3:()]
=== my_obj === : new : [[my_obj
	_P1:(val3)
	_P2:(val4)
	_P3:()]
=== my_obj === : new : [[my_obj
	_P1:(val5)
	_P2:(val6)
	_P3:()]
1 => my_obj => my_obj=HASH(0x86cf1e0)
2 => my_obj => my_obj=HASH(0x86cf200)
3 => my_obj => my_obj=HASH(0x86cf1d0)