
  PROCEDURE [INLINE] dfp$queue_client_core_request
    (    p_queue_interface_table: dft$p_queue_interface_table;
         queue_index: dft$queue_index;
         queue_entry_index: dft$queue_entry_index;
     VAR status: ost$status);

*copyc dfc$queue_request_constants

    VAR
      maximum_request_count: integer,
      message: string (40),
      new_out: integer,
      old_out: integer,
      queue_request_status: dft$queue_request_status,
      request_buffer_entry: dft$request_buffer_entry,
      request_buffer_queue_index: 0 .. 0FF(16),
      retry_count: integer;

{ Attempt to queue the request.  If it is queued, OK.  If it is not queued, keep trying until:
{   . it is queued
{   . request buffer full status has been seen too many times
{   . any other unexpected status
{ If it cannot be queued because of server terminated, set terminated status and return.
{ If it cannot be queued because of request buffer full, set timeout status and then
{   . if the blocking request buffer entry belongs to the same queue as the executor of this code, return to
{     process the timeout status.
{   . if the blocking request buffer entry belongs to some other queue, wait a bit for the timeout to process,
{     and then attempt the queue request again.

    maximum_request_count := dfv$task_queue_timeout_interval DIV dfc$request_delay;

  /queue_request/
    WHILE TRUE DO { attempt to queue the request
      old_out := -1;
      status.normal := TRUE;

      REPEAT
        osp$begin_subsystem_activity;
        dfp$queue_request (p_queue_interface_table, queue_index,
              queue_entry_index, queue_request_status);
        osp$end_subsystem_activity;
        IF queue_request_status = dfc$qrs_request_buffer_full THEN
          new_out := dfp$current_rq_buffer_out_index (p_queue_interface_table);
          IF new_out = old_out THEN
            retry_count := retry_count + 1;
          ELSE
            retry_count := 0;
            old_out := new_out;
          IFEND;
          pmp$delay (dfc$request_delay, status);
          IF NOT status.normal THEN
            osp$system_error (' pmp$delay ERROR', ^status);
          IFEND;
        IFEND;
      UNTIL (queue_request_status <> dfc$qrs_request_buffer_full) OR
            (retry_count > (maximum_request_count DIV 2)); { core calls shouldn't wait as long as others }

      IF queue_request_status = dfc$qrs_entry_queued THEN
        RETURN;
      IFEND;

      IF queue_request_status = dfc$qrs_server_terminated THEN
        dfp$set_terminated_status (p_queue_interface_table, queue_index, status);
        RETURN;
      ELSEIF (queue_request_status = dfc$qrs_request_buffer_full) AND
            (retry_count > (maximum_request_count DIV 2)) THEN
        dfp$get_current_rq_buffer_entry (p_queue_interface_table, old_out, request_buffer_entry);

{  If queue_index is 0, request buffer entry has been freed since we last looked.

        request_buffer_queue_index := request_buffer_entry.queue_index;
        IF request_buffer_queue_index = 0 THEN
          CYCLE /queue_request/;
        IFEND;

        IF dfv$file_server_debug_enabled THEN
          message := ' DF- Partner mainframe ';
          message (24, *) := p_queue_interface_table^.queue_directory.cpu_queue_pva_directory
                [request_buffer_queue_index].p_cpu_queue^.queue_header.destination_mainframe_name;
          display_to_console (message);
          core_log_display (message);
          display_integer_to_console (' DF- Timing out queue, QI = ', request_buffer_queue_index);
          core_log_display_integer (' DF- Timing out queue, QI = ', request_buffer_queue_index);
        IFEND;
        dfp$set_queue_timed_out (p_queue_interface_table, request_buffer_queue_index, status);
        IF queue_index = request_buffer_queue_index THEN
          RETURN; { to process own timeout }
        IFEND;
      ELSE
        core_log_display_integer (' DF- Unexpected queue request status: ', $integer (queue_request_status));
        core_log_display_integer ('     Queue index: ', $integer (queue_index));
        osp$system_error (' UNEXPECTED QUEUE REQUEST STATUS ', NIL);
      IFEND;
      IF dfv$file_server_debug_enabled THEN
        display_integer_to_console (' DF- Waiting for request_buffer entry timeout, QI = ',
              request_buffer_queue_index);
      IFEND;
      core_log_display_integer (' DF- Waiting for request_buffer entry timeout, QI = ',
            request_buffer_queue_index);
      pmp$delay (dfc$timeout_delay, status)
    WHILEND /queue_request/;

  PROCEND dfp$queue_client_core_request;
?? PUSH (LISTEXT := ON) ??
*copyc dfd$driver_queue_types
*copyc dfe$error_condition_codes
*copyc dfi$console_display
*copyc dfi$core_log_display
*copyc dfp$current_rq_buffer_out_index
*copyc dfp$get_current_rq_buffer_entry
*copyc dfp$queue_request
*copyc dfp$set_queue_timed_out
*copyc dfp$set_terminated_status
*copyc dft$request_buffer
*copyc dfv$file_server_debug_enabled
*copyc dfv$task_queue_timeout_interval
*copyc osp$begin_subsystem_activity
*copyc osp$end_subsystem_activity
*copyc osp$set_status_abnormal
*copyc osp$system_error
*copyc pmp$delay
?? POP ??

