AU2011201335B2

AU2011201335B2 - A system for matching orders in a single threaded matching engine for stock exchanges

Info

Publication number: AU2011201335B2
Application number: AU2011201335A
Authority: AU
Inventors: Rajesh K. Mansharamani
Original assignee: Tata Consultancy Services Ltd
Current assignee: Tata Consultancy Services Ltd
Priority date: 2010-03-31
Filing date: 2011-03-23
Publication date: 2012-06-21
Anticipated expiration: 2031-03-23
Also published as: AU2011201335A1

Abstract

A SYSTEM FOR MATCHING ORDERS IN A SINGLE THREADED MATCHING ENGINE FOR STOCK EXCHANGES A system for matching order in a single threaded matching engine for stock exchanges, the said system comprising of a shared memory data structure for an order book adapted to be used for storing at least one buy order and at least one sell order in predefined index, a plurality of program instructions are configured to cause a processor to validate 10 at least one active order received from at least one active client; send order confirmation information to the active client after validating the order; match at least one active order against at least one passive order in the order book in a time price priority characterized by handling at least I million orders/sec with 1pI second latency and also handling at least 50% of trades for stock exchanges and send trade confirmation information to the 15 active client and a passive clients.

Description

- 1 AUSTRALIA PATENTS ACT 1990 COMPLETE SPECIFICATION FOR A STANDARD PATENT ORIGINAL Name of Applicant/s: Tata Consultancy Services Limited Actual Inventor/s: Rajesh K Mansharamani Address for Service is: SHELSTON IP 60 Margaret Street Telephone No: (02) 9777 1111 SYDNEY NSW 2000 Facsimile No. (02) 9241 4666 CCN: 3710000352 Attorney Code: SW Invention Title: A SYSTEM FOR MATCHING ORDERS IN A SINGLE THREADED MATCHING ENGINE FOR STOCK EXCHANGES The following statement is a full description of this invention, including the best method of performing it known to me/us: File: 69820AUP00 -2 A SYSTEM FOR MATCHING ORDERS IN A SINGLE THREADED MATCHING ENGINE FOR STOCK EXCHANGES FIELD OF THE INVENTION 5 The present invention relates to matching engine for stock exchange and more particularly relates to a system and method for matching orders in a single threaded matching engine for stock exchange. 10 BACKGROUND OF THE INVENTION Any discussion of the prior art throughout the specification should in no way be considered as an admission that such prior art is widely known or forms part of common general knowledge in the field. 15 With the advent of algorithmic trading, stock exchanges have been empowered to process tens of thousands of orders per second, and this number is increasing with increased traders and associated trade volumes. With increasing volumes, the system for trading at stock exchanges is expected to process at least 0.1 million orders per second, 20 even on a single stock. A typical computing solution employed to handle increased trade orders and associated data is providing a horizontal scalability to the system i.e. use of several instances of matching engines connected in parallel, that will service the load in a scalable fashion. 25 However, in stock exchanges, particularly in emerging markets, it is quite often that a few stocks may dominate trading activity in the day. It is not uncommon to see a single hot stock have more than 10% of transactions in the day and some RFPs by stock exchanges specify 30% activity in a hot stock. On a single stock the requirement by stock exchanges is to have first come first serve processing which results in a single 30 instance of matching having to service enormous number of orders. In algorithmic trading it may be the case that trades are far less than quotes or orders. In emerging markets like India and China, trades are far in excess as compared to the -3 developed markets, wherein the total orders processed in the entire day is around 10-20 million in the largest stock exchange (capital market) and the total trades per day is of the order of 10 million in the capital market. 5 The multicore servers may offer faster computing solutions, wherein each core thereof possesses a limited processing capacity. Hence, even after employing multicore servers, it is imperative to modify the execution process of a single instance on a single core of multicore servers. 10 In accordance with the computing capabilities for data processing, presently available, for processing huge volumes of trade orders, an efficient order data handling, reporting and broadcasting solution is required which would demonstrate a capability of handling a huge order data and trade execution at a latency less than one microsecond and not being constrained by hardware limitation or enhancement thereof. Further, such a 15 solution needs to have an adaptability to be deployed on the existing trading systems as well as on the new hardware with equal ease. SUMMARY OF THE INVENTION 20 Before the present systems and hardware enablement are described, it is to be understood that this invention is not limited to the particular systems, methods and hardware described, as there can be multiple possible embodiments of the present invention and which are not expressly illustrated in the present disclosures. It is also to be understood that the terminology used in the description is for the purpose of 25 describing the particular versions or embodiments only, and is not intended to limit the scope of the present invention which will be limited only by the appended claims. A principle embodiment of the present invention is to provide a matching system and method for stock exchanges that shall provide an efficient order data handling, reporting 30 and broadcasting solution, with reduced latency, for processing of more than one million orders per second. The invention provides for one or more of the following: acquiring, encoding, assembling, comparing, storing, retrieving, decoding, extracting, and using an order data for execution of order matching process.

-4 In an embodiment of the invention, the order data is encoded into a predefined core data structure and further assembled into the plurality of assemblers on a computer readable medium. The data structures comprising a plurality of fields which may contain actual or implied field values, and data associated therewith that relates to the plurality of order 5 data fields. Encoded order data may be viewed as data that attaches meaning to field values, describing data for the plurality of fields in the coded data structure, e.g., data that describes or interprets the data type of the field values and/or the nature or name of the data. 10 Further, in an embodiment of the invention, data associated with a coded data structure may not only provide a basis for interpreting the field values of the order data fields of coded data structures, but also function as a descriptor for a coded data structure. Functioning as a descriptor, encoded order data may indicate what information is represented by the field values or the nature thereof or by the name of the coded data 15 structure, or represent an action or a type of information associated with a particular coded data structure. A text may be used in coded data structures in an embodiment of the invention as a look up to obtain describing data for each of the order data fields. The text may also serve to provide in human readable form a description of the coded data structure, e.g., "MaxOrderNodes" which as mentioned above, describes maximum size 20 of the order book in terms of passive orders. In an embodiment of the invention, a system manifested by the present invention, a computer system, temporarily stores received data from one or more client, e.g., either buyer or seller of one or more securities, into a order list on a computer-readable 25 medium, and assembles, encodes and/or populates the data into the coded data structures in accordance with a core data structure. In accordance with an embodiment of the invention, a set or group of coded data structures is provided that includes required order data fields and one or more implicitly included optional fields.

