# Patent

## Title
Apparatus, system, and method for offloading pattern matching scanning

## Abstract

Diagnostic software often requires pattern matching scanning to be performed to detect problems such as computer viruses or unwanted intruders. A computing system offloads pattern matching scanning from a central processing unit to a graphics processing unit.

## Background
FIELD OF THE INVENTION
The present invention is generally directed towards performing pattern matching scanning of data in a computer system to detect problems such as computer viruses or intrusive attacks. More particularly, the present invention is directed towards offloading pattern matching scanning from a central processing unit.
BACKGROUND OF THE INVENTION
Computer systems typically include diagnostic software that scans data files or received data packets to detect pattern matches indicative of problems such as computer viruses or intrusive attacks. For example, computer anti-virus software typically scans files for patterns indicative of computer viruses. Depending upon the implementation, diagnostic software may also scan data packets received from a network. For example, some types of computer intrusion software detects patterns in data packets indicative that a source of incoming data or requests is untrustworthy. As one example, intrusion detection software may look for patterns in password prompts and other information indicative of an intruder.
Conventional pattern matching software performs sequential pattern matching in which a data source is compared to different patterns in a sequence, i.e., first pattern 1 is checked against the data source, then pattern 2, then pattern 3, and so on until all of the different patterns are checked. A problem with pattern matching software is that it places a substantial burden on the resources of a central processing unit (CPU). This is due, in part, to the large number of patterns that must be compared in typical applications. For example, anti-virus software typically must guard against numerous different types of viruses that each require different pattern matches to be performed. As a result, many computer systems run significantly slower when anti-virus software is running in the background. Moreover, a complete anti-virus scan often takes longer than desired in many computer systems. For example, in some personal computer systems it can take several hours to perform a complete anti-virus scan of all files stored on a disk.
The demands for diagnostic pattern matching scans continues to increase. For example, anti-virus software companies regularly increase the dictionary of patterns that must be scanned in order to address new viruses or other problems, such as spyware. Additionally, diagnostic software is increasingly being applied to address new issues, such as implementing increasingly sophisticated intrusion detection algorithms. It can therefore be expected that pattern matching scanning will impose an ever increasing burden on computing resources.
Therefore, in light of the problems described above the apparatus, system, and method of the present invention was developed.
SUMMARY OF THE INVENTION
Diagnostic software may require pattern matching scans to be performed to detect problems in a computing system. An apparatus, system, and method is disclosed for offloading pattern matching scans from a central processing unit to a graphics processing unit.
One embodiment of an apparatus for use in a computing system having a central processing unit (CPU) and diagnostic software requiring pattern matching scanning, comprises: a graphics processing unit (GPU) for processing graphics data; the GPU configured to have a mode of operation in which the GPU performs pattern matching scanning operations on the behalf of the computing system, whereby pattern matching scanning is offloaded from the CPU to the GPU.
One embodiment of a computing system comprises: a central processing unit having a memory and associated diagnostic software requiring pattern scanning matching; and a graphics processing unit communicatively coupled to the central processing unit for performing graphics processing; the graphics processor adapted to have a mode of operation in which the graphics processing unit performs pattern matching scanning for the diagnostic software in which data is compared to a string database.
One embodiment of a method of performing a diagnostic operation in a computing system having a central processing unit and a graphics processing unit comprises: offloading pattern matching scanning to a graphics processing unit; and receiving reports from the graphics processing unit indicative of instances of pattern matching of input data blocks to a string database.



BRIEF DESCRIPTION OF THE FIGURES
The invention is more fully appreciated in connection with the following detailed description taken in conjunction with the accompanying drawings, in which:
FIG. 1 is a block diagram of a computing system that offloads pattern matching scanning to a graphics processing unit in accordance with one embodiment of the present invention;
FIG. 2 is a diagram illustrating a method of performing pattern matching scanning utilizing a graphics operation in accordance with one embodiment of the present invention;
FIG. 3 illustrates a graphics processing unit in accordance with one embodiment of the present invention;
FIG. 4 illustrates a stage of a graphics processing unit having an array of parallel processors in accordance with one embodiment of the present invention; and
FIGS. 5 and 6 illustrate a method of utilizing parallel processing threads to scan different windows of a character string in accordance with one embodiment of the present invention.



