APPARATUS

FIELD OF THE INVENTION

The present invention relates to the field of data processing. More particularly, it relates to the allocation of data processing tasks to the multiple threads executing in a data processing apparatus.

BACKGROUND OF THE INVENTION

It is known for a contemporary data processing apparatus such as a graphics processing unit (GPU) to be programmed in a single program multiple data (SPMD) fashion in which the programmer provides a single program (or kernel) and a set of multiple data items on which that single program should operate. The data processing apparatus then creates and executes a thread for each data item within that data set. For example, in the context of image processing on a GPU, a thread can be created and executed for each pixel in a frame, with many threads being executed simultaneously in order to perform the same data processing operation on each pixel within the frame.

It is further known that a data processing apparatus such a GPU may benefit, in terms of data processing efficiency, if the order in which data values are processed is adapted to benefit the configuration of the data processing apparatus. For example, advantages related to cache locality can result if the data values are processed in an order which is modified in dependence on the requirements of the image processing to be performed. For example, it is known that where an image processing operation requires a comparison of data values related to one image pixel to be compared to its immediate neighbours, a block-wise approach to processing the pixels in the image is likely to result in improved cache performance with respect to an approach in which the pixels are handled in a row-by-row raster order configuration. Programming models such as CUDA and OpenCL allow such a deviation from raster-scan processing of pixel data by grouping threads together, e.g. in blocks, in order to more efficiently make use of architectural features such as local memory and barriers.

In order to adapt the order in which the pixels in an image frame are processed, it is known for the kernel running in each thread to adapt its address calculation from a simple linear increment to a calculation which allows, for example, the above mentioned block-wise treatment of the pixels to result.

In a massively-parallel data processing apparatus such a GPU, it is however advantageous to reduce the processing that must be performed by each kernel running within each thread as much as possible in order to allow the data processing apparatus as a whole to more effectively process large volumes of input data.

Accordingly, it would be advantageous to enable a data processing apparatus to improve its data processing performance by adapting the order in which a set of data items are processed, without increasing the processing burden on each kernel running within each thread of that parallel data processing device.

SUMMARY OF THE INVENTION

Viewed from a first aspect, the present techniques provide a data processing apparatus configured to perform data processing in a single program multiple data fashion, the data processing apparatus comprising: execution circuitry configured to execute multiple threads to perform the data processing on input data by reference to at least one coordinate value of points in a reference domain; and thread allocation circuitry configured to specify a selected point in the reference domain for each thread of the multiple threads respectively in order to allocate the data processing by specifying for each thread the at least one coordinate value of the specified point for that thread, wherein each thread accesses the input data with reference to its selected point in the reference domain, and wherein an order in which points in the reference domain are allocated to threads for data processing is configurable in the thread allocation circuitry. The data processing apparatus is a single program multiple data device, meaning that the programmer provides only a single program (i.e. sequence of instructions) and indicates the input data on which that single program should operate. The device is then configured to execute that single program in a parallel fashion across multiple data items simultaneously in the set of input data. To do this, the data processing apparatus is provided with execution circuitry which is configured to execute multiple threads. Each thread of those multiple threads then seeks to perform essentially the same data processing operations (subject to conditional branches which that particular thread may take) on an input data value which has been allocated to it. According to the present techniques the execution circuitry determines the input data value on which it should perform its processing with respect to a reference domain. The reference domain sets out a range of points and each point thus represents an individual "processing point" which a thread can use as its reference when determining which input data to process. Each point in the reference domain can be identified by at least one coordinate value, for example, where the reference domain is n-dimensional, a given point within that domain can be referenced by n coordinate values.

The data processing apparatus is provided with thread allocation circuitry which determines the input data for each thread to be executed in the execution circuitry (note that this could be a single data input data value per thread or it could be plural data input values per thread) and this is done by means of the at least one coordinate value by which the points in the reference domain are identified. The thread allocation circuitry does not however simply allocate input data to threads in a sequential fashion in which a point with the next sequential coordinate value is allocated to the next available thread, but rather the order in which those points are allocated to threads for data processing is configurable in the thread allocation circuitry. The configurability of this order thus enables the thread allocation circuitry to adapt the ordering in dependence on the particular requirements of the data processing apparatus and/or the particular kernel being executed. Prior art approaches (such as those of CUDA and OpenCL) of merely grouping threads together have been found to leave room for improvement with respect to system/kernel performance. In particular, enabling the ordering to be configurable in the manner of the present techniques has been found to enable a particularly flexible approach to making improvements both in terms of the efficient usage of various architectural components of the data processing apparatus and in terms of optimizing the performance of a particular kernel.

