Lines Matching full:job

8 - asynchronous job management functions
17  int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
22  ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
33 subsequent event indicates that the job can be resumed.
38 the pool, used, and then returned to the pool when the job completes. If the
57 An asynchronous job is started by calling the ASYNC_start_job() function.
58 Initially I<*job> should be NULL. I<ctx> should point to an B<ASYNC_WAIT_CTX>
61 be stored on completion of the job. I<func> represents the function that should
63 will be copied and then passed as an argument to I<func> when the job starts.
70 An error occurred trying to start the job. Check the OpenSSL error queue (e.g.
80 The job was successfully started but was "paused" before it completed (see
81 ASYNC_pause_job() below). A handle to the job is placed in I<*job>. Other work
82 can be performed (if desired) and the job restarted at a later time. To restart
83 a job call ASYNC_start_job() again passing the job handle in I<*job>. The
84 I<func>, I<args> and I<size> parameters will be ignored when restarting a job.
85 When restarting a job ASYNC_start_job() B<must> be called from the same thread
86 that the job was originally started from.
90 The job completed. I<*job> will be NULL and the return value from I<func> will
95 At any one time there can be a maximum of one job actively running per thread
97 a pointer to the currently executing B<ASYNC_JOB>. If no job is currently
100 If executing within the context of a job (i.e. having been called directly or
105 I<*job> parameter will resume execution from the ASYNC_pause_job() call. If
106 ASYNC_pause_job() is called whilst not within the context of a job then no
110 for the I<job>. B<ASYNC_WAIT_CTX>s contain two different ways to notify
111 applications that a job is ready to be resumed. One is a "wait" file
117 that the job should be resumed). If no file descriptor is made available then
118 an application will have to periodically "poll" the job by attempting to restart
131 The ASYNC_block_pause() function will prevent the currently active job from
136 currently active job then they have no effect. This functionality can be useful
141 resuming the original job then a deadlock can occur. By calling
161 or NULL if not within the context of a job.
163 ASYNC_get_wait_ctx() returns a pointer to the B<ASYNC_WAIT_CTX> for the job.
210          printf("Executing within a job\n");
212          printf("Not executing within a job - should not happen\n");
235       * immediately signalling that the job is ready to be woken up after
246      printf ("Resumed the job after a pause\n");
253      ASYNC_JOB *job = NULL;
270          switch (ASYNC_start_job(&job, ctx, &ret, jobfunc, msg, sizeof(msg))) {
276              printf("Job was paused\n");
279              printf("Job finished with return value %d\n", ret);
283          /* Wait for the job to be woken */
284          printf("Waiting for the job to be woken up\n");
307  Executing within a job
309  Job was paused
310  Waiting for the job to be woken up
311  Resumed the job after a pause
312  Job finished with return value 1