Are You Taking Full Advantage of the System Entry Point Table Object?

  • Smaller Small Medium Big Bigger
  • Default Helvetica Segoe Georgia Times

Achieve API invocation performance gains and discover a new pointer caching technique.


The System Entry Point Table (SEPT) object, QSYS/QINSEPT, is a space object with MI object type/subtype code hex 19C3 and external object type *SEPT. It is designed to improve the performance of invocation of program objects in library QSYS. The SEPT stores authorized system pointers to many (but not all) of the user domain/system state (aka API) or system domain/system state program objects residing in library QSYS in its associated space.


User programs are always of user domain and run under user state. The user domain/system state APIs are the glue between user programs and their system domain/system state counterparts. Since they are of user domain, they can be called by user code. And since they run under system state, they can call system domain programs. For example, each time you request to open a database file object, the user domain/system state API QDMCOPEN is called, and QDMCOPEN then calls the system domain/system state program QDBOPEN to achieve the actual operation on the target database file. Protections such as parameter validation are performed by user domain/system state APIs before controls are passed to system domain/system programs.


The SEPT is addressable to each MI process (an i5/OS job) through the Process Control Space (PCS) object. A PCS is an MI object (with object type/subtype code hex 1AEF) used by i5/OS to control the execution of an MI process. The PCS is also referred to as the job structure. An MI process can be uniquely identified by a PCS object. A PCS object contains work areas and storage needed by an MI process, such as process storage spaces for stack, static, and heap storage. The associated space of a PCS object contains the Process Communication Object (PCO). When a PCS object is created and allocated to an MI process, a space pointer addressing the associated space of the SEPT is stored at the beginning of the PCO.


So how does the SEPT improve the performance of invocation of program objects in library QSYS?


Entries (system pointers) in the SEPT are resolved in the installation stage of the system. The number of SEPT entries and the position of a system pointer to a particular program object is the same for each installation for a specific i5/OS release. Newly introduced APIs are appended at the end of the SEPT. For example, the number of entries in the SEPT is 6700 and 7001, respectively, at V5R2 and V5R4. By calling a program in library QSYS via the system pointer to it stored in the SEPT, user programs can spare the time being consumed in locating the target program object by using MI instruction Resolve System Pointer (RSLVSP) to resolve a system pointer to the program object via the symbolic identification (object and optional library name).


So is it really so time-consuming to resolve a system pointer to an MI object? Let's find out.


The following two ILE RPG programs, jan23b.rpgle and jan25b.rpgle, call the Send Data Queue (QSNDDTAQ) API to enqueue a queue entry to a data queue object. The only difference between them is that jan23b.rpgle calls QSNDDATQ directly using the ILE PRG operation code CALL and passing the name of the API, while jan25b.rpgle calls QSNDDTAQ via a resolved system pointer in the SEPT.


This is the source code of ILE RPG program jan23b.rpgle.


     d e               s             16a


     c                   time                    w                14 0

     c                   movel     w             e

     c                   call      'QSNDDTAQ'

     c                   parm      'JAN23'       qname            10

     c                   parm      'LSBIN'       qlib             10

     c                   parm      16            elen              5 0

     c                   parm                    e


     c                   seton                                          lr


Here is the source code of ILE RPG program jan25b.rpgle.


     h dftactgrp(*no)

     /* Prototype of PCOPTR2 */

     d pcoptr2         pr              *   extproc('_PCOPTR2')

     /* Prototype of CALLPGMV */

     d callpgmv        pr                  extproc('_CALLPGMV')

     d     pgm_ptr                     *

     d     argv                        *   dim(1) options(*varsize)

     d     argc                      10u 0 value


     d pco_ptr         s               *

     d pco             ds                  qualified

     d                                     based(pco_ptr)

     d     sept_ptr                    *


     d septs           s               *   dim(7001)

     d                                     based(pco.sept_ptr)


     d qsnddtaq        s               *

     d argv            s               *   dim(4)

     d qname           s             10a   inz('JAN23')

     d qlib            s             10a   inz('LSBIN')

     d qent            s             16a

     d len             s              5p 0 inz(16)




           pco_ptr = pcoptr2();

           qsnddtaq = septs(2898);


           qent = %char(%time : *iso);

           argv(1) = %addr(qname);

           argv(2) = %addr(qlib);

           argv(3) = %addr(len);

           argv(4) = %addr(qent);

           callpgmv(qsnddtaq : argv : 4);


           *inlr = *on;