The execution circuitry could comprise just a single execution unit (for example just a single processor core) but in one embodiment the data processing apparatus comprises a plurality of execution units. This further increases the parallelism which can be achieved by the apparatus, in that the multiple threads are executed across multiple execution units.

The thread allocation circuitry could be provided in a number of different ways in the data processing apparatus. For example, in one embodiment the data processing apparatus further comprises job manager circuitry configured to allocate the data processing between the plurality of execution units, and the thread allocation circuitry is provided by the job manager circuitry. In such a "multi-core" system, having a plurality of execution units, the job manager circuitry is provided to subdivide the data processing operations which must be carried out by the data processing as a whole between the execution units of the data processing apparatus, for example on the basis of availability and capacity. The allocation of points in the reference domain to threads can therefore in such an embodiment be effected by the job allocation performed by the job manager circuitry and it can therefore be at this level of the job allocation that the configuration of the order in which the points in the reference domain are allocated to threads is effected. For example, the job manager circuitry can group the points together such that the input data values on which a given execution unit will perform its data processing will exhibit a locality, which may for example improve the usage of a cache within that execution unit.

Alternatively or in addition, the thread allocation circuitry can be provided by thread dispatch circuitry associated with the execution circuitry. Each execution unit can thus have its own thread dispatch unit which allocates the data processing tasks to be performed by that execution unit to the multiple threads which execute within that execution unit. It can therefore be at this level of the thread dispatching that the configuration of the order in which the points in the reference domain are allocated to threads is effected. In some embodiments the order in which points in the reference domain are allocated to threads is configurable at more than one level of granularity. For example, this means that the ordering of points may be varied on the one hand at a fine level of granularity - say switching the ordering of individual adjacent points - and can simultaneously be varied at a coarser level of granularity - say switching the ordering of groups of points. Simultaneous ordering variation at more than two levels of granularity is further envisaged.

The order in which points in the reference domain are allocated may be varied in a number of ways. In one embodiment the thread allocation circuitry is configured to sub-divide the reference domain into a plurality of sub-domains and the thread allocation circuitry is configured to allocate all points within a first sub-domain to threads for data processing before allocating points within a second sub-domain to threads for data processing, such that the order in which points are allocated to threads is not a raster scan order through the reference domain. This sub-division of the reference domain into a plurality of sub-domains thus provides one approach by which the order in which points are allocated to threads for data processing is not a raster scan (i.e. sequential) order through the reference domain. For example with respect to a two dimensional reference domain the thread allocation circuitry may subdivide that two dimensional domain into a number of smaller blocks, and by allocating points to threads for data processing based on a chosen block ordering, the processing order of the points can be varied from raster scan order.

In one such embodiment, the thread allocation circuitry is configured to subdivide the reference domain into a hierarchy of sub-domains, wherein the hierarchy comprises at least two levels and wherein the thread allocation circuitry is configured to allocate points to threads in an iterative, nested fashion with respect to the hierarchy. The order in which the thread allocation circuitry approaches the nested nature of the levels of the hierarchy can be chosen in dependence on the particular system and/or kernel requirements. For example, it may be advantageous to proceed in a depth first approach with respect to the hierarchy, such that points at the lowest level of the hierarchy are sequentially processed (e.g. in a raster scan ordering), meaning that overall the points are processed in an order which retains some degree of the original locality of the (sequential) set of points. Alternatively, the thread allocation circuitry may approach the hierarchy of sub-domains in a breadth first manner, meaning that after a given point at a lowest level of the hierarchy has been processed, the data processing then "jumps" to a new point generated by iterating a sub-domain at a higher level of the hierarchy. This may, for example, be advantageous if it is desirable to process the points in a manner that introduces a degree of non-locality (and the degree of this non-locality can then be configured by the choice of sub-domain size). For example, where the data processing apparatus seeks to hide memory access latency by making use of a pending memory transaction queue, the overall performance of the data processing system may be improved if that queue is kept relatively full, and this breadth first approach to hierarchy of sub-spaces is one way of achieving this.

When the thread allocation circuitry is configured to sub-divide the space into a hierarchy of sub-spaces, it may be provided that the system user (i.e. the programmer) can at least partially determine how that hierarchy is treated by the thread allocation circuitry. Accordingly, in one embodiment the data processing apparatus is configured such that a program instruction executed by the data processing apparatus can specify at least one level of the hierarchy at which the order in which points are allocated to threads is to be determined by the thread allocation circuitry. The user can therefore configure the processing order of the points by for example specifying a chosen level of the hierarchy at which the thread allocation circuitry should determine the order in which points are to be allocated to threads, whilst explicitly specifying the ordering with respect to another level of the hierarchy. In some situations the user may desire more direct control over the configurable ordering and hence in one embodiment the data processing apparatus is configured such that a program instruction executed by the data processing apparatus can specify at least partially the order in which points are allocated to threads.