Like reference numerals refer to corresponding parts throughout the several views of the drawings.
DETAILED DESCRIPTION OF THE INVENTION
FIG. 1 illustrates a computing system 100 in accordance with one embodiment of the present invention. Computing system 100 is configured to support graphics processing and may including a variety of types of computing systems that support graphics processing, such as personal computers, networked computers, media center computers, and laptop computers.
A central processing unit 110 is provided for executing software applications. As an illustrative example, in a personal computer CPU 110 may be the CPU that executes software applications running on the personal computer. A bridge module 120 may be included to couple data between different devices in computing system 100. Bridge module 120 may, for example, implement the function of a North bridge. A main memory 130 is provided to store data and may, for example, be coupled either directly to CPU 110 or via bridge module 120 or other intermediate element.
Graphics processing unit (GPU) 140 performs graphics processing operations on the behalf of CPU 110. In one embodiment a frame buffer memory 150 is provided for GPU 140 to store graphics data. In one embodiment GPU 140 and frame buffer 150 are disposed on a graphics card 160. However, it will also be understood in the following discussion that other implementations of GPU 140 are contemplated. For example, GPU 140 may be implemented as an integrated GPU residing inside a chipset with the frame buffer located in system memory.
CPU 110 has diagnostic software 112 that it executes which requires pattern matching scans. The pattern matching scans may, for example, include scans to detect strings of characters indicative of a problem. In many typical diagnostic applications a dictionary will include many different strings of characters for which a pattern matching scan must be performed to complete a particular diagnostic function. Illustrative examples of diagnostic software requiring pattern matching scans include computer virus detection software (often known as “anti-virus” software) and intrusion detection software. The diagnostic software 112 may require a pattern matching scan to be performed on a scheduled basis. Alternatively, diagnostics software 112 may diagnose problems as computing system 100 receives a stream of data from a network, such as performing virus scans as a computer user downloads data from the Internet.
CPU 110 also executes a graphics driver 114 for interacting with GPU 140. CPU 110 may also execute other software applications, such as graphics applications (not shown), text applications, media applications, and email applications. It will be understood that software modules for each application reside on a memory associated with CPU 110 and may be provided to end-users pre-loaded on computing system 100, downloadable from the Internet, or as software modules having computer readable program code stored on a computer-readable medium.
One aspect of the present invention is that at least some pattern matching scanning calculations are offloaded from CPU 110 to GPU 140. GPUs have evolved to support demanding graphics applications, such as three dimensional games and simulations. Consequently, GPU 140 will typically have substantial processing power for performing calculations upon graphics data within the graphics domain. Moreover, in a multi-purpose computing system, GPU 140 is typically fully utilized only for the fraction of the time that an end-user operates a demanding graphics application. Thus, GPU 140 is a potential resource for performing pattern matching scanning. Consequently, in accordance with the present invention diagnostic software 112 has a mode of operation in which it offloads pattern matching scanning calculations to GPU 140.
Pattern matching scanning may be performed on data blocks 180 of a pre-selected size. An exemplary size is 64K, corresponding to a conventional network data window size. An individual data block 180 may reside in any memory of computing system 100 accessible by GPU 140 directly or through a direct memory access, such as main memory 130 or frame buffer 150. The source of data for a data block may be stored data, such as data accessed from a disk (not shown) via a disk interface 122.
In one embodiment the source of data for a data block 180 comes from data packets 124 received by a network interface 126. For the case of data packets received from a data network, payload data for a number of data packets may be aggregated into a data block 180 for efficient analysis. Attributes of the header information may also be collected for analysis. In one embodiment, a data block 180 formed from incoming data packets may be intercepted for pattern matching in GPU 140 before it is processed by CPU 110. For example, bridge module 120 may be configured in response to an offload command to route data packets to GPU 140 for pattern matching analysis.
In one embodiment, an application programming interface (API) call is made from diagnostic software 112 to driver 114 to initiate an offloading of the pattern matching scanning to GPU 140. That is, software hooks in diagnostic software 112 utilize an API call to driver 114 to request that pattern matching scanning be offloaded to GPU 140. In turn, driver 114 then generates any necessary commands and data pointers to instruct bridge module 120 and GPU 140 to provide access to data blocks 180 to GPU 140 for pattern matching scanning. In the case of a computing system 100 performing two or more different types of pattern matching scanning, driver 114 may also provide instructions to GPU 140 to define the type of pattern matching scanning to be performed.
The results of the pattern matching scanning performed by GPU 140 are reported back to diagnostic software 112 in CPU 110. This may be implemented with different levels of specificity, depending upon bandwidth and processing constraints. For example, the report may be a flag or other bit indicating a match occurred. Alternatively an exact string may be reported or a list of all strings and offsets. While GPU 140 may perform all of the pattern matching scanning, more generally GPU 140 may perform selected portions of the pattern matching scanning. For example, GPU 140 may perform a first pass of pattern matching scanning to identify data blocks 180 having potential problems. In one implementation, the report that is sent back to diagnostic software 112 is used by diagnostic software 112 to select data blocks 180 for additional analysis in a second pass of analysis. The second pass of analysis may, for example, be performed either on GPU 140 or on CPU 110.
GPU 140 may be adapted to receive data in specified data formats. Reformatting of input data may occur in CPU 110. Alternatively, in one embodiment bridge module 120 includes a data reformater 128 to convert input data blocks 180 into a format compatible with GPU 140. In another embodiment, a processing block 142 of GPU 140 is used to perform at least some of the data reformatting
GPU 140 utilizes a string database 152 to perform pattern matching scans for a particular diagnostic function. In one embodiment an initialization process is implemented by diagnostic software 112 to load the string database 152 into a memory accessible to GPU 140, such as frame buffer 150 or a portion of main memory 130.
The string database 152 is a dictionary of strings of characters that input data is compared against to identify matches indicative of problems with a data block 180. Pattern matching scanning requires testing input data for the occurrence of a sequence of characters having a specified order. As such, one way of performing a pattern matching scan in GPU 140 is to utilize a state table in which the state is incremented each time that a successive character of an input data string matches a pattern. That is, the state advances with each successive matching character until a terminal state is reached, indicating a pattern match was identified. There may also be an exit state indicating that no pattern match was found. In one embodiment, string database 152 includes finite state machine (FSM) dictionary tables 154 which are designed to execute a FSM implementation of a pattern matching algorithm when GPU 140 executes a pre-selected processing operation. The FSM dictionary tables 154 may be compiled and loaded by diagnostic software 112 into a memory accessible by GPU 140.
String pattern matching scanning is performed utilizing at least one processing block 144 of GPU 140, such as a pixel shader, vertex processor, or video processor. GPUs typically include pipeline stages designed to perform certain types of graphics operations in parallel over a substantial number of parallel processors. For example, many GPUs have hundreds or even thousands of processors in selected pipeline stages, such as a shader stage or a vertex processor stage. It is therefore desirable to perform pattern matching scanning in a way that is compatible with the types of graphics operations that a GPU is designed to process in parallel. This permits GPU 140 to be used to perform pattern matching using parallel processors, improving the speed with which pattern matching scanning can be performed. As a result, GPU 140 can be utilized to perform pattern matching scanning with the processing work of the pattern matching scanning distributed over many different internal processors, resulting in potential speed improvements compared with performing pattern matching scanning in a conventional CPU 100.
An exemplary graphics operation to execute a FSM implementation of a pattern matching scanning algorithm is a dependent texture fetch. Dependent texture operations are well-known graphics operations described in graphics standards such as the OpenGL® 2.0 Specification, the contents of which are hereby incorporated by reference. Pixel texture and dependent texture are commonly used to describe graphics operations in which color fragments are used to generate texture coordinates. The color fragments are replaced with corresponding entries from a texture. These operations are essentially equivalent to an arbitrary function evaluation using a lookup table. Thus, one way to implement a FSM for pattern matching scanning in a GPU is to implement string database 152 as textures selected to execute a FSM for performing pattern matching when a dependent texture operation is performed. In particular, string database 152 may be implemented as FSM dictionary tables 154 stored as a texture such that in response to a dependent texture operation an input character string is compared to entries in the FSM dictionary table 154. In this case, the function evaluation performed by the table lookup to FSM dictionary table 154 is selected to implement a FSM designed to perform a pattern matching scan.
FIG. 2 illustrates an exemplary process for performing pattern matching in GPU 140 using dependent texture operations. Driver 114 (not shown in FIG. 2) opens a graphics device channel for performing graphics processing to draw primitives, e.g., triangles. An input data character string 205—such as a character string a, b, c, d, and e—is converted into a input data structure compatible with GPU 140, such as a texture 210 in which each character is represented as an attribute of a pixel, such as a color. In an exemplary application each pixel has four thirty-two bit values. As an illustrative example, texture 210 may be a one or two-dimensional texture with each pixel being a single character (e.g., byte) of the input data. A shader program 230 is implemented to perform a texture dependent fetch to compare texture 210 with a two-dimensional texture corresponding to a FSM dictionary table 154. In one embodiment the output data is a one-dimensional texture surface in which the byte value of each pixel position represents whether a string was detected in the input starting in that position. In one embodiment, a pixel 220 of a bitmap is shaded to indicate that an instance of a pattern match was detected.
Table I illustrates in more detail a portion of an exemplary FSM dictionary table. An input data block 180 is represented as an input data structure corresponding to a first texture, such as a linear texture in which each character (e.g., each ASCII byte value) is assigned to one pixel. The FSM dictionary table corresponds to a second texture which is a two-dimensional texture. An x-dimension of a second texture corresponds to the ASCII byte value of an input character (e.g., a, b, c, or d) defining a pattern match and the y dimension corresponds to the current state of the state machine. In a dependent texture operation the value accessed at a point (x, y) would be the next state of the state machine. Thus, as a dependent texture fetch operation is performed Table I is traversed in a raster fashion. Thus, for example, in the first state (second row) if characters “ab” are encountered the state moves to state 2.
Table II illustrates another example of an FSM dictionary table. The table structure is arranged as a jump table. The address into the table is formed from {state|byte}, where state is a per-thread register that is retained, and byte is the next byte of input. The contents of the texture are used to update state. As one example, consider a state table of 7*256 entries which searches for the strings “foo” and “sam”. The initial state is set to 2. States 0 and 1 are sticky. Upon exit, if state==0, there was no match. If state==1, there was a match.
Referring back to FIG. 2 and Tables I and II, in one embodiment shader program 230 starts in an initial state and reads sequential values from a starting point within texture 210. Shader program 230 then uses these values to make a dependent texture fetch to the FSM dictionary table 154 to find the next state. This continues until the state of the FSM dictionary table 154 indicates that the next state is a terminal state. In one embodiment the output data structure is a one-dimensional texture surface in which the byte value of each pixel position represents whether a string was detected beginning at a corresponding character position (e.g., byte position in an implementation in which a character corresponds to a byte) in texture 210. For example, in one embodiment the output of the shader program is a bitmap 1 wide by N long, where N is the number of bytes in the payload (e.g., in an embodiment where a character corresponds to a byte, the bitmap corresponds to a length of N characters). If the FSM arrives at a terminal case indicating that a match was found, a pixel is written to indicate that a match was found. In one embodiment, the pixel is written in a location indicative of a corresponding byte location in the input data character string where a pattern match begins (e.g., the pixel is written red in the location of the bitmap corresponding to a string pattern match starting at that byte location). If no match is found, the pixel is written with a different format (e.g., the pixel is written white). Thus, upon completion of shader program 230 the pixels are written such that instances of pattern matches can be detected by detecting pixels with the specified shading characteristics (e.g., red pixels in this example).







