octave-parallel 2.2.0-1build1 / usr / share / octave / packages / parallel-2.2.0 / doc-cache

# Created by Octave 3.8.0, Tue Feb 25 02:18:16 2014 UTC <root@toyol>
# name: cache
# type: cell
# rows: 3
# columns: 9
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bw_clear


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 219
 -- Function File: bw_clear (F, ARGS)
     Terminates scheduler (if running) and removes statefile for
     function F and argument filename ARGS.  Results will be lost.

     See also: bw_start, bw_list, bw_retrieve.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Terminates scheduler (if running) and removes statefile for function F
and argum



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bw_list


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 135
 -- Function File: bw_list ()
     Display state of jobs started with 'bw_start ()'.

     See also: bw_start, bw_retrieve, bw_clear.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Display state of jobs started with 'bw_start ()'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
bw_retrieve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 816
 -- Function File: bw_retrieve (F, ARGS, FN, [MATLAB])
     Retrieve results of computations started with 'bw_start ()'.
     Computation need not be finished for all arguments.  F, ARGS:
     function name and filename of arguments given to 'bw_start ()'.
     FN: path to file to save results in.  MATLAB: if given and true,
     results are stored in Matlab compatible binary format; otherwise
     the binary format of Octave is used.

     Three variables are saved, "results" is a cell-array of results
     (empty entry if no result), one for each argument set, "errors" a
     vector with non-zero elements for each argument set which caused an
     error, and "messages" is a cell-array of the respective error
     messages, or empty values if there was none.

     See also: bw_start, bw_list, bw_clear.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Retrieve results of computations started with 'bw_start ()'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bw_start


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1185
 -- Function File: bw_start ()
 -- Function File: bw_start (F, ARGFILE)
     Start parallel computation in a beowulf cluster.

     With no arguments, restart all unfinished jobs.

     With two arguments, (re)start job.  String F names a function to be
     started multiple times in parallel.  ARGFILE names a data-file in
     the configured data directory containing a one-dimensional
     cell-array with arguments for F, one entry for each invocation of
     F.  F must be of one of the following forms

          function RET = f (ARGS)

          function RET = f (ARGS, IDX)

     where ARGS is an entry of the argument cell-array, IDX is the index
     of this entry, and RET contains the result of computation.

     Users can put configuration commands into the file "~/.bwrc".
     Variable "data_dir" contains the configured data directory, default
     is "~/bw-data/".  Directory given in variable "state_dir", default
     "~/.bw-state/", is used internally to read and write state
     information.  If this directory does not exist it is created, which
     will fail if there would be more than one level to create.

     See also: bw_list, bw_retrieve, bw_clear.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Start parallel computation in a beowulf cluster.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
pararrayfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1005
 -- Function File: [O1, O2, ...] = pararrayfun (NPROC, FUN, A1, A2, ...)
 -- Function File: pararrayfun (nproc, fun, ..., "UniformOutput", VAL)
 -- Function File: pararrayfun (nproc, fun, ..., "ErrorHandler",
          ERRFUNC)
     Evaluates a function for corresponding elements of an array.
     Argument and options handling is analogical to 'parcellfun', except
     that arguments are arrays rather than cells.  If cells occur as
     arguments, they are treated as arrays of singleton cells.  Arrayfun
     supports one extra option compared to parcellfun: "Vectorized".
     This option must be given together with "ChunksPerProc" and it
     indicates that FUN is able to operate on vectors rather than just
     scalars, and returns a vector.  The same must be true for ERRFUNC,
     if given.  In this case, the array is split into chunks which are
     then directly served to FUNC for evaluation, and the results are
     concatenated to output arrays.

     See also: parcellfun, arrayfun.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Evaluates a function for corresponding elements of an array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
parcellfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2481
 -- Function File: [O1, O2, ...] = parcellfun (NPROC, FUN, A1, A2, ...)
 -- Function File: parcellfun (nproc, fun, ..., "UniformOutput", VAL)
 -- Function File: parcellfun (nproc, fun, ..., "ErrorHandler", ERRFUNC)
 -- Function File: parcellfun (nproc, fun, ..., "VerboseLevel", VAL)
 -- Function File: parcellfun (nproc, fun, ..., "ChunksPerProc", VAL)
     Evaluates a function for multiple argument sets using multiple
     processes.  NPROC should specify the number of processes.  A
     maximum recommended value is equal to number of CPUs on your
     machine or one less.  FUN is a function handle pointing to the
     requested evaluating function.  A1, A2 etc.  should be cell arrays
     of equal size.  O1, O2 etc.  will be set to corresponding output
     arguments.

     The UniformOutput and ErrorHandler options are supported with
     meaning identical to "cellfun".  A VerboseLevel option controlling
     the level output is supported.  A value of 0 is quiet, 1 is normal,
     and 2 or more enables debugging output.  The ChunksPerProc option
     control the number of chunks which contains elementary jobs.  This
     option particularly useful when time execution of function is
     small.  Setting this option to 100 is a good choice in most cases.

     Notice that jobs are served from a single first-come first-served
     queue, so the number of jobs executed by each process is generally
     unpredictable.  This means, for example, that when using this
     function to perform Monte-Carlo simulations one cannot expect
     results to be exactly reproducible.  The pseudo random number
     generators of each process are initialised with a unique state.
     This currently works only for new style generators.

     NOTE: this function is implemented using "fork" and a number of
     pipes for IPC. Suitable for systems with an efficient "fork"
     implementation (such as GNU/Linux), on other systems (Windows) it
     should be used with caution.  Also, if you use a multithreaded
     BLAS, it may be wise to turn off multi-threading when using this
     function.

     CAUTION: This function should be regarded as experimental.
     Although all subprocesses should be cleared in theory, there is
     always a danger of a subprocess hanging up, especially if unhandled
     errors occur.  Under GNU and compatible systems, the following
     shell command may be used to display orphaned Octave processes: ps
     -ppid 1 | grep octave




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Evaluates a function for multiple argument sets using multiple
processes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
scloseall


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 scloseall (sockets)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 scloseall (sockets)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
select_sockets


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 605
 -- Function File: [N, IDX] = select_sockets (SOCKETS, TIMEOUT[, NFDS])
     Calls Unix 'select'.

     SOCKETS: valid sockets matrix as returned by 'connect'.

     TIMEOUT: seconds, negative for infinite.

     NFDS: optional, default is Unix' FD_SETSIZE (platform specific).
     Passed to Unix 'select' as the first argument -- see there.

     An error is returned if nfds or a watched filedescriptor plus one
     exceeds FD_SETSIZE.

     Return values are: IDX: index vector to rows in SOCKETS with
     pending input, readable with 'recv'.  N: number of rows in SOCKETS
     with pending input.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Calls Unix 'select'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
server


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
 Start server for remote execution with package 'parallel'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 Start server for remote execution with package 'parallel'.