This more direct control over the order may apply universally, or in accordance with one embodiment the data processing apparatus can be configured such that a program instruction executed by the data processing apparatus can specify at least partially the order in which points are allocated to threads for at least one level of the hierarchy. It may for example be the case that the definition of one level of the hierarchy is particularly significant for system performance, and the user may therefore wish to take full control over this level, but conversely may allow the order at other levels to be freely determined by the apparatus. For example, at a given level of the hierarchy the user may choose to specify that either a breadth first approach or a depth first approach should be taken to the allocation order of the points within that level of the hierarchy.

When the reference domain is sub-divided into a hierarchy of sub-spaces, it may be provided that the system user (i.e. the programmer) can specify the order in which the levels are treated by the thread allocation circuitry. Accordingly in some embodiments the data processing apparatus is configured such that a program instruction executed by the data processing apparatus can specify an order in which the at least two levels of the hierarchy are to be used to allocate points to threads. For example, where the reference domain is subdivided into outer and inner sub-domains, the user can specify whether the allocation should iterate over the outer or the inner sub-domain first.

There is a range of architectural features of the data processing apparatus which could be taken into consideration when the order in which points are allocated to threads for data processing is configured. In some embodiments the at least one execution circuitry is warp-based execution circuitry and the order in which points are allocated to threads for data processing is configured in dependence on a number of threads in a warp used by the warp-based execution circuitry. The coordinated execution of threads in warp based execution circuitry may benefit from an order of points allocation which is configured to match, for example because of the closely related (in terms of memory addresses) load and store operations which may then result, and the more efficient coordinated memory access which can then be performed.

In some embodiments the data processing apparatus further comprises at least one cache storage configured to store temporary copies of data retrieved from memory, wherein the order in which points are allocated to threads is configured in dependence on a size of the cache. More efficient use of the cache can for example result if the points are allocated to threads such that the resulting data processing seeks to populate the cache with related data items that occupy one cache line and not with too many unrelated data items which would then result in thrashing in the cache. In some embodiments comprising at least one cache storage configured to store temporary copies of data retrieved from memory, the order in which points are allocated to threads is configured in dependence on a re-use distance of the cache. In other words the frequency with which selected data items in the cache are (re)accessed by the particular kernel being executed may be chosen as a metric for determining the ordering in which the points are allocated. In some embodiments the data processing apparatus comprises an outstanding transaction queue configured to hold indications of pending memory transactions resulting from the data processing, wherein the order in which points are allocated to threads is configured in dependence on a size of the outstanding transaction queue. For example, the data processing apparatus may operate most efficiently if the outstanding transaction queue is kept relatively full, since this can hide the latency associated with each individual memory transaction. The order in which points are allocated to threads can facilitate keeping the queue full by virtue of the corresponding memory addresses which must be accessed for each point. An empirical approach to configuring the order in which points are allocated may be taken and in one embodiment the data processing apparatus further comprises optimisation circuitry configured to configure the order in which coordinate values are allocated to threads for data processing on the basis of previous data processing performance. This may be done to optimise various performance parameters, such as data processing time and/or data processing energy consumption. A predictive approach to configuring the order in which points are allocated may also be taken and in one embodiment the data processing apparatus further comprises optimisation circuitry configured to configure the order in which points are allocated to threads on the basis of at least one architectural parameter of the data processing apparatus. As such, by knowing how the data processing apparatus is set up, steps may already be taken to improve system performance. For example, this could be to vary the ordering in dependence on one of the architectural parameters mentioned above, where this architectural parameter is known to the optimisation circuitry. The manner in which the order of allocation of the points is configured in the thread allocation circuitry could take a number of forms. For example, in one embodiment the thread allocation circuitry is configured to determine the order in which points are allocated to threads as a function of a thread number of each of the threads. This function may for example be determined by a program instruction executed by the data processing apparatus. In other words the user could directly specify this function which converts thread numbers into points in the reference domain. The function could for example permute at least a portion of the thread number of each of the threads. It may be the case that it is not required (or even desired) that all points in the reference domain are allocated to threads for processing and in some embodiments the data processing apparatus is configured such that a program instruction executed by the data processing apparatus can specify a subset of the points in the reference domain which are to be allocated to threads for processing by the thread allocation circuitry. Viewed from a second aspect the present techniques provide a data processing apparatus configured to perform data processing in a single program multiple data fashion, the data processing apparatus comprising:

means for executing multiple threads to perform the data processing on input data by reference to at least one coordinate value of points in a reference domain; and means for specifying a selected point in the reference domain for each thread of the multiple threads respectively in order to allocate the data processing by specifying for each thread the at least one coordinate value of the specified point for that thread, wherein each thread accesses the input data with reference to its selected point in the reference domain, and

wherein an order in which points in the reference domain are allocated to threads for data processing is configurable in the means for specifying.

Viewed from a third aspect the present techniques provide a method of data processing in a single program multiple data fashion, the method of data processing comprising the steps of:

executing multiple threads to perform the data processing on input data by reference to at least one coordinate value of points in a reference domain; and

specifying a selected point in the reference domain for each thread of the multiple threads respectively in order to allocate the data processing by specifying for each thread the at least one coordinate value of the specified point for that thread, wherein each thread accesses the input data with reference to its selected point in the reference domain, and

wherein an order in which points in the reference domain are allocated to threads for data processing is configurable in the specifying step.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention will be described further, by way of example only, with reference to embodiments thereof as illustrated in the accompanying drawings, in which:

Figure 1 schematically illustrates a multi-core GPU to which a CPU delegates data processing tasks in one embodiment; Figure 2 schematically illustrates the allocation of data processing tasks to threads in a warp-based execution unit in one embodiment, together with a performance optimiser configured to vary the allocation of data processing tasks to those threads;

Figure 3 schematically illustrates a reference domain corresponding to the dimensions of a frame of image data;

Figure 4A schematically illustrates the sub-division of a reference domain into a hierarchy of sub-domains;

Figure 4B schematically illustrates the sub-division of a reference domain into a hierarchy of sub-domains and different choices of ordering with respect to those sub- domains;

Figures 5A-5C show example program instructions which may be used to configure the operation of the data processing apparatus in one embodiment;

Figure 6A-6C illustrate some functions which may be provided to convert thread numbers into point co-ordinates in a reference domain;

Figure 7 schematically illustrates one configuration of the order in which points in a reference domain may be allocated to different warps in a warp-based execution unit in one embodiment;

Figure 8 schematically illustrates a series of steps which may be taken in a method of one embodiment;

Figure 9 schematically illustrates a series of steps which are taken in one embodiment to monitor and adapt data processing performance; and

Figure 10 schematically illustrates a series of steps which are taken in one embodiment when determining a preferred order in which points are allocated to threads for data processing with reference to test configurations.

DESCRIPTION OF EMBODIMENTS

Figure 1 schematically illustrates a data processing apparatus 10 in one embodiment. This data processing apparatus 10 comprises a graphics processing unit (GPU) 12, a central processing unit (CPU) 14 and a memory 16 coupled together via a system bus 18. Overall control of the data processing apparatus 10 is maintained by the CPU 14 which executes a sequence of program instructions (for example retrieved from the memory 16) defining its data processing operations. The GPU 12 is provided as a dedicated hardware device to which the CPU 14 can delegate various data processing tasks. In particular, the GPU 12 is configured to be particularly well suited to highly parallelised data processing operations, for example as may be commonly be required in association with graphics processing. Moreover, the GPU 12 is configured to be programmed using a single program multiple data (SPMD) programming model in which the programmer provides a single program (or kernel) and identifies the target data with respect to which that program should be executed. Furthermore, as will be explained in more detail with reference to the subsequent figures, the programmer identifies how the input data should be processed by specifying a reference domain. In the context of the GPU 12 in Figure 1, this reference domain may for example be a two-dimensional reference domain corresponding in size to the dimensions of an image frame to be processed by the GPU. The GPU 12 comprises two cores 20 and 22 each of which is configured to execute multiple threads in parallel. To administer the allocation of data processing tasks to the threads within each core, each core is provided with a thread dispatcher 24, 26 respectively. The higher level sub-division of data processing tasks between the two cores is administered by the job manager 28. As will be discussed in more detail with reference to the following figures, the GPU 12 is arranged such that the order that the points in the reference domain specified by the programmer are allocated to individual threads being executed on cores 20 and 22 can be varied. This variation may come about as a result of the GPU acting independently or may (alternatively or in addition) come about as a result of explicit programmer choice.

