Re: Subsystems and ODP

[CRPence <CRPbottle@xxxxxxxxx>]

  I think that description may imply false expectations, both where 
multiple threads can be used, and what they can accomplish with regard 
to ODP sharing.  A data queue server job can just as easily be threaded, 
as a sockets server job.  But in both cases the access to the ODP will 
almost surely need to be serialized, thus /blocking/ the requests from 
competing threads, since all of the requests from competing threads 
would presumably be working to complete perhaps the same task, but 
against a different set of data.  So if moving the contention down to 
just the ODP from the request itself can speed things along because the 
access to the data is only a minor portion of the complete request, then 
there is value in threading the job.  However typically, the data access 
is the major portion of the total request, so little is to be gained by 
that approach as compared to separate jobs.  For that, it may be easiest 
to establish an extra job or two to handle higher volume time periods.

  To share an ODP between separate calls to the processing, all of that 
processing must be done in one job.  A server job with whatever type of 
interprocess communication to start the work seems appropriate; i.e. the 
simplest.  Such a server job could optionally run multi-threaded.  There 
is of course the option of more than one server job, perhaps where the 
original one job creates\starts more jobs when the number of requests is 
not being kept up with.

Regards, Chuck

Charles St-Laurent wrote:
> <<SNIP>>
>
> I know that is is possible to start a never ending program, a kind 
> of server, that waits for requests. Once the program receives a
> request, it processes the request and returns the result to the
> requester. The easy way to do that is a data queue server. But a data
> queue server is a blocking server. It can process only one request at
> the time. Another way is a TCP server, with one parent process and
> many children processes. So the parent process waits for a request.
> Once it receives a request, it dispatches this request to one of its
> children processes. Then, the child process returns the result.
> Because the server is a never ending job, all the resources 
> allocated in QILE will stay open until I stop the job, including ODP.
>
> Is there something simpler to do what I want to do? Sharing ODP
> between calls of my process, considering that each call can be done
> by different users / jobs?