-5 Coded data structures may include dynamic or real time values of the order data, such as ticker and trade values. A particular coded data structure may include dynamic information, static information, or both. In a financial services embodiment, coded data structures may include values related to trades, quotes, etc. 5 The term "computer system" is used in a broad sense, and includes, e.g., computer comprising at least one processor and volatile and non-volatile storage accessible thereby and at least one device adapted to input, output, or both. A computer system may also comprise a plurality of connected computers. In a real time financial trading embodiment, a trade order computing computer system 10 processes order data for matching, validation and confirmation of the client. As described above, a trade order computing computer system may receive order data from the clients, wherein the clients are communicatively coupled with the said trade computing system. An active client computer system in the present invention is manifested by remote buyers and seller trading securities on the stock exchange. 15 In one embodiment of the invention, the trade order data acquired into the computer system of the present invention is stored in an order book on a computer readable medium. The order book is stored in the present invention on a shared memory implementation of the computer readable medium. The matching engine envisaged in 20 the present invention has order matching instances associated with each trade order. Each matching instance processes a range of securities and processed in the shared memory. In one embodiment of the invention, a system for matching orders in stock exchanges 25 comprising of at least one processor with one or more associated cores thereof, a computer-readable medium electronically coupled to the at least one processor, the computer-readable medium comprising instructions and an order data stored thereon in the order list. The instructions, when executed by the at least one processor, directs the at least one processor to receive an order data signal related to a tradable security from an 30 active client computer system. The present system is adapted to operate in the multiple client computer systems in the network environment connected with the stock exchange and inputting order data into the I/O system of the matching engine of the stock -6 exchange, interacting and receiving the order conformation and security transaction thereof. In another significant embodiment of the present invention a shared memory is 5 configured for the order book. The shared memory is implemented for handling multiple order matching instances. For enabling order data computing, matching and logical decision making with the assistance of the said shared memory, plurality of order data assemblers are structured to store order data. The Order data acquired into the system of the present invention is modeled and stored in the corresponding assembler. The order 10 data stored in the assembler, mostly, encoded in accordance with a predefined core data structures. The core data structure defined, for the purpose of the present invention is intended, to store hashed and indexed quantities associated with the each order data. Thus, assemblers store information related to buy and sell orders in their respective coded data fields. A first set of orders, received in the matching engine of the present 15 invention, and yet to be processed are designated as "active orders" and a second set of orders which are received and upon processing if no matching is possible or if balanced order quantity remained to be matched are designated at "passive orders". The matching engine of the present invention is adapted to run a plurality of order 20 instances and each matching instance may be associated with the range of tradable securities. A plurality of program instructions configured to cause a processor to receive and validate trading orders from the active clients. Subsequently, the matching engine conducts a predefined matching process, generally in compliance with the rules of the stock exchange; at least one active order is matched against at least one passive order in 25 the order book in a time price priority. In another embodiment of the invention, a method for matching orders in stock exchanges is disclosed, the method comprises of computer implemented steps of: receiving order data from the clients and storing into an orderlist of the order book 30 stored thereon a shared memory. The said order is validated and receipt thereof is confirmed with the associated client. The order is identified as a buy order or a sell order in accordance with the 1/0 data capture system. A header, one of the assemblers, -7 associated with a shared memory, contiguously stores order data associated with the plurality of the order data related to one or more securities. The header typically comprising of range of securities associated with the matching 5 instance, MaxOrderNodes signifying maximum size of the order book, MaxPriceNodes signifying maximum number of nodes matching the order price, OrderFreeListHead signifying header information of a list of new free order nodes and allocated space therefor, a PriceHashTable adapted to store price value associated with at least one security, wherein SellPriceHashTable maintains a hash table of sell orders, and 10 BuyPriceHashTable maintains a hash table for buy orders, a PriceHeaps adapted to store binary status of at least one security, wherein a SellPriceHeap stores a binary heap of sell prices arranged as a minheap data structure adapted to keep a minimum element of LeastSellPrice at the top of the structure for matching of the buy order and a BuyPriceHeap stores a binary heap of buy prices arranged as a maxheap data structure 15 adapted to keeps a maximum element of maxbuysellprice at the top of the structure for matching of the sell order. The method for matching orders further comprises of running a matching routine to match at least one active order against at least one passive order in the order book in the 20 time price priority derived from the core data structure stored in the respective assemblers and matching the corresponding order data fields of the assembler with the matching instance for a successful trade of at least one ordered security. According to a first aspect of the present invention there is provided a system for 25 matching orders in stock exchanges, the said system comprising of: at least one processor of a computing system associated with a matching engine of the stock exchange; 30 at least one core associated with the processor; at least one active client computer system, communicatively coupled with the processor of the matching engine and manifested by at least one buyer or at least -8 one seller, trading at least one security and inputting at least one data signal into the system; a computer-readable medium electronically coupled to the at least one processor, 5 the computer-readable medium comprising instructions, when executed by the at least one processor, directing the at least one processor to: receive a first data signal from a active client computer system, wherein the first data signal comprises a first order for a tradable security and further comprises a first indicator, wherein the first indicator of the first data signal indicates that the first 10 order of the first data signal is stored in a order list; at least one order book stored thereon the said computer-readable medium, adapted to store at least one buy order and at least one sell order in a predefined coded order data signal; 15 a shared memory configured for at least one order book for processing plurality of matching instances associated with at least one order data; a core data structure assigned to each order data signal received therefrom the 20 each client, describing plurality of primitive descriptors associated with type, value, action and nature of each order data fields, stored in an associated indexed binary hash table; a set of order data assemblers configured to implement the shared memory 25 processing, aggregating and retrieving plurality of encoded order data fields in accordance with the predefined core data structure for matching operations; a plurality of matching instances associated with the shared memory, wherein each matching instance is associated with the range of tradable securities; 30 a plurality of program instructions configured to cause a processor to validate at least one active order received from the at least one active client, to cause the processor to send order confirmation information to the active client after -9 validating the order and further configured to cause the processor to match at least one active order against at least one passive order in the order book in a time price priority. 5 According to a second aspect of the present invention there is provided a method for matching orders in stock exchanges, the method comprising of computer implemented steps of: receiving at least one order from at least one client into an orderlist of at least one 10 order book stored thereon a shared memory of at least one core of at least one processor; encoding the order data associated with each order in conformity with a predefined core data structure; 15 validating the active order associated with the client; assembling the encoded order data into a set of order data assembler, wherein each member of the order data assembler describing plurality of primitive 20 descriptors of the order data associated with type, value, action and nature of each order data fields; sending confirmation information to the client regarding stacking of the order into the order book in an associated indexed binary hash table and processing 25 status thereof; determining if the order type is a buy order or a sell order; configuring a header, a first assembler member, associated with a shared memory 30 coupled with at least one core of at least one processor, wherein the header aggregating plurality of order data associated with at least one matching instance of at least one security in conformity with core data structure, and includes a range of securities associated with the matching instance, MaxOrderNodes -10 indicating maximum size of the order book, MaxPriceNodes indicating maximum number of nodes matching the order price, OrderFreeListHead indicating header information of a list of new free order nodes and allocated space therefor, a PriceHashTable adapted to store price value associated with at 5 least one security, wherein SellPriceHashTable maintains a hash table of sell orders, and BuyPriceHashTable maintains a hash table for buy orders, a PriceHeaps adapted to store binary status of at least one security, wherein a SellPriceHeap stores a binary heap of sell prices arranged as a minheap data structure adapted to keep a minimum element of LeastSellPrice at the top of the 10 structure for matching of the buy order and a BuyPriceHeap stores a binary heap of buy prices arranged as a maxheap data structure adapted to keeps a maximum element of maxbuysellprice at the top of the structure for matching of the sell order; and 15 running a matching routine, wherein matching at least one active order against at least one passive order in the order book in the time price priority derived from the core data structure stored in the header and matching the corresponding order handling components for a successful trade of at least one ordered security. 20 It is an object of the present invention to overcome or ameliorate at least one of the disadvantages of the prior art, or to provide a useful alternative. Unless the context clearly requires otherwise, throughout the description and the claims, the words "comprise", "comprising", and the like are to be construed in an 25 inclusive sense as opposed to an exclusive or exhaustive sense; that is to say, in the sense of "including, but not limited to". BRIEF DESCRIPTION OF THE DRAWINGS 30 The foregoing summary, as well as the following detailed description of preferred embodiments, are better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings - I1 example constructions of the invention; however, the invention is not limited to the specific methods and system disclosed. In the drawings: Figure 1 shows a system architecture diagram for order matching engine in stock 5 exchanges according to multiple exemplary embodiments of the invention. Figure 2 shows the layout of the shared memory for the order book relevant to a single instance of a matching system according to one embodiment of the invention. 10 Figure 3 shows the PriceHashTable data structure according to one embodiment of the invention. Figure 4 shows examples of the heap data structure for both minheap and maxheap according to one embodiment of the invention. 15 DETAILED DESCRIPTION OF THE INVENTION Some embodiments of this invention, illustrating all its features, will now be discussed in detail. The words "comprising," "having," "containing," and "including," and other 20 forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms "a," "an," and "the" include plural references unless the context clearly dictates otherwise. 25 Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present invention, the preferred, systems and methods are now described. The disclosed embodiments are merely exemplary of the invention, which may be embodied in various forms. 30 Orders in a stock exchange are matched against an order book that is maintained by the exchange. An incoming order is called an active order and orders that lie in the order book are called passive orders. An order typically comprises of the following fields: e security (which stock is the order for); - 12 e client id (who is the buyer or seller); * side (is this a buy order or a sell order); " quantity (number of shares); and " price (at which to buy or sell). 5 An active buy order will be matched against passive sell orders held in the order book in time price priority. This means that the best price for the buyer (i.e. lowest sell price) is taken up and for a given price the matching is in first come first serve order. A single buy order with a large quantity can match multiple sell orders with smaller quantities. 10 An active sell order will be matched against passive buy orders held in the order book in time price priority. This means that the best price for the seller (i.e. highest buy price) is taken up and for a given price the matching is in first come first serve order. A single sell order with a large quantity can match multiple buy orders with smaller quantities. 15 Each match is called a trade. The general flow of an order arriving at a matching engine is as follows: a) Validate order; b) Send order confirmation to client; 20 c) Match against orders in the order book in time price priority until no further match is possible (that is for an active buy order all passive sell prices are higher than quoted price or for an active sell order all passive buy prices are lower than quoted price); and d) For each trade (matched order) send a trade confirmation to both parties (active 25 and passive clients). The present invention provides a matching system and method for processing more than one million orders per second and also handles at least fifty percent of trades (2:1 ratio of orders to trades) for stock exchanges. 30 Figure 1 shows a system architecture diagram for order matching engine in stock exchanges according to multiple exemplary embodiments of the invention. A system 100 - 13 for matching orders in stock exchanges, the said system 100 comprising of: at least one processor 132 (not shown in the figure), at least one core associated with the above said processor 132, one active client computer systems 134 and one passive client computer systems 130 (not shown in the figure) communicatively connected to each other by a 5 communication network for trading at least one security. In a preferred embodiment of the invention, the processor 132 is computer. The communication network is selected from the internet, intranet, Wide area network (WAN), Local Area Network (LAN) or Metropolitan Area Networks (MAN), etc. In a 10 preferred embodiment of the invention, the communication network is internet. The above active client computer systems 134 is manifested by at least one buyer 138 (not shown in the figure) and the above passive client computer systems 130 is manifested by at least one seller 140 (not shown in the figure), for trading at least one security and inputting at least one order data signal into the system 100. A computer-readable 15 medium 136 electronically coupled to the processor 132, wherein the computer-readable medium 136 comprising instructions, when executed by the processor 132, direct the processor 132 to: receive a first order data signal from the active client computer system 134, wherein the first data signal comprises a first order for a tradable security and further comprises a first indicator, and validating the receipt of the first order data signal 20 and storing it in a order list. At least one order book 110 (not shown in the figure) stored thereon the said computer-readable medium 136. A shared memory 112 configured for the order book 110 comprising of plurality of order data assemblers, each assembler is associated with corresponding order data fields. The information stored in each assembler is encoded in accordance with the predefined core data structure. The core 25 data structure is meant to store hashed and/or indexed quantities associated with each order data. A plurality of instances associated with the order data, wherein each matching instance is associated with the range of tradable securities. A plurality of program instructions 30 configured to cause a processor 132 to validate at least one active order 102 received from the active client 134, to cause the processor 132 to send order confirmation information 106 to the active client 134 after validating the order and further configured - 14 to cause the processor 132 to match at least one active order 102 against at least one passive order 142 in the order book 110 in a time price priority. A stock market provides a facility for traders to buy and sell securities (colloquially 5 known as stocks). Consider for example that a trader A posts an order to sell 100 units of security X at price 50.75. If subsequently a trader B posts an order to buy 75 units of security X at price 51, this will result in match for the buyer. As a result a trade occurs wherein 75 units of security X are sold at price 50.75 from trader A to trader B. Stock exchanges provide an electronic trading facility to thousands of traders. At the core of 10 trading system is the matching engine 104 that maintains pending or passive orders 142 of both buyers 138 and sellers 140, and whenever a new order (active order) enters the exchange it attempts to match the active order 102 against the passive orders 142. This is the core component of the functionality. It provides validation of order, and matching of orders entering the exchange. It generates order confirmation 106 and trade 15 confirmations 108 to be sent back to the trader. The above said system 100 maintains the shared memory data structure 112 for order book 110 for buy orders and for sell orders. This is the database of pending & confirmed orders in the system 100. For an active buy order 102, the processor 132 needs to 20 compare it with passive sell orders 142 in the order book 110 that are at either at lower price or the same price (in ascending order of price). Conversely, for an active sell order 102, the processor 132 needs to compare it with passive sell orders 142 in the order book 110 that are either at price higher or the same price (in descending order of price). 25 Before the order can be matched, it needs to be validated by the processor 132. The validation includes basic checks on the security, client id, side, price, quantity and other such attributes of the order. In some stock exchanges there also a guard against short selling. In other words, an investor cannot 'sell' a security unless he holds enough positions to place the sell order. This guard is against the investor, after first selling and 30 later buying securities without having any security holdings to begin with. Once an order is validated, it is a confirmed order 106 in that the exchange has accepted it and proceeds to process it for matching is as mentioned below. The matching engine 104 needs to send an order confirmation 106 back to the trader within a specific response time so that - 15 the trader can quickly know whether his order has been accepted or rejected by the exchange. Figure 2 shows the layout of the shared memory for the order book 112 relevant to a 5 single instance of a matching system according to one embodiment of the invention. We assume that each matching instance processes a range of securities (stocks) and for the sake of convenience assume a sequential number of securities. The ranges need not be uniform and thus our proposal naturally provides for hot stocks. 10 According to one embodiment of the invention, the shared memory 112 for the order book 110 comprises of plurality of order data assemblers for aggregating order data information in accordance with predefined representation of type, value, action and nature of each order data fields prescribed by a core data structure, wherein the order data assemblers comprises of a header 114, at least one offset 116, a PriceHashTable 15 118, a PriceHeaps 120, Free Order Nodes 122, Order Data 124, Free Price Nodes 126 and Price Data 124. The above said header 114 contiguously stored with plurality of order data fields associated with at least one matching instance of at least one security, wherein the said 20 order data fields includes start security indicating range of securities associated with the matching instance, end security indicating last security associated with the matching instance, MaxOrderNodes indicating maximum size of the order book, MaxPriceNodes indicating maximum number of nodes matching the order price, OrderFreeListHead indicating header information of a list of new free order nodes and allocated space there 25 for, and PriceFreeListHead indicating a header information of a list of new free price nodes and allocated space therefor; The above said offset 116 adapted to point to the data structures that maintain price and order information of at least one tradable security, wherein the shared memory data 30 structure 112 of the offsets 116 adapted to invoke price and order information of each security and acts as pointers to the plurality of order handling components of the shared memory 112 including Order Data 124, Free Order Nodes 122, Price Data 128, and Free Price Nodes 126; -16 The said PriceHashTable 118 (shown in the Figure 3), comprises of a SellPriceHashTable 118a and a BuyPriceHashTable 118b (not shown in the figure), adapted to store price value associated with at least one security, wherein the 5 SellPriceHashTable 118a maintains a hash table of sell orders, hashed by the order price and the BuyPriceHashTable 118b that maintains a hash table for buy orders, hashed by the order price; The said PriceHeaps 120, comprises of SellPriceHeap 120a and BuyPriceHeap 120b 10 (not shown in the figure), adapted to store binary status of at least one security, wherein the SellPriceHeap 120a stores a binary heap of sell prices arranged as a minheap data structure (shown in the figure 4) adapted to keep a minimum element at the top of the structure thererby allowing the minimum element to match against at least one active buy order and the minimum element realizing the sale price related to sale order from 15 the SellPriceHashTable 118a for at least one actual order instance generated by at least one buyer 138 and the BuyPriceHeap 120b stores a binary heap of buy prices arranged as a maxheap data structure (shown in the figure 4) adapted to keeps a maximum element at the top of the structure thereby allowing the maximum element to match against at least one active sell order and the maximum element realizing the buy price 20 related to buy orders from the BuyPriceHashTable 118b for at least one actual order instance generated by at least one seller 140, wherein PriceHashTables 118 and PriceHeaps 120 are maintained per security. The offsets 116 are designated for above mentioned four critical data structures 25 associated with each security. Two offsets 116 for buy orders and two offsets for sell orders are designated. Once the price is determined for matching the actual orders 102 to be matched against the orders 142 are found via the SellPriceHashTable 118a or BuyPriceHashTable 118b that maintains a hash table of sell orders or buy orders respectively, hashed by the order price; 30 The Free Order Nodes 122 linked via linked list and Order Data 124 adapted to store order data wherein each new order is compared with the existing orders and arranged in price time priority in the order book 110; and the Free Price Nodes 126 wherein each - 17 price node is linked with another in the PriceHashTable 118 and Price Data 128 adapted to store price node data. The present invention proposes the shared memory 112 implementation for the order 5 book 110. While this may appear to slow down performance of the processor, fault tolerance limit is higher. Having a shared memory implementation naturally lends itself to fault tolerance. The plurality of program instructions configured for shared memory 112 implementation of the order book 110 causes the processor 132 to activate and process the matching of a standby instance in the same shared memory region, thereby 10 reducing the recovery time of the processor 132. Figure 3 shows the PriceHashTable data structure 118 according to one embodiment of the invention. The PriceHashTable 118 applies to both BuyPriceHashTable 118a and SellPriceHashTable 118b. Essentially a PriceHashTable 118 has a HashTable indexed 15 by price. Assuming that prices can be represented as integers we can use a simple hash function as: h(price) = price mod k 20 Where k is the size of the hash table and is usually a prime number. It is better to keep k as large as possible depending on the memory available. Typically in stock exchanges a value in the order of 10000 provides a good balance between memory and speed. When an orders needs to be inserted, the plurality of program instructions are configured 25 to cause the processor 132 to first hash the price in to the PriceHashTable 118. Then for buy orders, the processor 132 scans through in ascending order of price the list of price nodes, whereas for sell orders, the processor 132 scans through in descending order of price. The hashing on price points to a PriceNode that contains the list of orders at the given price and is part of a doubly linked list for ease of adding and removing price 30 nodes. To add an order at a given price, the plurality of program instructions are configured to cause the processor 132 to insert the order at the tail of the orderlist and for removing an order, the processor 132 removes from the head of the orderlist. This preserves the price time priority requirement of the exchange. Thus it is expected to - 18 maintain both the head and the tail of the orderlist to execute orders in the price time priority. For inserting an order it is quite clear that the PriceHashTable structure 118 suffices. 5 However, when the active order 102 comes in to the matching instance, the processor 132 first needs to determine whether there are corresponding matching orders 142. Only after matching is complete, the processor 132 writes the remaining (unmatched) order quantity in to the order book 110. For the purpose of matching, the processor 132 needs to access prices in sorted order for which a hashtable is not the best data structure. 10 Instead the present invention proposes the binary heap structure 120, which is mentioned in Data Structures and Algorithms as shown in Figure 4. Figure 4 shows examples of the heap data structure 120 for both minheap and maxheap according to one embodiment of the invention. A minheap is a balanced binary tree such 15 that the value of each node is less than the value of its children. This means that the root node will always have the minimum value. A maxheap is a balanced binary tree such that the value of each node is greater than the value of its children. This means that the root node will always have the maximum value. 20 Efficient implementation of the heap data structure 120 is possible by representing the heap as an array which is mentioned in Data Structures and Algorithms. If the root node is numbered I, then for a node i its children are at positions 2i and 2i+1 in the array and its parent is at position i/2. 25 The minheap data structure provides for three operations of finding minimum element, removal of minimum element and insertion of a new element and accordingly exploits findmino, removeminelemento and insertelement(value) methods modeled therefor. Likewise the maxheap provides for three operations of finding maximum element, removal of maximum element and insertion of a new element and accordingly exploits 30 findmaxo, removemaxelement() and insertelement(value) methods modeled therefor. The findmin() and findmaxo operations are of complexity 0(1), and all the other operations are of complexity O(log n). In the present invention, arrays are employed for - 19 heap implementation, wherein "n" is number of elements in the heap and designates the size of the heap. According to one exemplary embodiment of the invention, the process of matching the 5 active buy order 102 against passive sell orders 142 held in the order book 110 in time price priority is as mentioned below. An active buy order 102 will be matched against passive sell orders 142 held in the order book 110 in time price priority by the processor 132. This means that the best price for the buyer 138 (i.e. lowest sell price) is taken up and for a given price the matching is in first come first serve order. A single buy order 10 102 with a large quantity can match multiple sell orders 142 with smaller quantities. The plurality of program instructions are configured to cause the processor 132 to provide validation of order, and matching of orders entering the exchange. Let B be the active buy order, SellPriceHeap 120a is a minheap that maintains unique prices of sell orders, SellPriceHash Table 118a hashes to price nodes that link to sell orders, and 15 BuyPriceHash Table 118b hashes to price nodes that link to buy orders. The plurality of program instructions are configured to cause the processor 132 to match at least one active buy order 102 against at least one passive sell order 142 in the order book 110 in a time price priority characterized by handling at least one million orders 20 per second by the processor implemented steps for executing a logic routine of the matching engine 104. After processing order matching, the plurality of program instructions are configured to cause the processor 132 to send trade confirmation 108 information after matching at least one active buy order 102 to be sent back to the trader. 25 According to one exemplary embodiment of the invention, the process of matching the active sell order 102 against passive buy orders 142 held in the order book 110 in time price priority is as mentioned below:. An active sell order 102 will be matched against passive buy orders 142 held in the order book 110 in time price priority. This means that the best price for the seller 140 (i.e. highest buy price) is taken up and for a given price 30 the matching is in first come first serve order. A single sell order 102 with a large quantity can match multiple buy orders 142 with smaller quantities. The plurality of program instructions are configured to cause the processor 132 to provide validation of order, and matching of orders entering the exchange. Let S be the active sell order, -20 BuyPriceHeap 120b is a maxheap that maintains unique prices of buy orders, BuyPriceHash Table 118b hashes to price nodes that link to buy orders and SellPriceHash Table 118a hashes to price nodes that link to sell orders. 5 The plurality of program instructions are configured to cause the processor 132 to match at least one active sell order 102 against at least one passive buy order 142 in the order book 118 in a time price priority characterized by handling at least one million orders per second by the following processor implemented steps for executing a logic routine of the matching engine 104. After processing order matching, the plurality of program 10 instructions are configured to cause the processor 132 to send trade confirmation 108 information after matching at least one active buy order 102 to be sent back to the trader. According to another embodiment of the invention, the plurality of program instructions configured to run on at least one core of the processor 132 and runs at least one thread 15 for at least one input instance. According to one exemplary embodiment of the invention, the above mentioned matching system 100 is adapted to be implemented by means of multicore server architecture, wherein, according to one exemplary embodiment, the server can be selected from Intel Nehalem EX Server with Xeon 2.8 GHz CPU. 20 According to another embodiment of the invention, the system 100 is configured for shared memory implementation 112 for handling core data structure thereby exploiting plurality of core associated with plurality of the processors 132 and facilitating core intensive operations that consumes significant processor resources and causes utilization 25 of the processors 132 to execute I million orders per second in a single instance of a single threaded matching engine, to execute 1 million orders per second with successful trade execution exceeding 50% of the matching engine and to execute 1 million orders per second with less than 1 microsecond latency in the matching engine. 30 According to another embodiment of the invention, a method for matching orders in stock exchanges, the method comprising of various computer implemented steps of receiving at least one order 102 from at least one client 134 into a orderlist of at least one order book 110 stored thereon a shared memory 112 of at least one core of at least one -21 processor 132; in the next step of the proposed method, encoding the order data associated with each order in conformity with a predefined core data structure; in the next step of the proposed method, validating the active order 102 associated with the client 134 by the processor 132; In the next step of the proposed method, assembling the 5 encoded order data into a set of order data assembler, wherein each member of the order data assembler describing plurality of primitive descriptors of the order data associated with type, value, action and nature of each order data fields; in the next step of the proposed method, sending confirmation information 106 to the client 134 regarding stacking of the order into the order book 110 and processing status thereof the processor 10 132; In the next step of the proposed method, determining if the order type is a buy order or a sell order by the processor 132; in the next step of the proposed method, configuring a header 114, one of the assemblers, to aggregate order data information in different data fields in accordance with a predefined core data structure. 15 The header 114 further comprise of data fields for range of securities associated with the matching instance, MaxOrderNodes signifying maximum size of the order book 110, MaxPriceNodes signifying maximum number of nodes matching the order price, OrderFreeListHead signifying header information of a list of new free order nodes and allocated space there for, a PriceHashTable 118 adapted to store price value associated 20 with at least one security, wherein SellPriceHashTable 118a maintains a hash table of sell orders, and BuyPriceHashTable 118b maintains a hash table for buy orders, a PriceHeaps 120 adapted to store binary status of at least one security, wherein a SellPriceHeap 120a stores a binary heap of sell prices arranged as a minheap data structure adapted to keep a minimum element of LeastSellPrice at the top of the structure 25 for matching of the buy order and a BuyPriceHeap 120b stores a binary heap of buy prices arranged as a maxheap data structure adapted to keeps a maximum element of maxbuysellprice at the top of the structure for matching of the sell order. In the final step of the proposed method, running a matching routine process 104 for 30 matching at least one active order 102 against at least one passive order 142 in the order book 110 in the time price priority derived from the core data structure stored in the header 114 and matching the corresponding values from the related assembler for a successful trade of at least one ordered security.