Within each core 20, 22, this variation of the order in which points in the reference domain are allocated to threads can be effected by the respective thread dispatchers 24, 26. However, it should be appreciated that the job manager 28 can also play a role in the configuration of this ordering, by virtue of the job allocation which it performs. For example, where the points in the reference domain are gathered together into a number of groups, the job manager 28 can affect the order in which those groups of points are processed by allocating groups of points as jobs to the cores. Each processor core 20, 22 has an associated level 1 (LI) cache 30, 32, and each cache has a pending transaction queue 34, 36. The cores share a level 2 (L2) cache 38, which itself has its own pending transaction queue 40. As will be familiar to those of ordinary skill in the art, the LI caches 30, 32 and L2 cache 38 are provided such that each processor core 20, 22 does not experience the full memory latency associated with retrieving data values from the memory 16 via the system bus 18 every time a given data value is accessed. One of ordinary skill in the art will be similarly familiar with the provision of the pending transaction queues 34, 36, 40 in each of the illustrated caches, in which an entry is made for each transaction which has been requested from that cache level but has not yet completed. As will be discussed in more detail with reference to the following figures, the size of the caches 30, 32, 38 and their respective pending transaction queues 34, 36, 40 represent architectural parameters of the data processing apparatus 10 which may be taken into consideration when determining how the order in which points in the referenced domain are allocated to threads for execution should be configured.

The GPU 12 is further provided with a performance optimiser unit 42 which monitors the performance of the GPU 12 as a whole and the performance of its specific components (receiving this information from performance monitor 43), and on the basis of performance feedback information is configured to, where required, signal to the job manager 28 or the thread dispatchers 24, 26 that the order should be amended in order to improve system performance. The performance monitor 43 is configured to receive performance information from throughout the GPU 12, as required for the particular determinations being performed by the performance optimiser 42. The performance optimiser 42 can be configured to optimise performance according to different metrics. One metric is the data processing time, i.e. the time taken for a particular set of operations to carried out. Another metric is the data processing energy consumption, i.e. the (estimated) energy consumed by the GPU 12 when performing a predetermined data processing task. The energy consumption could for example be estimated by counting high-energy operations such as floating point add/multiply, instruction fetches and data moves between LI, L2 and memory. By assigning a nominal energy cost to each operation it is possible to estimate the total energy used. In addition, the static energy used can be determined by measuring the number of active cycles for each unit and having a nominal energy cost per cycle (=power) for each unit. These determinations are carried out in the performance monitor 43. Alternatively the performance monitor 43 may be configured to contain explicit circuitry to measure the energy used directly.

Figure 2 schematically illustrates more detail of the manner in which the thread dispatcher in one of the cores shown in GPU 12 in Figure 1 operates, and more detail of the parallel execution of multiple threads. The example of core 20 is taken here and accordingly thread dispatcher 24, LI cache 30 and its pending transaction queue 34 are thus shown. The performance optimiser 42, L2 cache 38 and memory 16 of Figure 1 are also illustrated again in Figure 2. As can be seen from the top of Figure 2, core 20 is in fact not only configured to perform parallel thread execution, but moreover is a warp-based execution unit configured to execute 8 threads T0-T7 as one warp, and is configured to maintain 8 warps (shown as warp 0 - warp 7) of threads. The thread dispatcher 24 allocates the threads to the warps and data processing tasks to each thread. This is done in part with to respect to reference domain information defining the reference domain which should be used to determine the input data for the data processing carried out by each thread, and in part based on user specification (this being in the form of dedicated program instructions (executed by the thread dispatcher 24 / job manager 28) which allow the user to specify certain aspects of the how the order that points in the reference domain are allocated to threads for processing should be configured). In addition, the thread dispatcher 24 is responsive to input from the performance optimiser 42 which itself receives architectural information about the configuration of the data processing device as one input and processing performance information about current or previous data processing performance as another input.

As illustrated in Figure 2 the core 20 is currently executing warp 0, comprising threads T0-T7. Thus, in the execution stage each thread has an associated program counter value PC (i.e. PC0-PC7). Ideally, threads T0-T7 operate fully in parallel with one another (i.e. without divergence) and will then all operate with respect to the same program counter value PC. One particular benefit of being at the same program counter value PC is that in the load/store stage the memory addresses A0-A7 which this set of 8 threads seeks to access will be closely aligned. In some instances these could indeed be the same memory address, or they may for example only be small increments with respect to one another, meaning that for example a single cache line may cover several if not all, of the required data values. As a warp-based execution unit, the core 20 is provided with mechanisms to identify when the addressed A0-A7 are closely related to one another and to optimise (for example to group together) the resulting memory transactions accordingly.