If you call these two programs 100,000 times on a V5R4 machine, you might get the following results: jan23b takes 9.198 seconds, and jan25b takes 2.306 seconds. Clearly, resolving a system pointer to a program object (the QSNDDTAQ API) might be much more time-consuming than the actual work done by the called program.


In the example ILE RPG program jan25b.rpgle, MI instruction Return PCO Pointer (PCOPTR2) is used to obtain addressability of the PCO of the current MI process in the form of a space pointer. As mentioned above, a space pointer to the SEPT is at the beginning of the PCO, so when the address of space pointer pco_ptr is returned upon a successful completion of _PCOPTR2, the array elements in the system pointer array septs are available. Finally, jan25b.rpgle calls the QSNDDTAQ API via the resolved system pointer to program object QSNDDTAQ, whose index number in the SEPT is hex 0B51 (start from zero). MI instruction Call Program with Variable Length Argument List (CALLPGMV) is used to call program object QSNDDTAQ via the resolved system pointer to it.


To avoid hard-coding the index numbers of SEPT entries, you might dump the SEPT of your target i5/OS release and convert the offset values of system pointers in it to a list of declarations of constants. To dump the SEPT, you can dump space object QSYS/QINSEPT either directly or via the space pointer to the SEPT that is at the beginning of the PCO of an MI process. Here are the example CL commands.


/* Dump the SEPT object directly */



/* Dump the SEPT via the PCO object */



The following declaration of the index number in SEPT of the User Interface Manager (UIM) API Display Long Text (QUILNGTX) is extracted from ept54.rpgleinc, which is provided by the open-source project i5/OS Programmer's Toolkit.


     /* Display Long Text (QUILNGTX) API */

     d ept_quilngtx    c                   x'1629'


The following ILE RPG program, t064.rpgle, calls QUILNGTX by using the index number of QUILNGTX's entry in the SEPT.


     h dftactgrp(*no)


      /copy mih54

      /copy ept54


     d pco_ptr         s               *

     d pco             ds                  qualified

     d                                     based(pco_ptr)

     d     sept_ptr                    *

     d septs           s               *   dim(7001)

     d                                     based(pco.sept_ptr)


     d argv            s               *   dim(5)

     /* arguments of QUILNGTX */

     d text            s              8a   inz('The SEPT')

     d len             s             10i 0 inz(8)

     d msgid           s              7a   inz('CPF9898')

     d msgf            s             20a   inz('QCPFMSG   QSYS')

     d ec              s             16a



           pco_ptr = pcoptr2();


           ec = x'00000010000000000000000000000000';

           argv(1) = %addr(text);

           argv(2) = %addr(len);

           argv(3) = %addr(msgid);

           argv(4) = %addr(msgf);

           argv(5) = %addr(ec);

      /if defined(*v5r4m0)

           callpgmv( septs(ept_quilngtx) // hex 162A

                   : argv : 5);



           *inlr = *on;



There is yet another method to obtain the addressability of the SEPT. The undocumented system built-in _SYSEPT can be found in ILE C/C++ header QSYSINC/MIH(SYSEPT). _SYSEPT returns a space pointer to the SEPT. The following is the ILE RPG prototype of _SYSEPT extracted from mih52.rpgleinc.


     /* returns a space pointer to the SEPT */

     d sysept          pr              *   extproc('_SYSEPT')


In the following ILE RPG program t065.rpgle, _SYSEPT is used to obtain the addressability of the SEPT.


     h dftactgrp(*no)


      /copy mih54

      /copy ept54


     d ept_ptr         s               *

     d septs           s               *   dim(7001)

     d                                     based(ept_ptr)

     d argv            s               *   dim(1)



           // address the SEPT

           ept_ptr = sysept();


      /if defined(*v5r4m0)

           // call Operational Assistant API Send Message (QEZSNDMG)

           callpgmv( septs(EPT_QEZSNDMG)

                   : argv

                   : 0);



           *inlr = *on;



SEPT's value is not only the performance gains in API invocation; the design of the SEPT also introduces a pointer caching technique to us. The virtual address stored in the system pointer to an MI object is a single-level storage (SLS) address in the 64-bit virtual address space of i5/OS. And this virtual address remains unchanged during the life of an MI object. This means that system pointers to permanent MI objects stored in a permanent MI object (such as a permanent space object, a permanent index object, or a queue object that can contain pointers) will remain valid and can be reused even across IPLs.