WO2006082424A1

WO2006082424A1 - Data processing

Info

Publication number: WO2006082424A1
Application number: PCT/GB2006/000383
Authority: WO
Inventors: Jason Doig
Original assignee: Sony Computer Entertainment Limited
Priority date: 2005-02-04
Filing date: 2006-02-03
Publication date: 2006-08-10
Also published as: GB0502281D0; GB2422924A

Abstract

A data processing system has a plurality of data items; the data items being arranged as a tree structure so that a data item lower in the tree structure is related by a path through the tree structure to one or more data items at respective higher levels in the tree structure; and each data item having an associated numerical item identifier and a tree identifier representing the position of that data item in the tree structure. The tree identifier for a data item is dependent upon a mathematical combination of the item identifiers for data items in the path relating to that data item; and the item identifiers and the mathematical combination are arranged so as to allow a test dependent only on the tree identifier of a data item under test and the item identifier of a data item higher in the tree structure to determine whether the data item under test lies on a path relating to that data item higher in the tree structure.

Description

DATA PROCESSING

This invention relates to data processing.

In object-oriented (00) programming, so-called objects are created with a given "type". The types available are defined (usually) as a tree, or hierarchy. There is typically one base type from which (one or more) more specialised types are derived/inherited, and yet more types are derived in turn from those. An object of a heavily derived type inherits all the properties of each parent type in turn, and can in some circumstances be treated as if it is any type from which is derives. It is therefore common in OO programming for the programmer to be expected to handle an object knowing only that it derives in some way from a base type. If the programmer wants to use this object as a more derived type, it must first be tested to check if the object is of (or is derived from) the type containing the specific functionality required.

A traditional solution is for each object to store locally it's own type, and for each type to know which type it is derived from. So when an object is tested, there is an iterative process of comparing the object's type with the type being searched for, and if there is no match, moving on to the immediate parent type. This process only ends if a match is found, or there are no more parent types. This means that the worst case is found when testing for a rare type, and where many objects exist of heavily-derived types, because the entire list of parents is checked for each of many objects in order to reject them. Accordingly this is a variable length process with many potential performance penalties in a real-world situation.

This invention provides a data processing system having a plurality of data items; the data items being arranged as a tree structure so that a data item lower in the tree structure is related by a path through the tree structure to one or more data items at respective higher levels in the tree structure; and each data item having an associated numerical item identifier and a tree identifier representing the position of that data item in the tree structure; in which: the tree identifier for a data item is dependent upon a mathematical combination of the item identifiers for data items in the path relating to that data item; and the item identifiers and the mathematical combination are arranged so as to allow a test dependent only on the tree identifier of a data item under test and the item identifier of a data item higher in the tree structure to determine whether the data item under test lies on a path relating to that data item higher in the tree structure. Various further respective aspects and features of the invention are defined in the appended claims.

Embodiments of the invention can provide a method of testing an object for inheritance, with only a single "cheap" (having a low processing overhead) and fixed- overhead check. Preferably, the technique assigns a unique prime number to each individual class. Then there is assigned to each class (e.g. in depth order) a number which is the product of it's own prime number and the prime numbers associated with each of the classes from which it is derived. The product of the base or root class can be initialised to 1 (although any prime would do), as all classes must derive from this and an explicit test is not required.

The test for an object against a given type is then to check if the object's product is exactly divisible by the type's prime. If it is, it must be a derived class, otherwise it can't be.

Embodiments of the invention will now be described with reference to the accompanying drawings in which:

Figure 1 schematically illustrates the internal structure of a data processing system;

Figure 2 schematically illustrates a data processing system;

Figure 3 is a schematic flow chart illustrating operations involved in preparing and executing computer program code;

Figure 4 schematically illustrates a tree structure of object types;

Figure 5 is a schematic flow chart illustrating part of a runtime initialisation process; and

Figure 6 schematically illustrates a detection process.

Referring now to Figure 1, a data processing system comprises a bus 10 to which are connected a processor (CPU) 20, read only memory (ROM) 30, random access memory (RAM) 40, input / output (I/O) logic 50 (e.g. including a network interface to a network or internet connection 70) and a graphics processor (GP) 60. Of course, other functionality (such as disk storage) may be provided.

Figure 2 schematically illustrates the external appearance of such a system, generally having a system unit 100 housing much or all of the functionality shown in Figure 1, a display 110 and at least one user interface device 120 such as a keyboard, mouse or (as in the present case) a games controller.

In terms of a process for producing and executing OO program code, the data processing system may take part in various different stages of that process. The overall process is shown schematically in Figure 3. Referring to Figure 3, at a step 200 a user prepares so-called source code. This may be entered via a keyboard or a visual interface, and defines operations to be executed in a form that is readable by the user. But in order for the program to be executed (e.g. by the CPU 20 of Figure 1) the code has to be compiled at a step 210. This well-established process involves converting the human-readable program into machine-operable program code, and at the same time linking together different functional units within the program to operate in a consistent manner.