In the context of the processing arrangements schematically illustrated in Figure 2, the present techniques recognise that performance advantages may be gained by targeted choices being made in respect to the order with which the thread dispatcher 24 allocates points in the reference domain to the threads for data processing. This then enables the architectural components of the data processing apparatus to be used more efficiently (for example by benefitting from cache locality), but without this efficiency being won at the expense of the executing threads having to use valuable data processing capability to perform a non- sequential memory address calculation. One example of performance improvement which can be gained is if the memory addressed A0-A7 at the load/store stage are closely correlated, and the ordering of allocation of points of the reference domain chosen by the thread dispatcher 24 can be made to support this. Conversely a preferred performance advantage may in fact result if this memory address correlation is intentionally broken up (at least to a certain extent). This can be understood with reference to the pending transaction queue 34, in which entries are made with respect to each memory transaction, i.e. where a memory transaction initiated by the core 20 has been unable to complete with respect to the data values currently held in the cache lines 44 of the LI cache 30 and the required data is currently being retrieved, either from L2 cache 38 or further from the memory 16. In order to hide the memory latency associated with retrieval from the L2 cache 38, or more significantly from the memory 16, it is advantageous if the pending transaction queue 34 remains relatively full. One way of achieving this is to vary the order with which points in the reference domain are allocated to threads for the processing by the thread dispatcher 24, such that the correlation between the memory addresses A0-A7 at the load/store stage is weakened and therefore more independent memory transactions are required. It should be recognised that the same principle with respect to the population of the pending transaction queue applies equally to the other LI cache 36, or indeed to the L2 cache 40.

Another architectural feature of the components shown in Figure 2 which may be taken into account when determining the order in which the thread dispatcher 24 allocates points in the reference domain to the threads for data processing is the configurational sizes of the caches. For example, the size of each individual cache line 44 and the number of those cache lines which can be held by the LI cache 30 can be a significant factor. In order to ensure that the LI cache 30 is efficiently used, the order in which the thread dispatcher 24 allocates points in the reference domain to the threads for data processing can be correspondingly adjusted.

Figure 3 schematically illustrates a reference domain which may be employed according to the present techniques. As can be seen from the figure, in this instance the reference domain is a two-dimensional reference domain and in particular, comprises 1000 x 800 points. This two-dimensional set of points corresponds in this instance in a one-to-one relationship with a frame of image data (i.e. the frame comprises 1000 x 800 pixels), however it should be noted that this one-to-one relationship is not essential, and may vary in dependence on the processing being performed. For example, a reference domain with fewer reference points than there are pixels can be envisaged, such as when less than all pixels required processing (e.g. only alternate pixels should be processed). Alternatively, a reference domain with more reference points than there are pixels can also be envisaged, and could even have an additional dimensional, say, such as when more than one processing step should occur with regards to each pixel and the additional dimensional gives a set of reference points corresponding to each processing step for each pixel. The highlighted set of pixels 60 shown in Figure 3 gives an example of when it may be advantageous not to process the pixels in raster scan order. In this example the particular processing being performed with respect to each pixel location requires a comparison to be made to the pixel locations which are immediately (up/down/left/right) adjacent. Accordingly two example sets of pixel locations which are accessed in two different processing steps as shown, the first being indicated by the cross-shaped set of "x"s and the second being indicated by the cross-shaped set of "o"s. The spatial spread of each of these sets, and the overlap between them, illustrates why a block-wise approach to the ordering with which the points of reference domain (and thus in this example the pixels in the frame) is preferable over a raster scan ordering, because the improved cache usage which results.

Figure 4A schematically illustrates an example of a two-dimensional reference domain 50. Furthermore, Figure 4A shows an example of how the order in which points within this reference domain are allocated for processing can deviate from a simple sequential, raster scan ordering. The rectangles in Figure 3 illustrates how the reference domain 50 has been sub-divided into a hierarchy of levels of smaller rectangles, with a hierarchically higher level of four rectangles 52 each themselves being sub-divided into a hierarchically lower level of nine rectangles 54. The arrows in Figure 4A illustrate that the points within each rectangle 54 are taken in a raster scan order, and the rectangles 54 are themselves handled in a raster scan order, and finally the rectangles 52 are themselves also handled in a raster scan order.

