Module: PRuby

Defined in:
lib/pruby/pruby.rb,
lib/pruby/future.rb,
lib/pruby/stream.rb,
lib/pruby/channel.rb,
lib/pruby/version.rb,
lib/pruby/pipeline.rb,
lib/pruby/task_bag.rb,
lib/pruby/array-range.rb,
lib/pruby/pipeline-factory.rb

Defined Under Namespace

Modules: PArrayRange Classes: Channel, FarmNode, PRubyFuture, Pipeline, PipelineFactory, PipelineNode, ProcNode, Stream, TaskBag

Constant Summary

GO_ON =

Constantes speciales pour les noeuds de types "fastflow".

:PRUBY_GO_ON
NONE =

Alias

GO_ON
MANY = 
:PRUBY_MANY
EOS = 
:PRUBY_EOS
VERSION = 
'0.5.1'
TaskPool = 
TaskBag

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.nb_tasks_created ⇒ Fixnum (readonly)

Note:

Le nombre de taches creees n’est pas exacte, a moins qu’un appel ne soit fait au prealable a la methode with_exact_nb_tasks.

Justification: Pour avoir le nombre exact de taches, il faut utiliser un verrou (ou une variable atomique) ce qui ajoute des conflits d’acces inutiles. Donc, a n’utiliser que de facon exceptionnelle, car le verrou utilise est un verrou non-reentrant donc le meme thread peut vouloir l’obtenir a nouveau, ce qui genere une erreur.

Nombre de taches creees lors de l'execution de pcall, future ou version dynamique de peach, peach_index, pmap ou preduce.

Returns:

  • (Fixnum) 


74
75
76
 
# File 'lib/pruby/pruby.rb', line 74

def nb_tasks_created
  @nb_tasks_created
end

.nb_threads ⇒ Fixnum

Nombre de threads a utiliser par defaut pour l'execution de peach, peach_index, pmap, preduce.

Returns:

  • (Fixnum) 


38
39
40
 
# File 'lib/pruby/pruby.rb', line 38

def nb_threads
  @nb_threads
end

.nb_threads_used ⇒ Fixnum

Nombre de threads effectivement utilises pour l'execution de peach, peach_index, pmap, preduce.

Returns:

  • (Fixnum) 


56
57
58
 
# File 'lib/pruby/pruby.rb', line 56

def nb_threads_used
  @nb_threads_used
end

.thread_kind=(value) ⇒ :THREAD, :FORK_JOIN_TASK (writeonly)

Indique la sorte de threads desire pour l'execution d'un pcall. Si :THREAD alors ce sont des Thread JRuby. Si :FORK_JOIN_TASK alors ce sont des threads encore plus legers de la bibliotheque forkjoin.

Returns:

  • (:THREAD, :FORK_JOIN_TASK) 


104
105
106
107
108
 
# File 'lib/pruby/pruby.rb', line 104

def thread_kind=( sorte )
  DBC.check_value( sorte, @methodes_de_thread.keys )

  @thread_kind = sorte
end

.with_exact_nb_tasks=(value) ⇒ Bool (writeonly)

Assure que le decompte du nombre de tache soit fait de facon exacte. Voir nb_tasks_created.

Returns:

  • (Bool) 


92
93
94
 
# File 'lib/pruby/pruby.rb', line 92

def with_exact_nb_tasks=( b )
  @with_exact_nb_tasks = b
end

.with_exact_nb_tasks? ⇒ Bool (readonly)

Determine si le decompte du nombre de taches est fait de facon exacte ou non. Voir nb_tasks_created.

Returns:

  • (Bool) 


82
83
84
 
# File 'lib/pruby/pruby.rb', line 82

def with_exact_nb_tasks?
  @with_exact_nb_tasks
end

Class Method Details

.future(expr = nil, sorte_de_thread = :THREAD, &block) ⇒ PRubyFuture

Cree un future a partir d'une expression a evaluer, representee soit par un argument explicite de type Proc (lambda), soit par un bloc.