- 22 According to another embodiment of the invention, for the buy order 102, the matching routine process 104 configured to match plurality of encoded order data fields of the assemblers in the steps of equating a LeastSellPrice of the SellPriceHeap 120a with at 5 least one buy order price, if matching then hashing the sell order into SellPriceHashTable 118a for LeastSellPrice and matching buy order quantity against orders held at LeastSellPrice of the SellPriceHashTable 118a. After the matching process, generating trade realization messages 108 for matched orders and sending the trade message to each client associated with the trade and sell 10 orders are removed from the order list, whose quantities have been depleted. An iterative routine, checks if buy order quantity is greater than zero after matching all the sell orders at LeastSellPrice of the SellPriceHashTable 118a, executing a matching logic in the further steps of: a) if the buy order greater than zero, quitting the matching routine; 15 b) if the buy order equals to zero, running the matching routine for checking whether the LeastSellPrice of the SellPriceHeap is equal to rest of the orders of the buy order price; once the iterative routine stops, sending trade confirmation information 108 after 20 matching at least one active order 102 with at least the passive order 142 to at least one active client 134 and at least one passive client 130. In case, where a LeastSellPrice of the SellPriceHeap 120a doesn't match with the order price, the matching engine is programmed for hashing the buy order in to 25 BuyPriceHashTable 118b, if the LeastSellPrice of the SellPriceHeap 120a is greater than the buy order price, and inserting the buy order at the end of orderlist of a relevant existing PriceNode, creating a new PriceNode for the buy order and inserting in a descending order of price in a hash map, and inserting buy order at head of the orderlist of the PriceNode. 30 According to another embodiment of the invention, for the sell order 102, the matching routine process 104 configured to match plurality of encoded order data fields of the assemblers in the steps of equating a maxbuysellprice of the BuyPriceHeap 120b with -23 the sell order price, if matching, hashing in to BuyPriceHashTable 118b for maxbuysellprice and matching sell order quantity against orders held at maxbuysellprice of the of the BuyPriceHashTable 118b. Generating trade realization messages 108 for matched orders by the matching routine process 104 and sending the trade message to 5 each client associated with the trade and removing buy orders whose quantities have been depleted. An iterative routine, checks if sell order quantity is greater than zero after matching all the buy orders at maxbuysellprice of the of the BuyPriceHashTable 118b, executing a matching logic in the further steps of: i. if sell order quantity is greater than zero, quitting the matching routine 10 process 104; ii. if sell order quantity equals zero, running the matching routine for checking whether the maxbuysellprice of the BuyPriceHeap 120b is equal to rest of the orders of sell order price; 15 once the iterative routine stops, sending trade confirmation information 108 after matching at least one active order 102 with at least the passive order 142 to at least one active client 134 and at least one passive client 130. In case, where a maxbuysellprice of the BuyPriceHeap doesn't match with the sell order 20 price, the matching engine is programmed for hashing the sell order in to SellPriceHashTable 118a, if maxbuysellprice of the BuyPriceHeap 120b is lesser than the sell order price, and searching relevant PriceNode for the sell order price and inserting sell order at the end of orderlist of relevant existing PriceNode, creating a new PriceNode for the sell order, inserting in ascending order of price in a hash map and 25 inserting sell order at head of the orderlist of the PriceNode. According to another embodiment of the invention, price time priority requirement of the exchange is ensured by inserting at least one order at the tail of the orderlist and for removing at least one order from the head of the orderlist. 30 According to another embodiment of the invention, order insertion in conformity with the core data structures of the order handling components is facilitated by employing hashing of the order price into the PriceHashTable 118, wherein for buy orders, scanning - 24 the price nodes in an ascending order of the price and for sell orders, scanning the price nodes in a descending order of the price. According to another embodiment of the invention, hashing the price points to a PriceNode containing the list of orders at the given price, wherein each PriceNode is configured to be a doubly linked list, facilitating 5 ease of insertion and removal of price nodes. The invention is described in the example given below which is provided only to illustrate the invention and therefore should not be construed to limit the scope of the invention. 10 An order file was created and loaded to memory. Then a test program read an order from memory and did the matching. All output of trades and orders was logged to a memory buffer to prevent the disk from becoming a bottleneck. 15 Real life order data from an Asian stock exchange was used. The data comprised of 100000 orders resulting in 15946 trades. The performance of the single matching thread was 5.23 million orders/sec for a trade rate of 0.84 million trades/sec. The inventor also ran a test on synthetically generated orders such that the trade rate was higher. This was also a file of 100000 orders resulting in 62282 trades. The performance of the single 20 matching thread was 4.53 million orders/sec for a trade rate of 2.82 million trades/sec. The preceding description has been presented with reference to various embodiments of the invention. Persons skilled in the art and technology to which this invention pertains will appreciate that alterations and changes in the described structures and methods of 25 operation can be practiced without meaningfully departing from the principle and scope of this invention.