TABLE I







Portion of exemplary FSM dictionary table illustrating state transitions.











state
a
b
c
d





0
0
0
0
0


1
0
2 (move to state




2 if string “ab”




is matched)


2
0
0
3 (move to state





3 since string





“abc” is





matched)


3
















TABLE II







Second example of FSM dictionary table.











State
byte
state_next







0 (no match)
. . .
0



1 (match)
. . .
1



2 (start)
0
0




. . .
0




‘f’
3




. . .
0




‘s’
4




. . .
0



3
. . .
0




‘o’
4




. . .
0



4
. . .
0




‘o’
1




. . .
0



5
. . .
0




‘a’
6




. . .
0



6
. . .
0




‘m’
1




. . .
0










In one embodiment, pointers to data structures are passed on to a shader program 230 to perform the pattern matching scanning. One of the pointers is to the data to be scanned. The input data is formatted as a one-dimensional or two-dimensional texture, with each pixel being a single character of the input data. The other pointer is to a state table corresponding to an output texture. Depending upon the implementation, other information may also be passed on the shader program 230 to implement the desired pattern matching scans and output data in a desired format.
One aspect of the present invention is that it can exploit the parallelism of a GPU 140 having one or more stages with parallel processing units. FIG. 3 illustrates an exemplary GPU 140 having a pipelined architecture which includes a vertex processor stage 305, geometry processor stage 310, shader stage 315, raster operations (ROP) 320, and video processor 325. As illustrated in FIG. 4, an individual stage 400, such as shader stage 315 may, in turn, have a multi-threaded parallel processor architecture in which stage 400 has a number of different processors 400 that are assigned work from a thread pool. This permits a program executed on stage 400 having parallel processors 410 to generate execution threads which are processed in parallel.
GPU 140 is preferably optimized for a particular implementation to efficiently read FSM dictionary tables 154 of string database 152, read input data blocks, record matches, report results, and reformat data. One optimization is to encode a FSM dictionary table 154 for a data string so that a single read of the FSM dictionary table 154 returns not only the next FSM state but a compressed list of one or more of next most-likely states along with corresponding input values. The number of data reads can be reduced by selecting an efficient input texture format based upon the different types of data stored in a pixel. For example, in an R, G, B, alpha format, an input texture can be optimized by repeating values of a character string in a staggered manner in the red, green, blue and alpha fields of a pixel such that the data string “abcdefg” is encoded in a pixel as “abcd”, “bcde”, “cdef” and “defg.” In this example, a single read permits the input value and the next three values to be obtained from a single read. In one embodiment the shader program discards pixels where no strings were detected to reduce the amount of data that must be recorded. In this embodiment, the number of strings matches with the input data can then be obtained by counting the number of pixels written to the output structure. One optimization for handling larger input data blocks is to format large data blocks as two-dimensional textures. Two-dimensional textures complicate comparisons at the edges of textures. However, these issues can be addressed by padding the two-dimensional structures with repeated sections of input data or by adding a wrapping mode in the graphics hardware. Another optimization is to offload reformatting of input data to hardware such that the CPU does not have to reformat input data into a texture format.
FIGS. 5 and 6 are diagrams illustrating parallel pattern matching scanning. As illustrated in FIG. 5, it is desirable to examine different windows 502 and 504 of input texture 210 corresponding to different byte offsets. That is, each window has a different byte offset. As illustrated in FIG. 6, different threads 510, 515, and 520 of GPU 140 are assigned to process the different windows in parallel. For example, a first thread 510 may check for a pattern match to a window of the input data string corresponding to “abcd,” a second thread 515 may check for a pattern match to a window corresponding to “bcde,” and a third thread 529 may check for a pattern match to a window corresponding to “cdef.”
In one implementation of parallel pattern matching scanning, a shader program is run for every byte offset in the input data to perform pattern matching scanning in a parallel fashion. For example, for a 2 kB input string, the shader program may be run 2048 times in parallel with the value of the coordinates ranging from (0,0) to (0,2047). In one embodiment, if a string is found at a position coordinate x, then the corresponding pixel in the output texture is set to red and the occlusion counter will increment. Below is exemplary pseudocode describing operations performed by a shader program for checking for strings:














//float4
coords : DOMAIN
// parameter containing the


scan(float2


starting offset


 Stream
statetable,
// parameter pointing to the







output texture (not used)









 Stream
transitiontable,
// parameter pointing to the







table encoding the list of strings









 Stream
packetdata,
// parameter pointing to the







input data (e.g. network buffers)









 uniform float4
windowDims) : RANGE
// (not used)







{


// Initialize the “state” of the FSM to 1.


 float state = 1;


// This color of the output pixel will indicate whether a string was


detected.


// In this example, the output color is initialized to “red”, indicating a


 string has been found at this starting offset.


 float4 stateColor = float4(1.0,0,0,0);


 float packetbyte;


 int i;


// We walk through the FSM for 16 steps, which is the length of the


longest string in the string table.


// This can easily be adjusted for tables with longer strings.


 for(i=0; i<16; i++) {


  packetbyte = packetdata.value(float2(coords.x+i,coords.y));


  state = transitiontable.value(float2(packetbyte, state));


  }


// Now see what state the FSM is in. State == 0 means a string was


detected.


  if (state > 0) {


   // If no string was detected, discard the packet.


   // This is an optimization that allows us to use occlusion queries to


efficiently determine if pixels were set


    discard;


  }


// Set the pixel to “red”. // ignored if discard happened above.


return stateColor;


  }









