This file is indexed.

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

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
# 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'.