Claims

1. A system for matching orders in stock exchanges, the said system comprising of: 5 at least one processor of a computing system associated with a matching engine of the stock exchange; at least one core associated with the processor; 10 at least one active client computer system, communicatively coupled with the processor of the matching engine and manifested by at least one buyer or at least one seller, trading at least one security and inputting at least one data signal into the system; 15 a computer-readable medium electronically coupled to the at least one processor, the computer-readable medium comprising instructions, when executed by the at least one processor, directing the at least one processor to: receive a first data signal from a active client computer system, wherein the first data signal comprises a first order for a tradable security and further comprises a first 20 indicator, wherein the first indicator of the first data signal indicates that the first order of the first data signal is stored in a order list; at least one order book stored thereon the said computer-readable medium, adapted to store at least one buy order and at least one sell order in a predefined 25 coded order data signal; a shared memory configured for at least one order book for processing plurality of matching instances associated with at least one order data; 30 a core data structure assigned to each order data signal received therefrom the each client, describing plurality of primitive descriptors associated with type, - 26 value, action and nature of each order data fields, stored in an associated indexed binary hash table; a set of order data assemblers configured to implement the shared memory 5 processing, aggregating and retrieving plurality of encoded order data fields in accordance with the predefined core data structure for matching operations; a plurality of matching instances associated with the shared memory, wherein each matching instance is associated with the range of tradable securities; 10 a plurality of program instructions configured to cause a processor to validate at least one active order received from the at least one active client, to cause the processor to send order confirmation information to the active client after validating the order and further configured to cause the processor to match at 15 least one active order against at least one passive order in the order book in a time price priority.