As previously described, a benefit of the present invention is that scanning is offloaded to GPU 140. In many computing systems, GPUs are bundled with a CPU. As a result, in many applications an end-user gets the benefit of a reduced burden on their CPU and potentially faster scanning without increasing the hardware cost of computing system 100. Additionally, a GPU is also capable of performing pattern scanning processing using parallel processing, potentially increasing the rate at which pattern matching scanning is performed in a computing system.
An embodiment of the present invention relates to a computer storage product with a computer-readable medium having computer code thereon for performing various computer-implemented operations. The media and computer code may be those specially designed and constructed for the purposes of the present invention, or they may be of the kind well known and available to those having skill in the computer software arts. Examples of computer-readable media include, but are not limited to: magnetic media such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROMs and holographic devices; magneto-optical media such as optical disks; and hardware devices that are specially configured to store and execute program code, such as application-specific integrated circuits (“ASICs”), programmable logic devices (“PLDs”) and ROM and RAM devices. Examples of computer code include machine code, such as produced by a compiler, and files containing higher-level code that are executed by a computer using an interpreter. For example, an embodiment of the invention may be implemented using Java, C++, or other object-oriented programming language and development tools. Another embodiment of the invention may be implemented in hardwired circuitry in place of, or in combination with, machine-executable software instructions.
The foregoing description, for purposes of explanation, used specific nomenclature to provide a thorough understanding of the invention. However, it will be apparent to one skilled in the art that specific details are not required in order to practice the invention. Thus, the foregoing descriptions of specific embodiments of the invention are presented for purposes of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed; obviously, many modifications and variations are possible in view of the above teachings. The embodiments were chosen and described in order to best explain the principles of the invention and its practical applications, they thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. It is intended that the following claims and their equivalents define the scope of the invention.