A particular feature of the present techniques is that not only are the sizes of the (sub-)rectangles in Figure 4A configurable by the user, but the number of levels in the hierarchy of rectangles is similarly configurable. Furthermore, whilst the user may choose to fully specify the order in which the points of the reference domain are allocated at all levels of the hierarchy, it is also possible for the user to select one or more levels of the hierarchy at which to specify the ordering, whilst leaving the ordering at the remaining levels to be determined by the data processing apparatus itself. Figure 4B schematically illustrates how different choices may be made with respect to each level of a hierarchically sub-divided reference domain. For simplicity of illustration the reference domain is limited here to a two-dimensional 8 x 4 domain (i.e. having 32 points for allocation). The reference domain has been sub-divided into a hierarchy comprising an "outer" 4 x 4 sub-domain and an "inner" 2 x 2 sub-domain. At each level of the hierarchy the system user can specify whether a "depth first" or a "breadth first" approach should be taken. The resulting four different permutations of resulting allocation ordering are shown. Note that it is not necessary for the user to explicitly specify the ordering for each level, and the system may be configured to default to, say, a depth first ordering for a given level of the hierarchy if it has not been user-specified, or for the system to select an appropriate ordering based on the characteristics of the particular apparatus.

Figures 5A-5C schematically illustrate example program instructions which may be used to configure the data processing apparatus in one embodiment. These therefore represent program instructions which are executed by the data processing apparatus in an initial setup phase, before the main data processing begins. The sequence of program instructions shown in Figure 5 A correspond to the processing configuration schematically shown in Figure 4A. Accordingly, the first instruction "DEFINE REF DOMAIN (1000, 800)" defines the dimensions of the reference domain to be used. The second instruction "DEFINE HIERARCHYLEVELS = 2" sets up the number of levels of the hierarchy. The third and fourth instructions "DEFINE LEVEL" set up the configuration of each level, i.e. in this example being a 2x2 and 3x3 set of rectangles respectively. The fifth and sixth instructions "DEFINE ORDERING LEVEL [x]", allows the programmer to explicitly define the order in which the rectangles at each level of the hierarchy should be handled, in this case in depth-first and breadth- first order respectively. The seventh instruction "DEFINE ORDERING LEVEL [BASE]", allows the programmer to explicitly define the order in which the rectangles at the base level of the hierarchy should be handled, e.g. within each rectangle 54 in Figure 4A, which in this case is explicitly defined as raster scan order. Figure 5B shows an alternative manner in which the program instructions can be used to specify the ordering in which the reference domain points should be handled by the data processing apparatus. The first instruction "DEFINE ORDERING LEVEL 0, [FUNCTION]", allows the programmer to explicitly define, for a particular level of the hierarchy, a function to be used to determine the order in which points are allocated to threads as a function of the thread number. Further examples of such functions are described below with reference to Figures 6A-6C. The second instruction "DEFINE ORDERING LEVEL 0, [HARDWARE]", allows the programmer to explicitly define a level of the hierarchy at which the order in which points are allocated threads should be determined by the hardware, i.e. by the data processing apparatus. Referring to Figure 1, this selection within the hardware will then be carried out by job manager 28 and/or thread dispatchers 24,26. The third instruction "DEFINE POINT USAGE, ALTERNATE" allows the programmer to specify a subset of points in the reference domain which should actually be allocated to threads for processing. In this example only alternate points (e.g. in a checkerboard fashion) should be processed. Alternatively the user may explicitly specify "DEFINE POINT USAGE, ALL" to indicate that all points should be allocated, although this is also the default behaviour of the system. As another alternative the user may explicitly specify "DEFINE POINT USAGE, FUNCTION' to indicate that all points should be allocated which satisfy the specified function "FUNCTION', which could for example define a geometric sub-space (e.g. a circle) within the reference domain.

Finally Figure 5C presents a high-level view of the information which the programmer provides to the data processing apparatus before it begins its data processing operations. In particular, the three components provided are: a kernel; a reference domain definition; and an (at least partial) ordering definition.

Figures 6A-6C illustrate some functions by which points within a reference domain maybe selected on the basis of a given thread number (T _n ). Figure 6 A illustrates that separate functions fn _x and fn _y may be provided to determine each coordinate (x,y) in a two-dimensional reference frame. Figure 6B illustrates that the width W of a two-dimensional reference frame may be used to calculate x and y coordinates in combination with the thread number T _n . Figure 6C illustrates a function in which an 8-bit thread number can provide each coordinate (x,y) in a two- dimensional reference frame, wherein the four most significant bits provide the y coordinate and the four least significant bits provide the x coordinate, and wherein the function is configured to permute (i.e. swap) the least significant bits of the x and y coordinates. The resulting reference point ordering is shown.

