A | |
abort [Bsmlsig.COMM] |
Aborts the computation
|
abort [Bsmlsig.BSML] |
Aborts computation and quits.
|
apply [Bsmlsig.BSML] |
Pointwise parallel application.
|
apply2 [Bsmlbase.Make] |
Same thing as
apply but with aa function of arity 2, 3 or
4.
|
apply3 [Bsmlbase.Make] | |
apply4 [Bsmlbase.Make] | |
applyat [Bsmlbase.Make] | applyat n f1 f2 v applies function f1 at process n and f2 otherwise
|
applyif [Bsmlbase.Make] | |
argv [Bsmlsig.COMM] |
Returns the array of command-line arguments
|
argv [Bsmlsig.BSML] |
Returns the arguments from command line with implementation-specific
arguments removed.
|
B | |
bcast_direct [Bsmlcomm.Make] | |
bcast_totex [Bsmlcomm.Make] | |
bcast_totex_array [Bsmlcomm.Make] | |
bcast_totex_gen [Bsmlcomm.Make] | bcast_totex_gen partition paste root v broadcasts the value
at process root of parallel vector v .
|
bcast_totex_list [Bsmlcomm.Make] |
Specialized versions for lists, arrays, strings and values of
any type (but this general version implies the marshalling of
values and then the use of
bcast_totex_string .
|
bcast_totex_string [Bsmlcomm.Make] | |
bsml_abort_string [Bsmlbckcomp.Make] | |
bsml_begin [Bsmlbckcomp.Make] | |
bsml_end [Bsmlbckcomp.Make] | |
bsml_print [Bsmlbase.Make] | bsml_print print_element pid element prints the value of
element at process pid using the printer
print_element
|
bsp_g [Bsmlsig.BSML] |
BSP parameter g of the parallel machine.
|
bsp_l [Bsmlsig.BSML] |
BSP parameter l of the parallel machine.
|
bsp_p [Bsmlsig.BSML] |
Number p of processes in the parallel machine.
|
bsp_r [Bsmlsig.BSML] |
BSP parameter r of the parallel machine.
|
C | |
compose [Tools] |
Function composition.
|
F | |
filtermap [Tools] | filtermap p f l applies f to each element of l which
satifies the predicate p
|
finalize [Bsmlsig.COMM] |
Performs implementation-dependent finalization.
|
fold_array_direct [Bsmlcomm.Make] | |
fold_array_logp [Bsmlcomm.Make] | |
fold_direct [Bsmlcomm.Make] | |
fold_list_direct [Bsmlcomm.Make] | |
fold_list_logp [Bsmlcomm.Make] | |
fold_logp [Bsmlcomm.Make] | |
fold_wide [Bsmlcomm.Make] | |
from_to [Tools] | from_to n1 n2 = [n1;n1+1;...;n2]
|
G | |
gather [Bsmlcomm.Make] | |
gather_list [Bsmlcomm.Make] | |
get [Bsmlbckcomp.Make] | |
get [Bsmlsig.MACHINE_PARAMETERS] |
Get the current parameters.
|
get_cost [Bsmlsig.BSML] |
returns a parallel vector which contains, at each processor, the time
elapsed between the calls to
start_timing and stop_timing .
|
get_list [Bsmlbase.Make] |
The order of the elements of the result list is the same as
the order of the process numbers in the argument list.
|
get_one [Bsmlbase.Make] | get <x0,...,xp-1> <i0,...,ip-1> evaluates to
<xi_0,...,xi_p-1>.
|
I | |
id [Tools] |
Identity function
|
initialize [Bsmlsig.COMM] |
Performs implementation-dependent initialization.
|
is_empty [Tools] |
Tests whether a value is considered as an empty message.
|
M | |
mask [Bsmlbase.Make] | |
mkpar [Bsmlsig.BSML] |
Parallel vector creation.
|
N | |
natmod [Tools] |
Modulo
|
nprocs [Bsmlsig.COMM] |
Returns the number of processors in the parallel machine
|
P | |
parfun [Bsmlbase.Make] | parfun f <x0,...,x(p-1)> = <f x0,...,f x(p-1)>
|
parfun2 [Bsmlbase.Make] |
Same thing as
parfun but with a function of arity 2, 3 or
4.
|
parfun3 [Bsmlbase.Make] | |
parfun4 [Bsmlbase.Make] | |
parprint [Bsmlbase.Make] | parprint print v print the parallel vector v using the
printer print , one line per process, each line beginning with
the number of the process.
|
pid [Bsmlsig.COMM] |
Returns the processor ID of the host processor
|
procs [Bsmlbase.Make] | procs is the list of the process numbers
|
proj [Bsmlsig.BSML] |
projection (dual of
mkpar ).
|
put [Bsmlbckcomp.Make] | |
put [Bsmlsig.BSML] |
Global communication.
|
put_list [Bsmlbase.Make] |
Each process holds an association liste of pairs
(dst,v)
where dst is the number of the process of destination and
v the value to send.
|
put_one [Bsmlbase.Make] |
Each process holds a pair
(dst,v) where dst is the number of
the process of destination and v the value to send.
|
R | |
read [Bsmlsig.MACHINE_PARAMETERS] |
Reads the parameters from the configuration file.
|
regular_sampling_sort_array [Bsmlsort.Make] | |
regular_sampling_sort_list [Bsmlsort.Make] | |
replicate [Bsmlbase.Make] | replicate x gives a parallel vector with the value x on each
process.
|
S | |
safe_proj [Bsmlbckcomp.Make] | safe_proj <v,...,v> = v, raises the exception Unsafe_proj
otherwise
|
scan_array_direct [Bsmlcomm.Make] | |
scan_array_logp [Bsmlcomm.Make] | |
scan_direct [Bsmlcomm.Make] |
If
op is an associative operation, scan_direct op
<v0,...,vp-1> = <s0,...,sp-1> where si=op vk.
|
scan_list_direct [Bsmlcomm.Make] | |
scan_list_logp [Bsmlcomm.Make] | |
scan_logp [Bsmlcomm.Make] |
Computes the same result than
scan_direct but with
communication cost: i (log p)*2*n*g+l.
|
scan_wide [Bsmlcomm.Make] | scan_wide par_scan seq_scan last_element map op vv is used
to compute a parallel scan over a parallel vector of
collections of values.
|
scan_wide_direct [Bsmlcomm.Make] |
Specialized version of
scan_wide using scan_direct as
parallel scan.
|
scan_wide_logp [Bsmlcomm.Make] |
Specialized version of
scan_wide using scan_logp as
parallel scan.
|
scatter [Bsmlcomm.Make] | |
scatter [Bsmlbckcomp.Make] | |
scatter_array [Bsmlcomm.Make] | |
scatter_list [Bsmlcomm.Make] |
Specialized version for lists, arrays and strings
respectively.
|
scatter_string [Bsmlcomm.Make] | |
send [Bsmlsig.COMM] | |
shift [Bsmlcomm.Make] |
Shifts the values from processes to processes.
|
shift_left [Bsmlcomm.Make] | |
shift_right [Bsmlcomm.Make] | |
start_timing [Bsmlsig.BSML] | |
stop_timing [Bsmlsig.BSML] | |
T | |
this [Bsmlbase.Make] | this is the parallel vector such as each process hold its
number
|
total_exchange [Bsmlcomm.Make] | |
totex [Bsmlcomm.Make] | totex <v0,...,vp-1> evaluates to <f0,...,fp-1>
such as (fi j)=vj.
|
W | |
within_bounds [Bsmlsig.BSML] | within_bounds n is true is n is between 0 and p-1,
false otherwise.
|
wtime [Bsmlsig.COMM] |
Returns the clock
|