## Claims

1. An apparatus for use in a computing system having a central processing unit (CPU) and diagnostic software requiring pattern matching scanning, comprising:
a graphics processing unit (GPU) for processing graphics data; and
a memory accessible to said GPU storing a string database;
said GPU configured to have a mode of operation in which said GPU performs pattern matching scanning operations on input data on the behalf of said computing system, said string database is stored in a format selected to execute a finite state machine implementation of said pattern matching scanning operations, such that a state associated with said finite state machine implementation is incremented with each successive matching character in said input data until a terminal state is reached, whereby pattern matching scanning is offloaded from said CPU to said GPU, wherein said GPU is configured to utilize a shading program to scan for patterns in which said string database is represented as one texture and said input data is represented as another texture.

2. The apparatus of claim 1, wherein said shading program performs a dependent texture operation to execute said finite state machine implementation.

3. A computing system, comprising:
a central processing unit having a memory and associated diagnostic software requiring pattern matching scanning; and
a graphics processing unit communicatively coupled to said central processing unit for performing graphics processing;
said graphics processing unit adapted to have a mode of operation in which said graphics processing unit performs pattern matching scanning for said diagnostic software in which input data is compared to a string database, said input data being represented as a first texture, said string database being represented as a second texture, and said graphics processing unit adapted to compare said input data to said string database by performing a shading calculation using the first texture and the second texture.

4. The computing system of claim 3, wherein said graphics processing unit is operative to perform scanning for data strings associated with anti-virus scanning.

5. The computing system of claim 3, wherein said graphics processing unit is operative to performing scanning for data strings associated with intrusion detection.

6. The computing system of claim 3, wherein said graphics processing unit performs said shading calculation using an array of shaders to compare said input data to said string database.

7. The computing system of claim 6, wherein a shading operation upon pixels is performed to detect pattern matches.

8. The computing system of claim 3, wherein said string database is stored in the form of a finite state machine dictionary table operative to perform pattern matching scanning.

9. The computing system of claim 3, wherein said graphics processing unit is configured to perform a shading program to scan for patterns in which said string database is represented as said second texture and said input data is represented as said first texture.

10. The computing system of claim 9, wherein said shading program performs a dependent texture operation to execute a finite state machine implementation of pattern matching scanning.

11. A method of performing a diagnostic operation in a computing system having a central processing unit and a graphics processing unit, comprising:
initializing a memory accessible by said graphics processing unit to include a string database;
offloading pattern matching scanning to said graphics processing unit; and
receiving reports from said graphics processing unit indicative of instances of pattern matching of input data blocks to said string database;
wherein said initializing comprises formatting said string database as one texture, and said offloading comprises comparing, using a texture dependent shading operation, said input data blocks formatted as another texture to said string database formatted as said one texture.

12. The method of claim 11, wherein said offloading includes utilizing an application program interface to issue calls for pattern matching scanning to be offloaded.

13. The method of claim 12, wherein said calls are issued to a graphics driver.