Figure 7 schematically illustrates how the configuration of the order in which points in a reference domain allocated to threads for data processing can be linked to the warp structure of the data processing apparatus. In particular, as shown in the figure the ordering has been configured such that when considering a row of points in the reference domain the warps to which the allocated threads belong are interleaved. This means that each warp accesses a larger spread of memory, and causes more entries to be added to the load queue in the cache (if not already present). By doing this in the earliest warp the memory operations start sooner and thus latency is reduced.

Figure 8 schematically illustrates a sequence of steps which may be taken by the data processing apparatus in one embodiment. The first step 100 determines the dimensions of the reference domain (e.g. from a "DEFINE REFDOMAIN" instruction such as that described with reference to Figure 5A). The next step 101 determines if any user specified sub ranges/sub range usages have been specified (e.g. from the "DEFINE HIERAR CHYLEVELS' ' etc. instructions such as those described with reference to Figure 5A). At step 102 it is then determined if the sub ranges within the reference domain have been fully user- specified. If they have then the flow proceeds to step 105 where the points in the reference domain are allocated to threads using the user specified sub ranges and orderings. Whilst there are further points in the reference domain to be allocated (checked at step 106), the flow continues around the step 105 / step 106 loop. Once all reference point and reference domain have been processed the processing may be considered complete at step 107. It should however be noted that a typical configuration for the data processing apparatus to process many image frames sequentially and therefore once all points in the reference domain have been used with respect to one image frame, the next step will typically be to reset to the start of the reference frame to begin processing of the next image frame. Returning to step 102, it is determined that the sub ranges and orderings within the reference domain are not fully user specified then the flow proceeds to step 103 where the points in the reference domain allocated threads using any user specified sub ranges and orderings, and allowing the hardware (i.e. typically the job manager and thread dispatch unit(s)) to determine any sub ranges/orderings where it has the freedom to do so. These may in particular be determined by the hardware such that efficient usage of architectural components of data processing apparatus is made, as described above. Whilst there are further points in the reference domain to be allocated (checked at step 104), the flow continues around the step 103 / step 104 loop. Once all reference point in the reference domain have been processed the processing may be considered complete at step 107 (subject to the same caveat mentioned above with respect to processing many image frames sequentially).

Figure 9 schematically illustrates a sequence of steps which may be taken by the data processing apparatus in one embodiment. These steps are in particular associated with the operation of the performance optimiser 42 shown in Figures 1 and 2. At the first step 110 the data processing apparatus performs its data processing using a selected coordinate value to thread ordering (i.e. a current configuration for the allocation of points in the reference domain to threads for data processing). Step 111 shows the performance optimiser 42 monitoring and logging the data processing performance of the data processing apparatus (for example in terms of time spent, estimated energy consumption, or other aspects of system component use). It is then determined at step 112 whether it is desirable for the performance of the data processing apparatus to be adapted, for example because it has been determined that more efficient data processing could be achieved. Taking a frame of image data to be processed as a "job" allocated within the data processing apparatus, the determination performed at step 112 may be performed at the conclusion of the processing of each job (i.e. after each frame has been processed), as it may not be until this stage that meaningful analysis of the performance can be carried out. If an improvement in the performance can be achieved, then at step 113 the configuration which defines the order in which points (coordinates) in the reference domain are allocated to threads for processing is adjusted. Thereafter the flow returns to step 110. It should be noted that this performance adaption could be carried out by either the GPU 12 or the CPU 14 (see Figure 1) as required.

Figure 10 schematically illustrates a sequence of steps which may be taken by the data processing apparatus in one embodiment. These steps are in particular associated with an empirical approach to determining an optimal configuration for the order in which the reference domain points are allocated to threads for processing. A number of different configurations are tested out by the method illustrated in Figure 10 on sample data before the processing of the real target data begins. The flow can be considered to begin at step 115, where a first configuration is tested and at step 116 the data processing apparatus is reconfigured to use this new ordering configuration. On the basis of this configuration the performance of the data processing apparatus is monitored and logged at step 117, until sufficient data have been gathered to evaluate this configuration. The flow then returns to step 115 where it is determined if there is another configuration of the ordering to be tested. Whilst this is true the flow continues around the steps 115 / 116 / 117 loop, testing each configuration in turn and gathering performance data for each. Once all configurations have been tested the flow branches to step 118 where the preferred configuration is determined, at step 119 the ordering configuration is adapted accordingly and step 120 the target data processing begins.

Although a particular embodiment has been described herein, it will be appreciated that the invention is not limited thereto and that many modifications and additions thereto may be made within the scope of the invention. For example, various combinations of the features of the following dependent claims could be made with the features of the independent claims without departing from the scope of the present invention.