FORM-2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENTS RULES, 2003
COMPLETE SPECIFICATION
(See section 10; rule 13)
SYSTEM FOR PROVIDING MULTICORE OBJECT FRAMEWORK FOR MULTICORE PROCESSOR ARCHITECTURE
TATA CONSULTANCY SERVICES LIMITED,
an Indian Company
of Nirmal Building, 9th Floor, Nariman Point, Mumbai - 400 021,
Maharashtra, India.
THE FOLLOWING SPECIFICATION PARTICULARLY DESCRIBES THE INVENTION AND THE MANNER IN WHICH IT IS TO BE PERFORMED

FIELD OF THE INVENTION
The present invention relates to the field of processor technology. Particularly, the present invention relates to multicore processor technology.
Still particularly, this invention relates to a system for providing multicore object framework for multicore processor architecture.
BACKGROUND OF THE INVENTION
Over the years the processor technology evolution has come a long way from single processing technology to the latest multicore technology. Evolution of Processor Technology can be given by: single threaded processor technology -> symmetric multiprocessing using celeron dual (SMP) technology -> simultaneous multithreading (SMT) HT technology -> multicore processing technology.
A multicore processor is comprised of two or more independent cores. With the advent of multicore technology, chip manufactures are able to produce multicore processors with faster execution times, increased throughput, less consumption of power and low heat generation. The multicore technology integrates all the cores to provide high performance capabilities. Some of the systems using this technology are available for software program development with each having its own set of standards, rules, semantics, and syntaxes. Some examples are SWARM (software application running on multicore), Open MP, TBB (thread building blocks) and multicore Java from Data Rush. Some of these are open source systems and some are commercial products.
The main advantages of the existing multicore technology systems are:

• the hiding of threading implementations;
• parallel processing techniques; and
• helping the new modifications in software development based on multicore applications.
But the existing multicore technology systems have various disadvantages too, as given below:
• The systems are not standardized. For example, TBB, SWARM and openMP use different techniques for creating parallel tasks.
• Developers have to learn each system in order to implement various techniques.
• Legacy applications require complex code changes for adapting to the multicore systems.
• Total cost of ownership is more.
• Requires external libraries, recompilations and rebuilding.
• Involves complex debugging.
• Time to market is more.
Moreover, an application designed for a single core may not take the full advantage of the multicore system. In the multicore system, the CPU clock speed is reduced at individual core level. So a single core oriented application may run with decreased performance in a multicore platform. Many application systems in today's enterprise world run in a sequential fashion. So the biggest challenge is how to transform these applications for enabling them for parallel processing by taking the best advantages of the multicore technology.

Therefore, there is felt a need for a method and system to create multicore objects which can run in parallel in the execution core of the multicore processor. The system can:
• provide a standardized technique for the creation of parallel tasks using multicore objects to be processed in parallel; Multicore objects are objects which can run in the execution core of the multicore processor. This also provides the mechanism for handling heterogeneous applications i.e. using different combinations of programming languages.
• improve the efficiency of data processing;
• reduce the program density for applications;
• provide easy learning for developers;
• reduce total cost of ownership;
• can be extended to multiple programming languages;
• provide easy maintainability and compatibility with existing threading libraries;
• has simple debugging techniques; and
• reduce time to market.
OBJECTS OF THE INVENTION
It is an object of the present invention to provide a method and system to create parallel tasks which can work across multiple cores using multicore objects.

It is another object of the present invention to provide a method and system to create parallel tasks by using multicore objects which improve the efficiency of data processing in a multicore environment.
It is yet another object of the present invention to provide a method and system to create parallel tasks using multicore objects which reduce the program density for applications.
It is still another object of the present invention to provide a method and system to create parallel tasks using multicore objects which provide easy learning for developers.
It is still another object of the present invention to provide a method and system to create parallel tasks using multicore objects which reduce total cost of ownership.
It is yet another object of the present invention to provide a method and system to parallel tasks using multicore objects which can be extended to multiple programming languages.
It is still another object of the present invention to provide a method and system to parallel tasks using multicore objects which provide easy maintainability and compatibility with existing threading libraries.
It is yet another object of the present invention to provide a method and system to parallel tasks using multicore objects which has simple debugging techniques.