The compilation process generates so-called object code, which can then be stored (e.g. in ROM or on a removable disk medium - not shown) or transmitted (e.g. via an internet connection) for subsequent execution by the same or another processor.

At run time, in a simplified view a first step is a run time preparation step 220, during which (amongst other things) a process described below with reference to Figure 5 is executed. Then execution of the remainder of the object code takes place (a step 230). During that execution, a process described below with reference to Figure 6 may take place if and when required.

Figure 4 schematically illustrates a tree structure of object types. As mentioned above, each object has an associated "type", which in this embodiment are defined as a tree or hierarchy. There is one base type 300 from which more specialised types are derived/inherited, and yet more types are derived in turn from those. An object of a heavily derived type inherits all the properties of each parent type in turn, and can in some circumstances be treated as if it is any type from which it derives. It is therefore common in OO programming for the programmer to be expected to handle an object knowing only that it derives in some way from a base type. If the programmer wants to use this object as a more derived type, it must first be tested to check if the object is of (or is derived from) the type containing the specific functionality required.

So, in Figure 4, two types 310, 320 are derived from the base type 300. A type 330 is derived from types 346, 336, 324, 310 and 300, and inherits all the properties of those intervening types.

The deepest tree structure has typically about eight levels. So₅ the previously proposed technique described in the introduction for checking whether one type is derived from another can involve many separate and detailed checks, which is expensive in terms of processor requirements.

The techniques described here allow the test to be made much more quickly and cheaply (in terms of processor resources) by assigning numerical values to each type in such a way as to allow a test dependent only on an identifier of a type under test and a value associated with a type higher in the tree structure to determine whether the type under test is derived from the type higher in the tree structure.

In one embodiment, prime numbers are assigned to each type in the tree. Each type is also assigned the product of all of the prime numbers associated with types from which it is derived. These steps may be taken (as steps 400, 410 respectively) during a runtime preparation stage of executing the program. This can be (for example) implemented as part of the compiled software itself, as an automated function to take place at run time, or as a callable library routine which is accessed by the compiled software. So, in relation to the example shown in Figure 4, a set of numbers might be:

In order to test whether (for example) the type 348 is derived from the type 310, it is simply necessary to check whether the product associated with the type 348 (i.e. 650762) has the prime number associated with the type 310 (i.e. 2) as a factor. It does. This test is schematically illustrated in the flow chart of Figure 6. At a step 420, the prime number associated with the (potential parent) type is detected. At a step 430, the product value associated with the (potentially derived) type is detected. Then, at a step 440, a simple test is carried out to detect whether the prime number is a factor of the product.

In another embodiment, an additive combination can be used. Each type is assigned a number and a sum of the numbers relating to types from which it derives. Preferably, each of the numbers is selected from a group such that it is greater than a sum of all smaller numbers in that group. There follows an example, using binary arithmetic:

In this example, a simple software test can be carried out to detect whether a particular bit position (corresponding to the identifier associated with a potential parent type) is occupied in the sum. This test may be included as part of the compiled software itself, or as a callable library routine which can be used by the compiled software. It will be clear that although the present technique has been described with reference to object types in OO programming, it could be applied to other data handling techniques in which it is desired to be able to carry out a quick and elegantly simple test to detect whether one node lies on a path through the tree structure passing through another node.

The embodiments of the invention described above may be implemented, at least in part, using software-controlled data processing apparatus. It will be appreciated that a computer program providing such software control and a storage medium (e.g. an optical disk) or a transmission medium (e.g. the internet or network connection described above) by which such a computer program is provided are envisaged as aspects of the present invention.

There follows an example section of source code which, when compiled^' and executed, operates to establish a hierarchy of classes, each class having an associated prime number and a product value. This simplified example shows the derivation of one of each of a "base" class, a "derived" class and an "other" class, and ends with an example of a test which can be applied to determine the nature of the various classes. Comments are indicated by the "//" delimiter in some of the lines.

int primes[]={2,3 ,5,7,11,13,17,19,23,29}; // Define some primes (could start at 1) class Element // The Element class does most of the work