2. The system of claim 1, wherein the shared memory for the order book comprises of the set of order data assemblers for assembling plurality of order data fields in 20 the accordance with the predefined core data structure, wherein the set of order data assemblers further comprising of plurality of data field assemblers including: a) a header, contiguously stored with plurality of order data fields associated with at least one matching instance of at least one security, wherein the 25 said order data fields includes start security indicating range of securities associated with the matching instance, end security indicating last security stored in the range, MaxOrderNodes indicating maximum size of the order book, MaxPriceNodes indicating maximum number of nodes matching the order price, OrderFreeListHead indicating header 30 information of a list of new free order nodes and allocated space therefor, and PriceFreeListHead indicating a header information of a list of new free price nodes and allocated space therefor; -27 b) at least one offset adapted to point to the data structures that maintain price and order information of at least one tradable security; c) a PriceHashTable adapted to store price value associated with at least one 5 security, wherein a SellPriceHashTable corresponds to the hash table of sell orders and a BuyPriceHashTable corresponds to the hash table for buy order; d) a PriceHeaps adapted to store binary status of at least one security, 10 wherein a SellPriceHeap stores a binary heap of sell prices encoded as a minheap data structure adapted to keep a minimum element at the top of the structure and a BuyPriceHeap stores a binary heap of buy prices encoded as a maxheap data structure adapted to keep a maximum element at the top of the structure; 15 e) Free Order Nodes linked via linked list and Order Data adapted to store order data wherein each new order is compared with the existing orders and arranged in price time priority in the order book; and 20 f) Free Price Nodes wherein each price node is linked with another in the PriceHashTable and Price Data adapted to store price node data.