One more object of the present invention is to provide a method and system to parallel tasks using multicore objects which reduce time to market.
Yet another object of the invention is to provides interfaces for handling heterogeneous (programming) applications.
Still another object of the invention it to involves a new mechanism to handle race conditions and deadlock prevention which is a major challenge with conventional thread programming and processing.
SUMMARY OF THE INVENTION:
For the purposes of this specification, 'multicore objects' are defined as elements which map onto a multicore execution processor in a corresponding fashion, in order to induce a parallel processing system and architecture, so as to process multicore objects on a multicore execution processor in an effective pre-defined manner.
According to this invention, there is provided a system for providing a muticore object framework for multicore processor architecture, said system comprising:
- reading means to read an input file;
- first determining means adapted to determine size of said read file;
- second determining means adapted to determine number of cores on said multicore processor;

- splitting means adapted to split said read file into multiple sub-files, thereby producing multicore objects in accordance with said determined file size and said determined number of cores;
- mapping means adapted to map each of said multiple multicore objects correspondingly over each of said cores;
- computation means for computing each of said mapped multicore objects individually and parallely to obtain individually processed data;
- local variable element defining means adapted to define local variable elements for use by the multicore objects to facilitate temporary storage for computation;
- transfer means adapted to transfer data from said local variable elements to said multicore objects after said computation; and
- joining means adapted to join said individually processed data to obtain cumulative processed data for said read input file.
Typically, said mapping means includes:
- division means adapted to divide said file into a series of offsets;
- range defining means adapted to define a range for each of said offsets;
and
- distribution means adapted to distribute each offset with said defined
range to each of said corresponding multicore objects.

Typically, said system includes a temporary storage means created in a stack in order to speed up said computation.
Typically, said system includes a state defining means adapted to define the state of said multicore object as set state or reset state.
According to this invention, there is provided a method for providing a muticore object framework for multicore processor architecture, said method comprises the steps of:
- reading an input file;
- determining size of said read file;
- determining number of cores on said multicore processor;
- splitting said read file into multiple sub-files, thereby producing multicore objects in accordance with said determined file size and said determined number of cores;
- mapping each of said multiple multicore objects correspondingly over each of said cores;
- computing each of said mapped multicore objects individually and parallely to obtain individually processed data;
- defining local variable elements for use by the multicore objects to facilitate temporary storage for computation;

- transferring data from said local variable elements to said multicore objects after said computation; and
- joining said individually processed data to obtain cumulative processed data for said read input file.
Typically, said step of mapping includes the steps of:
- dividing said file into a series of offsets;
- defining a range for each of said offsets; and
- distributing each offset with said defined range to each of said
corresponding multicore objects.
Typically, said method includes the step of defining the state of said multicore object as set state or reset state.
BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWINGS
The method and system to split data across multiple threads will now be described with reference to the accompanying drawings, in which: Figure 1 illustrates an overview of the system in accordance with the present invention;
Figure 2 illustrates the flow diagram of the steps executed by the system in accordance with the present invention for a search example using heterogeneous applications.

Figure 3 illustrates a graph showing the execution times required by the system in accordance with the present invention and two existing systems (SWARM and TBB) for the search example using heterogeneous programming applications 1
Figure 4 illustrates a graph showing the CPU usage of the system in accordance with the present invention and two existing systems (SWARM and TBB) for the search example;
Figure 5 illustrates a graph showing the CPU usage of the system in accordance with the present invention, two existing systems (SWARM and TBB) and a single threaded processing technique for the search example using heterogeneous programming applications;
Figure 6 illustrates the flow of standard deviation computation using Multicore objects;
Figure 7 illustrates a graph showing the comparison between serial and parallel execution of standard deviation computation, wherein, the parallel execution uses the multithread approach using multicore objects; and
Figure 8 illustrates a graph showing the comparison between two different architecture (4 processor SMP Vs 32 core Multicore) for standard deviation computation..
DETAILED DESCRIPTION OF THE ACCOMPANYING DRAWINGS

