Abstract:
A data processing system ( 1 ) is programmed with objects ( 2 ) according to the object-oriented architecture. Each object ( 2 ) is for implementing an event, which for financial securities processing is often referred to as a corporate action. An object ( 2 ) has a container ( 3 ) containing a series of masks ( 4 ), all at the same level in a flat structure. Each mask has four binary bit flags, each switching on or off a pre-stored unit ( 5 ) of executable code for an asynchronous transaction. Initialization or modifications of the system involves only processing through a series of decisions and setting mask flags accordingly.

Description:
This is a continuation of PCT/IE03/000105 filed Jul. 23, 2003 and published in English. 

   FIELD OF THE INVENTION 
   The invention relates to data processing systems, and more particularly to initialisation and/or modification of a system to perform transactions. 
   PRIOR ART DISCUSSION 
   Many data processing systems which perform transactions require a large manpower input for initial programming and subsequent maintenance/upgrade. This is because of the highly complex nature of business requirements. For example, in the field of securities processing a system may handle many different financial products, and for each product there are many functions to implement events (or “corporate actions”) each comprising a number of transactions. As customer and financial needs and processes change and as regulations change, the corporate actions or events must be often modified and tested. Also, such complexity can lead to poor system performance for real time transaction processing because of the number of interactions between database and memory tables and retrieval of multiple program functions. 
   As functions are typically programmed individually, albeit with some re-use of code, the initialisation and ongoing modification is often very time-consuming and expensive. 
   The invention addresses these problems. 
   SUMMARY OF THE INVENTION 
   According to the invention, there is provided a data processing system comprising a processor, a memory, an input interface, and an output interface, the processor being programmed to perform data processing operations to complete an event, wherein an event is represented as an object comprising a mask switching on or off one or more of a number of units of executable code in which each unit is for implementing a transaction. 
   In one embodiment, there is a pre-defined and fixed number of units of code. 
   In another embodiment, the mask comprises a series of flags, each flag position being associated with a unit, and each flag value setting an on or off switch value for an associated unit of executable code. 
   In a further embodiment, the object comprises a plurality of masks, each associated with a subsidiary event within the event, each subsidiary event comprising one or more transactions. 
   In one embodiment, the masks are stored in at least one word having a plurality of masks, each mask having a plurality of flags. 
   In another embodiment, a flag is a binary bit. 
   In a further embodiment, a word is a 64-bit long. 
   In one embodiment, the object stores a numerical value representing the bits of each word. 
   In another embodiment, the word comprises binary bits and the numerical value is a decimal value. 
   In a further embodiment, the masks are in a linear series flat logical structure, the processor being programmed to execute the units of the masks in sequence. 
   In one embodiment, the object contains an array comprising a plurality of indexes, each index addressing a word comprising a plurality of masks. 
   In another embodiment, at least some of the transactions are asynchronous, without a return direction acknowledgement. 
   In a further embodiment the method comprises the steps of deciding in sequence if each of a limited number of pre-stored units of executable code are required for an event, and setting a switch value in a mask for the event accordingly. 
   In one embodiment, the switch values are set as attributes of an object representing the event. 
   In another embodiment, the flags are set with a fixed offset in a word for each unit decision. 

   
     DETAILED DESCRIPTION OF THE INVENTION 
     Brief Description of the Drawings 
     The invention will be more clearly understood from the following description of some embodiments thereof, given by way of example only with reference to the accompanying drawings in which:— 
       FIG. 1  is a diagram illustrating a processing structure for a data processing system of the invention; 
       FIG. 2  is a more detailed diagram illustrating a rule array; and 
       FIG. 3  is a flow diagram illustrating system initialisation. 
   

   DESCRIPTION OF THE EMBODIMENTS 
   Referring to  FIG. 1  a data processing system  1  is for executing operations for a financial institution. The business aspects of the operations may, however, be of any type and the invention is concerned instead with the underlying technical features for system performance, ease of initialisation, and ease of maintenance/upgrade. 
   The system  1  comprises a number of objects  2 , only one of which is shown. Each object  2  is responsible for performing a business event comprising multiple transactions. Each object  2  comprises:
         a container  3 ,   a series of (in this case three) masks  4  contained within the container  3 .       

   Each mask  4  comprises four ON/OFF flags, each flag switching on or off an associated unit of executable code  5 . The units  5  of executable code are fixed and are separately stored, being addressed by the object  2 . 
   If an object  2  has only one mask  4 , the complete event is implemented by executing some or all of the four units  5 , each unit  5  implementing a transaction. The maximum capacity of an object  2  is 16 masks, and so up to 64 transactions may be used to implement the event. 
   In this embodiment an event is called a “corporate action”, being the term used for an event for a securities system. Such an event may, for example, by splitting of a shareholder&#39;s set of shares. 
   An important aspect is that there is only a limited number of executable units  5 , in this embodiment four. These four units have code to implement the following transactions, expressed at the business level.
     (i) Keep Existing Securities Yes/No—does the customer keep their existing shares as a result of this corporate action? If No then these securities are transferred out of the account.   (ii) Receive New Securities Yes/No—does the customer receive new securities as a result of this corporate action? If Yes then the new securities are transferred into the account.   (iii) Receive Cash Yes/No—does the customer receive cash as a result of this corporate action? If Yes then a cash amount is transferred into the account.   (iv) Pay Cash Yes/No—does the customer have to pay cash as a result of this corporate action? If Yes then a cash amount is transferred out of the account.   

   In this embodiment, each transaction is a single-direction asynchronous transfer, without an acknowledgement. It has been found that such a requirement for the transactions provides for efficient system operation and for effective breakdown of events. 
   Of course, the operations or transactions may be of any type other than the above, depending on the nature of the business. An advantageous aspect is that there is a limited and fixed number defined for the event. 
   In each mask  4  a “1” bit flag indicates that the associated unit  5  is to be used, and a bit “0” flag indicates that it is not to be used. Each executable unit  5  implements a transaction arising from a rule such as the rules (i) to (iv) set out above. There is therefore no need for inter-table fetches and so database access is kept to a minimum. 
   In practice, an object may have many masks  4 . Thus, the masks  4  are stored in one or more longs, each of 64 bits, each long containing sixteen masks. Where there are more than sixteen masks there are two or more longs. 
   The structure is not logically hierarchical. The container  3  contains a number of masks, all masks being at the same level, in a “flat” logical architecture. The system processor executes the units  5  of the masks in succession, treating all of the masks and associated transactions as being at the same level. 
   The longs are stored in a “rulearray”  20  comprising, as shown in  FIG. 2 :
         an index  21  being the position of the long in the rulearray,   a decimal value  22  being the value of the long at that position, and each long is represented at the binary level by 64 bits.       

   The binary representations of the decimal value is the series of bits making up the long. This manner of storing the masks is very efficient and simple—additional transactions being achieved by simply adding to the longs. 
   Referring to  FIG. 3 , initialisation of an object for a corporate action is shown. In this diagram the series of four decision steps on the right hand side sets the mask for each action, the commands:
 