3. The system of claim 1 or claim 2, wherein the plurality of program instructions 25 configured to run on at least one core of the processor, executing at least one thread corresponding to at least one matching instance of the order data.

4. The system of any one of the preceding claims, further comprising of the plurality of program instructions configured for shared memory implementation 30 of the order book, wherein causing the processor to activate and process the matching of a standby instance in the same shared memory region, thereby reducing the recovery time of the processor. -28

5. The system of claim 2, wherein the offset data field assembler is adapted to invoke price and order information of each security and acts as a pointer to the encoded data structure of the associated order data assigned to plurality of order data assemblers of the shared memory including Order Data, Free Order Nodes, 5 Price Data, and Free Price Nodes.

6. The system of claim 2, wherein the SellPriceHeap data field assembler maintains a binary heap of sell prices encoded as a minheap, wherein the minheap is a data 10 structure configured to keep the minimum value of the element at the top of the structure allowing a logic routine, when executed on the processor, to match at least one active buy order with a minimum price element in accordance with the buy order instance generated by at least one buyer and fetching the sale price from the SellPriceHashTable corresponding to the order; 15

7. The system of claim 2, the BuyPriceHeap data field assembler maintains a binary heap of buy prices arranged as a maxheap, wherein the maxheap is a data structure configured to keep the maximum value of the element at the top of the structure, allowing a logic routine, when executed on the processor, to match at 20 least one active buy order with a maximum price element in accordance with the sell order instance generated by at least one seller and fetching the buy price from the BuyPriceHashTable corresponding to the order;