The drawings and the description thereof are merely illustrative of a method and system to create parallel tasks using multicore objects and only exemplify the system of the invention and in no way limit the scope thereof,
In accordance with the method and system of the present invention, an
application is executed by creating multiple multicore objects and by
splitting the data set among the objects. Considering the example of adding
16000 integers, a single threaded application reads the 16000 integers and
adds those sequentially to get the final sum. A multi threaded application
creates multiple threads and distributes a range of integers to each thread,
and each thread adds up the supplied data set to derive the partial sum.
Finally, one of the threads sums up the partial sum from each of the multiple
threads to get the final sum. In a multicore system, only one core will be
■ utilized by the single threaded application, while the multi threaded
application will utilize all the cores. Most importantly, with the multi
threaded application, the multiple threads will run in parallel with the given
data set. This improves the efficiency of data processing. However the
multithreaded programs are prone to issues like race conditions, deadlocks.
The basic purpose of the method and system in accordance with the present
invention is to create parallel tasks using multicore object framework and to
reduce issues like race conditions and deadlocks efficiently.. If there is
provided a multicore server with 16 cores, the 16000 integers can be broken
up into multiple tasks by using multicore objects in which each object can
handle 1000 integers (which each multicore object can add individually)
and those can be joined to get the total.

There are many ways to incorporate parallelism for a parallel design framework. The architecture of a processor greatly influences the parallel design framework. Most parallel processors used in the present enterprise world are designed to work on a single processor or SMP (symmetric multiprocessor) type of processor which encourages the system design to implement multitasking, multithreading or multiprocessing in a concurrency mode. Parallel processing systems are generally used for scientific and research oriented domains. The new multicore servers encourage parallelism and can be extended for a greater usability in almost every domain rather than few specific needs.
The method and system in accordance with the present invention do not confuse the developers too much with complex parallel processing techniques. The system in accordance with the present invention has inbuilt threading techniques and distributes tasks using multicore object to achieve task level parallelism. In a task level parallel processing system, the tasks run in parallel, independent of each other. In multicore systems, the cores share same physical memory, and also use different cache levels like L3 and L2. Each core has separate local stacks and local levels of cache. The thread scheduling at core level is taken care by the operating system. The system in accordance with the present invention provides a framework to create parallel tasks using multicore objects , which are then processed in parallel efficiently
Figure 1 illustrates an overview of the system in accordance with the present invention, indicated generally by the reference numeral 100. The splitter of the system 100 splits the global data set into data sets having smaller size

depending on the number of cores and creates multicore objects. To get the optimum performance, the number of multicore objectsis typically chosen as the number of cores available in the server. For example, a data set with 800 elements can be decomposed into a chunk of 100 elements each, assigned to each of the 8 cores for an 8 core server. Each of the multicore object reads the data set into the local memory of the core and processes them independent from each other in parallel. The join entity of the system 100 provides a mechanism to combine the output of all themulticore objects. The typical threading technology used by the system 100 is POSIX (portable operating system interface for unix).
To explain in depth how parallelism can be achieved using multicore, the example of a faster string search problem is illustrated in the following paragraphs. Ever since SAN (storage area network) has been accepted as a proven medium for efficient storage mechanism, many enterprises are using it for high volume of data storage, both for real time data and for historical data. Those data are retrieved and used for various analytic processes. The extraction part mostly involves pattern matching to obtain useful information. (For example: the queries: "Extract all orders between 10 am till 2 pm" or "Extract all the market orders"). Various methodologies can be followed for pattern matching for extraction. In one methodology, the widely used GREP (global / regular expression / print) / AWK (Aho, Weinberger and Kernighan) commands in unix / linux environment are used. Using another methodology, new programs are written using various regular expression libraries available in various programming languages. The various methodologies are followed to utilize these programs in the best way for the faster processing of huge files having size in the range of GB (giga

byte). If processing time for a huge file decreases, the extraction part for an ETL (extract, transform and load) engine can be sped up. This reduces the search time for a specific information from the file and speeds up the reconciliation procedures.
Typically, the trading applications write huge amount of raw data into log files. The information generally contains FIX (financial information exchange) messages. The FIX message structure is a series of tag and value pairs followed by semicolons (for example, 8=FIX.4.0; ll=;
35=;100=; ). Business users require the searching
of various information during business hours from real time log files and also, the archived files. For example: Considering the situation where i) a trade order did not get executed, ii) the client calls the trader at some point of time, and iii) the trader does not find the order in execution table in the database; to find out what had happened to the order, it requires the searching of the trade log files. Since the log files mostly have size in GB range, the search becomes a time consuming process. In addition, in some cases, reconciliation is to be carried out on the trade which involves processing of information form the log files. All these activities consume enormous amount of time. Analyzing these activities under multicore system provides the opportunity to explore the benefits of multicore capabilities to resolve such time consuming issues. Some of the benefits of using file search are given below:
1. The ease of online log file search from archive and real time for any FIX tag.
2. Faster log file processing for reconciliation activities.
3. Reduction in:

a) the user dependencies for real time search in critical databases; and
b) the database modifications for new tags (modifications to databases frequently results in their slow down).
4. Increased efficiency.
An experiment was conducted for the trading example illustrated above using a file with 8GB of data and contains FIX (Financial Exchange Protocol) Messages using a single processor application and a multicore application. A user was allowed to search the details of an order. The single processor application performed the following steps:
a) read the filename and the search pattern (for example, OrderlD);
b) checked for the existence of the file;
c) opened the file;
d) started reading a line;
e) conducted a pattern match function with the search pattern;
f) if the pattern matched with any string in the file, the line is printed as the output; and
g) continued till the end of the file.
Since the file was of the size in the GB range, the abovementioned searching steps became tedious for the application to conduct the search in the whole file. Independent of whether the search string is at the beginning line, at the middle line or at the end line, the whole file needs to be searched upon. Further, as the above mentioned steps are carried out sequentially, there was not much of any improvement even if the steps were executed in a multicore environment.

In the above case, it could be observed that the application could not take the advantage of the entire available core. In parallel mode, the file was split into a set of offsets and the portions following the offsets were distributed among the multiple cores using the splitter of the system 100. Figure 2 illustrates the various steps executed by system 100. The steps performed were as given below:
a) read the file name and the search pattern;
b) checked for the existence of the file;
c) determined the number of cores in the server;
d) determined the size of the file;
e) divided the file into a series of offsets;
f) create multicore objects;
g) distributed the starting offset and the range to each multicore object; h) each multicore object executed the search for the pattern in the portion
of the file allocated to it as if it is running in a single processor mode. i) the multicore object which found the pattern in its portion of the file
printed the result out; and j) for matter of simplicity, the search result was printed as they were
matched.
The Multicore object framework introduces a new type of variable element known as object variable. The main purpose of object variable is for data persistence, and also to avoid race conditions. Local variable elements are used by the multicore objects to facilitate temporary storage for computation. In addition to this the temporary storage is created in the stack which speeds up the computation. Once the computation is over, the local variable can transfer the data to the object variable. Multicore objects can

directly act on the object variable as well, since the object variable of one object is independent of the other object of same class. Object variable maintains a state within it i.e. set state and reset state. When the value of the object variable is set, the object variable transfers to ready state, and when the variable is reset it enters to initial state. In initial state the variable's state is 'false'. During this state, the get call on the value of the variable is returned as 0. The object variable can take the data types as long, int, double, float. The idea behind the state of the object variable is to provide a mechanism to avoid race conditions by checking if the variable is being ready to be retrieved when the multicore object enters into quasi active state. The object variable is useful between two multicore objects with one object variable writes and another reads it. Both objects cannot update an object variable at same time.
Figure 3 illustrates a graph showing the execution times required by the splitter of the system 100 and two existing systems (SWARM and TBB) for the search example. Figure 4 illustrates a graph showing the CPU usage of the splitter of the system 100 and two existing systems (SWARM and TBB) for the search example. Figure 5 illustrates a graph showing the CPU usage of the splitter of the system 100, two existing systems (SWARM and TBB) and a single threaded processing technique (GREP) for the search example. The unix grep command reports a steady nearly 14.8 seconds with CPU usage 99% even in the multicore environment. But, the parallel techniques in multicore mode, only took nearly 4 seconds with higher percentage of CPU utilizations.
The various advantages of the system 100 are given below:

1. The system 100 uses a standard technique for processing the data sets.
2. No learning curve for the thread application developers is involved for this system where as the existing systems require learning and understanding.
3. This system saves enormous amount of time.
4. This system reduces total cost of ownership as not much cost is involved in terms of maintenance, learning, licensing and the like.
5. Easy maintainability and compatibility with existing threading libraries. This system uses various parallel processing methodologies to build libraries which can be used in existing and new development areas without many problems.
6. For debugging, this system can use the existing standardized tools such as GDB (GNU debugger), DBX (debugger - unix) and the like.
7. Faster development and better control of program flow can be achieved through this system as the thread developers need not worry of learning a new software. So time to market is less.
Figure 5 illustrates a graph showing the CPU usage of the system in accordance with the present invention, two existing systems (SWARM and TBB) and a single threaded processing technique for the search example using heterogeneous applications;
According to another exemplary embodiment, the following steps are followed for Standard deviation computation using Multicore Objects:

In accordance with a Sequential Approach For the formula,
N

Compute mean of 1 to 10,000,000
b) Compute sum of squares of differences from mean
c) Divide by number N
d) Take the square root for computing standard deviation.
In accordance with a Parallel approach In a parallel approach, the same can be done using the following steps:
a) Create multicore objects
b) Distribute the numbers from 1 to 10,000,000 among objects.
c) Compute partial sums in each multicore objects
d) Compute mean using partial sums from each object.
e) Broadcast the mean to each object using quasi object state to update the mean through object variable.
f) Each object computes the partial sum of squares of difference from the


mean i.e.

Finally the main collects the partial squared sum and computes standard deviation

Figure 6 illustrates the flow of standard deviation computation using Multicore objects;
Figure 7 illustrates a graph showing the comparison between serial and parallel execution of standard deviation computation. The parallel execution uses the multithread approach using multicore objects; and
Figure 8 illustrates a graph showing the comparison between two different architecture (4 processor SMP Vs 32 core Multicore) for standard deviation computation. This shows as the number of processors/cores increases the performance also increases.
TECHNICAL ADVANCEMENTS
The technical advancements of the present invention include realization of a method and system to split data across multiple threads using multicore objects which:
• provide a standardized technique for the creation of parallel tasks to be processed in multiple cores in a multicore server;
• improve the efficiency of data processing;
• reduce the program density for applications;
• provide easy learning for developers;
• reduce total cost of ownership;
• can be extended to multiple programming languages;
• provide easy maintainability and compatibility with existing threading libraries;

• has simple debugging techniques; and
• reduce time to market.
While considerable emphasis has been placed herein on the particular features of this invention, it will be appreciated that various modifications can be made, and that many changes can be made in the preferred embodiments without departing from the principles of the invention. These and other modifications in the nature of the invention or the preferred embodiments will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the invention and not as a limitation.

We Claim:
1. A system for providing a muticore object framework for multicore processor architecture, said system comprising:
- reading means to read an input file;
- first determining means adapted to determine size of said read file;
- second determining means adapted to determine number of cores on said multicore processor;
- splitting means adapted to split said read file into multiple sub-files, thereby producing multicore objects in accordance with said determined file size and said determined number of cores;
- mapping means adapted to map each of said multiple multicore objects correspondingly over each of said cores;
- computation means for computing each of said mapped multicore objects individually and parallely to obtain individually processed
data;
- local variable element defining means adapted to define local variable elements for use by the multicore objects to facilitate temporary storage for computation;
- transfer means adapted to transfer data from said local variable elements to said multicore objects after said computation; and
- joining means adapted to join said individually processed data to obtain cumulative processed data for said read input file.

2. A system as claimed in claim 1 wherein, said mapping means includes:
- division means adapted to divide said file into a series of offsets;
- range defining means adapted to define a range for each of said offsets;
and
- distribution means adapted to distribute each offset with said defined
range to each of said corresponding multicore objects.
3. A system as claimed in claim 1 wherein, said system includes a temporary storage means created in a stack in order to speed up said computation.
4. A system as claimed in claim 1 wherein, said system includes a state defining means adapted to define the state of said multicore object as set state or reset state.
5. A method for providing a muticore object framework for multicore processor architecture, said method comprising the steps of:

- reading an input file;
- determining size of said read file;
- determining number of cores on said multicore processor;

- splitting said read file into multiple sub-files, thereby producing multicore objects in accordance with said determined file size and said determined number of cores;
- mapping each of said multiple multicore objects correspondingly over each of said cores;
- computing each of said mapped multicore objects individually and parallely to obtain individually processed data;
- defining local variable elements for use by the multicore objects to facilitate temporary storage for computation;
- transferring data from said local variable elements to said multicore objects after said computation; and
- joining said individually processed data to obtain cumulative processed data for said read input file.
6. A method as claimed in claim 5 wherein, said step of mapping includes the steps of:
- dividing said file into a series of offsets;
- defining a range for each of said offsets; and
- distributing each offset with said defined range to each of said
corresponding multicore objects.

7. A method as claimed in claim 5 wherein, said method includes the step of defining the state of said multicore object as set state or reset state.