{ protected:

Element(const Element &p); // Protected constructor to stop accidental duplication

. .. public:

Element(Element *parent) { // The real constructor requires a parent element (0 for the base element) mjparent=parent; m_nextElement=m_firstElement; // Add this element to the global list of elements m_fϊrstElement=this; m_prime=primes[m_curID-H-]; // Assign the next available prime

} void process() // This function sets up the products for all the types

{ if(! mjparent) {m_product=m_prime;} // Trivial case for the base type else if(!m_parent->m_product) m_parent->process(); // First we need to make sure any parent types are initialised if(!m_product && rαjparent) m_product=mjparent->m_product*mjprime; // If we haven't done so already, multiply the parent's product with our own -¹ prime if(m_nextElement) m_nextElement->process(); // Process any other elements we haven't got around to yet

} static processFirstQ {m_firstElement->process();} // Kick off the processing at the first element bool isTypeOf(Element *type) {return O==(m_product%type->m_prime);} // Trivial function to check ancestry - note we do not iterate or recurse to the parent protected:

Element * mjparent; // Pointer to the element for the parent class static Element *m_firstElement; // The first element in the list

Element *m_nextElement; // The next element in the list static int m_curID; // A counter for looking up the next available prime int m_prime; // Our own prime int m_product; . // The product of primes up to the base class

\ .

'' class Base // A simple base class

{ public:

static Element m_element; // AU classes must have an Element associated with them virtual Element *getType() { return &m_element;} // Any derived classes will override this function to return their own element bool isTypeOf(Element *el) {return getType()->isTypeOf(el);} // This is a shortcut to the type-checking function

}; class Derived : public Base // Define a simple derived class

{ public: static Element m_element; // The element for this class virtual Element *getType() { return &m_element;} // And the overridden type function

}; class Other: public Base // Define another derived class

{ public: static Element m_element; // Another unique element virtual Element *getType() { return &m_element;} // Once again override the type function

};

#defme TYPE(a) &a::m_element // This is just to make the code neater...

// Instantiate the static members declared above. int Element: :m_curID;

Element *Elemeπt: :m_fϊrstElement;

Element Base::m_element(O);

Element Derived::m_element(TYPE(Base));

Element Other: :m_element(TYPE(Base)); void main(int argc,char **argv)

{

Element: :processFirst(); // This has to be called at application start-up (after all the elements have been created)

Base a; // Make one object of each class Derived b; Other c; bool t=c.isTypeOf(TYPE(Other)); // This should return true, as object c really is an "Other" object bool f=c.isTypeOf(TYPE(Derived)); // This should return false, as object c is not derived from "Derived"

Claims

1. A data processing system having a plurality of data items; the data items being arranged as a tree structure so that a data item lower in the tree structure is related by a path through the tree structure to one or more data items at respective higher levels in the tree structure; and each data item having an associated numerical item identifier and a tree identifier representing the position of that data item in the tree structure; in which: the tree identifier for a data item is dependent upon a mathematical combination of the item identifiers for data items in the path relating to that data item; and the item identifiers and the mathematical combination are arranged so as to allow a test dependent only on the tree identifier of a data item under test and the item identifier of a data item higher in the tree structure to determine whether the data item under test lies on a path relating to that data item higher in the tree structure.

2. A system according to claim 1, in which: the system is an object-oriented data processing system; and the data items are object types which are derived from one or more data items at respective higher levels in the tree structure.

3. A system according to claim 1 or claim 2, in which the item identifiers are dependent upon respective different prime numbers.

4. A system according to claim 3, in which the tree identifier for a data item is dependent upon a product of the item identifier for that data item and item identifiers for data items higher in the tree to which that data item is related by the path.

5. A system according to claim 1 or claim 2, in which: the item identifiers are dependent upon numerical values selected from a group of possible values arranged such that each numerical value in the group is larger in turn than a sum of all preceding smaller numerical values in the group; and the tree identifier for a data item is dependent upon an additive combination of the item identifier for that data item and item identifiers for data items higher in the tree to which that data item is related by the path.

6. A system according to any one of the preceding claims, comprising means for applying the test to the tree identifier of a data item under test and the item identifier of a data item higher in the tree structure to determine whether the data item under test lies on a path relating to that data item higher in the tree structure.

7. A data processing method for handling a plurality of data items; the data items being arranged as a tree structure so that a data item lower in the tree structure is related by a path through the tree structure to one or more data items at respective higher levels in the tree structure; and each data item having an associated numerical item identifier and a tree identifier representing the position of that data item in the tree structure; the method comprising the steps of: setting the tree identifier for a data item to be dependent upon a mathematical combination of the item identifiers for data items in the path relating to that data item; the item identifiers and the mathematical combination being arranged so as to allow a test dependent only on the tree identifier of a data item under test and the item identifier of a data item higher in the tree structure to determine whether the data item under test lies on a path relating to that data item higher in the tree structure.

8. Computer software having program code for carrying out a method according to claim 7.

9. A medium by which software according to claim 8 is provided.

10. A medium according to claim 9, the medium being a storage medium.

11. A medium according to claim 9, the medium being a transmission medium.