8. The system of any one of the preceding claims, wherein the system is adapted to 25 be implemented by plurality of cores associated with plurality of processors of multicore server architecture.

9. The system of any one of the preceding claims, wherein the system is configured for shared memory implementation for handling core data structure thereby 30 exploiting plurality of cores associated with plurality of the processors and facilitating core-intensive operations that consumes significant processor resources and causes utilization of the processors to execute I million orders per second in a single instance of a single threaded matching engine. - 29

10. The system of any one of claims 1 to 8, wherein the system is configured for shared memory implementation for handling core data structure thereby exploiting plurality of core associated with plurality of the processors and 5 facilitating core-intensive operations that consumes significant processor resources and causes utilization of the processors to execute I million orders per second with successful trade execution exceeding 50% of the matching engine.

11. The system of any one of claims 1 to 8, wherein the system is configured for 10 shared memory implementation for handling core data structure thereby exploiting plurality of cores associated with plurality of the processors and facilitating core-intensive operations that consumes significant processor resources and causes utilization of the processors to execute 1 million orders per second with less than 1 microsecond latency in the matching engine. 15

12. A method for matching orders in stock exchanges, the method comprising of computer implemented steps of: receiving at least one order from at least one client into an orderlist of at least one 20 order book stored thereon a shared memory of at least one core of at least one processor; encoding the order data associated with each order in conformity with a predefined core data structure; 25 validating the active order associated with the client; assembling the encoded order data into a set of order data assembler, wherein each member of the order data assembler describing plurality of primitive 30 descriptors of the order data associated with type, value, action and nature of each order data fields; - 30 sending confirmation information to the client regarding stacking of the order into the order book in an associated indexed binary hash table and processing status thereof; 5 determining if the order type is a buy order or a sell order; configuring a header, a first assembler member, associated with a shared memory coupled with at least one core of at least one processor, wherein the header aggregating plurality of order data associated with at least one matching instance 10 of at least one security in conformity with core data structure, and includes a range of securities associated with the matching instance, MaxOrderNodes indicating maximum size of the order book, MaxPriceNodes indicating maximum number of nodes matching the order price, OrderFreeListHead indicating header information of a list of new free order nodes and allocated 15 space therefor, a PriceHashTable adapted to store price value associated with at least one security, wherein SellPriceHashTable maintains a hash table of sell orders, and BuyPriceHashTable maintains a hash table for buy orders, a PriceHeaps adapted to store binary status of at least one security, wherein a SellPriceHeap stores a binary heap of sell prices arranged as a minheap data 20 structure adapted to keep a minimum element of LeastSellPrice at the top of the structure for matching of the buy order and a BuyPriceHeap stores a binary heap of buy prices arranged as a maxheap data structure adapted to keeps a maximum element of maxbuysellprice at the top of the structure for matching of the sell order; and 25 running a matching routine, wherein matching at least one active order against at least one passive order in the order book in the time price priority derived from the core data structure stored in the header and matching the corresponding order handling components for a successful trade of at least one ordered security. 30