rule=rule+1, 2, 4, 8
 
inserting the bit in the mask at the correct position. In this diagram the first position is the LSB, and so on.
 
   When a mask is defined the long is updated to include the new mask. The “factor” sets the position in the long. For example, the third position is indicated by factor value 2. The command:
 
rule=rule+(factor*10)
 
in which (factor*10), shifts the mask value to the correct position in the long. For example, for the third position in a long there is a factor value of 2 and (factor*10) adds all preceding values to the mask value to inherently define the position.
 
   In  FIG. 3  the parameter “index” means the number of the long, the index being 0 for the first long. 
   The rulearray is built up in iterations as shown in  FIG. 3 . Once set up it does not change until off-line modification is made by executing the method of  FIG. 3 . 
   This is a major advance for system initialisation and ongoing modification/upgrade, as it significantly minimises system architecture complexity and engineering manpower. All that is required for a new upgrade is to execute the process of  FIG. 3  to create a new object. Modification of an existing object is achieved by simply deleting the existing one and generating a fresh one using the method of  FIG. 3  and generating a fresh one according to the process of  FIG. 3 . Also, system performance is excellent even for complex events because of the “flat” series mask sequence. This avoids iterative loops between different code hierarchical levels as has happened in the prior art. Another advantage arising from the structure of the objects  2  is that overall system architecture is easy for systems analysts to visualise and understand. 
   It will be appreciated that the invention allows a system to have a simple structure even if the operations to be performed are complex. Re-configuration is easily achieved by simply re-executing the setup process of  FIG. 3 . 
   The invention is not limited to the embodiments described but may be varied in construction and detail. For example, the events implemented by the objects may be other than those referred to as “corporate actions”. Also, the masks may have flags other than binary bits, although binary representation is an efficient one.