Browse Prior Art Database

Processing First Level Application Errors In A Conference Enabled graPHIGS Application

IP.com Disclosure Number: IPCOM000122812D
Original Publication Date: 1998-Jan-01
Included in the Prior Art Database: 2005-Apr-04
Document File: 6 page(s) / 282K

Publishing Venue

IBM

Related People

Fuqua, TW: AUTHOR

Abstract

A graPHIGS application may cause the graPHIGS API to generate one or more errors during the execution of a graPHIGS API call. When an application is enabled for conferencing by the graPHIGS conferencing layer, most graPHIGS API calls are executed not once but several times, once for each conference participant. A single API call may generate the same set of errors when executed on each conference participant, or, the API call may succeed on some of the participants yet fail on others. The graPHIGS conferencing layer must ensure that a consistent set of errors are reported back to the application.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 18% of the total text.

Processing First Level Application Errors In A Conference Enabled
graPHIGS Application

      A graPHIGS application may cause the graPHIGS API to generate
one or more errors during the execution of a graPHIGS API call.  When
an application is enabled for conferencing by the graPHIGS
conferencing layer, most graPHIGS API calls are executed not once but
several times,  once for each conference participant.  A single API
call may generate the  same set of errors when executed on each
conference participant, or, the  API call may succeed on some of the
participants yet fail on others. The  graPHIGS conferencing layer
must ensure that a consistent set of errors  are reported back to the
application.

      graPHIGS may detect application errors at either the graPHIGS
shell or graPHIGS nucleus layers as shown below:
                        +------------------+
                        |   Application    |
                        +------------------+
                        |  graPHIGS Shell  |
                        +---------+--------+
                                  | network
                        +---------+--------+
                        | graPHIGS Nucleus |
                        +------------------+

The shell and nucleus may communicate over a network.  The shell may
buffer application requests and send the buffer to the nucleus at
appropriate times.  Errors detected at the nucleus level are sent to
the shell layer so the shell can notify the application of the error.

The implications for normal graPHIGS error processing are:
  1.  Errors resulting from a graPHIGS API call may be detected
       at the nucleus level long after the API call returns to
       the application.
  2.  Multiple errors may be sent from the nucleus to the shell
       at a time.

      Because of these implications, graPHIGS API calls do not return
error codes, rather, errors are enqueued on an error queue maintained
by the shell during the execution of API calls.  At the completion of
an API call, graPHIGS processes each error on the error queue in FIFO
order.

      The application may install a first level error handler
subroutine using the graPHIGS API call GPEHND.  graPHIGS executes the
first level error handler once for each error on the error queue.
The first level error handler may print or display error messages and
it may determine the severity of the error.  No graPHIGS API calls,
except for a limited set related to error processing, may be invoked
by the application from within the first level error handler.  As
each error on the error queue is processed, graPHIGS keeps track of
the highest error severity encountered during processing.

      An application may also install...