13. The method of claim 12, wherein, for the buy order, the matching routine configured to match plurality of encoded order data fields of the associated order data assembler in the steps of: -31 equating a LeastSellPrice of the SellPriceHeap with at least one buy order price, if matching: hashing the sell order into SellPriceHashTable for LeastSellPrice and matching buy order quantity against orders held at LeastSellPrice of the 5 SellPriceHashTable; generating trade realization messages for matched orders; removing sell orders, whose quantities have been depleted, from the orderlist; 10 checking if buy order quantity is greater than zero after matching all the sell orders at LeastSellPrice of the SellPriceHashTable, executing a matching logic in the further steps of: a) if the buy order greater than zero, quitting the matching routine; 15 b) if the buy order equals to zero, running the matching routine for checking whether the LeastSellPrice of the SellPriceHeap is equal to rest of the orders of the buy order price; and if not matching: hashing the buy order in to BuyPriceHashTable, if the LeastSellPrice of the 20 SellPriceHeap is greater than the buy order price, and inserting the buy order at the end of orderlist of a relevant existing PriceNode, creating a new PriceNode for the buy order and inserting in a descending order of price in a hash map, and inserting buy order at head of the orderlist of the PriceNode. 25

14. The method of claim 12 or claim 13, wherein, for the sell order, the matching routine configured to match plurality of encoded order data fields of the associated order data assembler in the steps of: equating a maxbuysellprice of the BuyPriceHeap with the sell order price, if 30 matching: -32 hashing the buy order into BuyPriceHashTable for maxbuysellprice and matching sell order quantity against orders held at maxbuysellprice of the of the BuyPriceHashTable; 5 generating trade realization message for matched orders; removing buy orders whose quantities have been depleted; checking if sell order quantity is greater than zero after matching all the buy 10 orders at maxbuysellprice of the BuyPriceHashTable, executing a matching logic in the further steps of: a) if sell order quantity is greater than zero, quitting the matching routine; b) if sell order quantity equals zero, running the matching routine for checking whether the maxbuysellprice of the BuyPriceHeap is equal to 15 rest of the orders of sell order price; sending trade confirmation information after matching at least one active order with at least the passive order to at least one active client and at least one passive client; and 20 if not matching: hashing the sell order into SellPriceHashTable, if maxbuysellprice of the BuyPriceHeap is lesser than the sell order price, and searching relevant PriceNode for the sell order price and inserting sell order at the end of orderlist 25 of relevant existing PriceNode, creating a new PriceNode for the sell order, inserting in ascending order of price in a hash map and inserting sell order at head of the orderlist of the PriceNode.

15. The method of claim 12, wherein price time priority requirement of the 30 exchange, is ensured by inserting at least one order at the tail of the orderlist and for removing at least one order from the head of the orderlist. - 33

16. The method of claim 12, wherein order insertion in conformity with the core data structures into associated order data assembler is facilitated by employing hashing of the order price into the PriceHashTable, wherein for buy orders, scanning the price nodes in an ascending order of the price and for sell orders, 5 scanning the price nodes in a descending order of the price.

17. The method of claim 12, wherein hashing the price points to a PriceNode containing the list of orders at the given price, wherein each PriceNode is configured to be a doubly linked list, facilitating ease of insertion and removal of 10 price nodes.

18. A system for matching orders in stock exchanges substantially as herein described with reference to any one of the embodiments of the invention illustrated in the accompanying drawings and/or examples. 15

19. A method for matching orders in stock exchanges substantially as herein described with reference to any one of the embodiments of the invention illustrated in the accompanying drawings and/or examples.