Parameters:

  • expr (Proc, nil) (defaults to: nil) —

    L’expression a evaluer

  • sorte_de_thread (:FORK_JOIN_TASK, :THREAD) (defaults to: :THREAD) —

    La sorte de thread a creer

  • block —

    Un bloc representant l’expression a evaluer

Returns:

  • (PRubyFuture) —

    Un future sur lequel on pourra faire un value pour obtenir la valeur resultante (appel a value qui sera bloquant)

Requires:

  • Soit un lambda est fourni en argument, soit un bloc mais pas les deux



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/pruby/pruby.rb', line 178

def self.future( expr = nil, sorte_de_thread = :THREAD, &block )
  DBC.require expr.nil? != !block_given?, "*** Dans future, il faut fournir soit un bloc, soit un lambda"
  DBC.require( expr.class == Proc, "*** L'argument fourni au future doit etre un Proc" ) if expr

  incr_nb_tasks_created 1

  case sorte_de_thread
  when :FORK_JOIN_TASK
    @pool.submit PRubyFuture.new( expr || block )
  when :THREAD
    if block_given?
      Thread.new( &block )
    else
      Thread.new { expr.call }
    end
  else
    DBC.check_value( sorte_de_thread, @methods_de_thread.keys,
                     "*** sorte_de_thread invalide" )
  end
end

.pcall(*args) ⇒ void

This method returns an undefined value.

Effectue un appel parallele a une serie de lambdas. On peut specifier soit uniquement des Proc (lambdas), soit un ou plusieurs Range suivi d'un Proc. Si un Range est present, alors on va creer autant de threads que d'elements dans le Range et chaque Proc recevra en argument l'element du Range.

Examples:

PRuby.pcall lambda { puts "foo" }, lambda { puts "bar" }, lambda { puts "baz" }
PRuby.pcall (1..10), lambda { |i| puts i }
PRuby.pcall (1..10), lambda { |i| puts i+1 }, (0..100), lambda { |i| puts 100*i }, lambda { puts "foo" }

Parameters:

  • args (liste de Range ou Proc) —

    Liste des lambdas a executer avec ou sans Range indiquant les instances a creer

Requires:

  • args.size > 1

  • Si un Range est present, alors il doit etre immediatement suivi d’un Proc qui recoit un argument

  • Si un Range suivi d’un Proc est present, alors il ne doit pas avoir ete precede d’un Proc sans Range



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/pruby/pruby.rb', line 141

def self.pcall( *args )
  # On permet des Range, mais seulement au debut:
  #   pcall [Range, Proc,]* Proc*

  DBC::assert args.size > 1, "*** Un appel a pcall devrait contenir au moins deux elements, sinon aucun interet!"

  thread_kind = @thread_kind
  if args[0].class == Symbol
    DBC.check_value( args[0], @methodes_de_thread.keys )
    thread_kind = args.shift
    DBC::assert args.size > 1, "*** Un appel a pcall devrait contenir au moins deux elements, sinon aucun interet!"
  end

  while args[0].class == Range
    range = args.shift
    le_lambda = args.shift
    DBC.require le_lambda.arity == 1, "*** Le lambda qui suit un range dans un pcall doit recevoir un argument"
    args.push( *generate_lambdas( range, le_lambda ) )
  end

  DBC.require args.all? { |a| a.class == Proc }, "*** Tous les autres arguments de pcall doivent etre des Procs (lambdas)"
  method = @methodes_de_thread[thread_kind]
  send method, *args
end

.thread_index ⇒ Fixnum

Retourne l'index du thread lorsque ce thread a ete cree dans un peach/peach_index/pmap/preduce.

Returns:

  • (Fixnum)

Ensures:

  • 0 <= thread_index < nb_threads_used

Requires:

  • L’appel se fait a partir d’un thread cree pour un peach, peach_index, pmap ou preduce.



119
120
121
 
# File 'lib/pruby/pruby.rb', line 119

def thread_index
  Thread.current[:thread_index]
end