USRE44129E1 - System and method for instruction-level parallelism in a programmable multiple network processor environment - Google Patents

System and method for instruction-level parallelism in a programmable multiple network processor environment Download PDF

Info

Publication number
USRE44129E1
USRE44129E1 US11/862,815 US86281507A USRE44129E US RE44129 E1 USRE44129 E1 US RE44129E1 US 86281507 A US86281507 A US 86281507A US RE44129 E USRE44129 E US RE44129E
Authority
US
United States
Prior art keywords
instruction
thread
dependency
counter
execution
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Expired - Lifetime, expires
Application number
US11/862,815
Inventor
Joel Zvi Apisdorf
Sam Brandon Sandbote
Michael Daniel Poole
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
US Department of Navy
Original Assignee
US Department of Navy
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by US Department of Navy filed Critical US Department of Navy
Priority to US11/862,815 priority Critical patent/USRE44129E1/en
Application granted granted Critical
Publication of USRE44129E1 publication Critical patent/USRE44129E1/en
Adjusted expiration legal-status Critical
Expired - Lifetime legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3836Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3851Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution from multiple instruction streams, e.g. multistreaming
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
    • G06F9/3836Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3838Dependency mechanisms, e.g. register scoreboarding

Definitions

  • the present invention is related to patent applications “System And Method For Processing Overlapping Tasks In A Programmable Network Processor Environment” (Ser. No. 09/833,581) and “System and Method for Data Forwarding in a Programmable Multiple Network Processor Environment” (Ser. No. 09/833,578), both of which are incorporated herein by reference.
  • the present invention relates generally to digital computing. More specifically, the present invention relates to network processors for processing network data elements.
  • Network switches and routers form the backbone of digital networks, such as the Internet.
  • Network switch elements connect network segments by receiving network data from ingress network segments and transferring the network data to egress network segments. Because large telecommunications switching facilities and central offices aggregate network traffic from extensive networks and many network segments, they require high-speed and high-availability switches and routers.
  • Network switch elements select the egress network segment by processing the address or destination included in the network data according to network data processing program logic.
  • network switch elements included Application Specific Integrated Circuits (ASICs) that provided the program logic. Because ASICs are “hard-coded” with program logic for handling network traffic, they provide the high speed necessary to process a large volume of network data. ASICs, however, make it difficult to upgrade or reconfigure a network switch element, and it is expensive to design and fabricate a new ASIC for each new type of network rig switch element.
  • ASICs Application Specific Integrated Circuits
  • manufacturers of network switch elements are turning to programmable network processors to enable network switch elements to process network data.
  • Programmable network processors process network data according to program instructions, or software, stored in a memory.
  • the software allows manufacturers and users to define the functionality of the network switch elements-functionality that can be altered and changed as needed.
  • manufacturers and users can change the software to respond to new services quickly, without costly system upgrades, as well as implement new designs quickly.
  • instruction-level parallelism One technique used to increase speed in traditional processor design is “instruction-level parallelism,” or processing multiple threads of instructions on a processing element in parallel.
  • instruction-level parallelism techniques are either highly complex, or would introduce unacceptable delays and timing problems into the processing of network data, which must be processed on a time critical basis.
  • the present invention provides a system and method for processing information using instruction-level parallelism.
  • an instruction buffer holds a first instruction and a second instruction, the first instruction being associated with a first thread, and the second instruction being associated with a second thread.
  • one or more instructions from the second thread may be dependent on the execution of one or more instructions in the first thread.
  • a dependency counter is used to record dependencies of instructions between the first thread and the second thread.
  • An instruction control unit is coupled to the instruction buffer and the dependency counter, the instruction control unit increments and decrements the dependency counter on the basis of information in the instructions.
  • An execution switch is coupled to the instruction control unit and the instruction buffer, the execution switch sends instructions to an execution unit.
  • a first instruction associated with a first thread is loaded on a processing element.
  • the processing element determines that execution of a second instruction depends on the execution of the first instruction, where the second instruction is associated with a second thread.
  • a dependency counter associated with the second thread is incremented if the processing element determines that execution of a second instruction depends on the execution of the first instruction.
  • FIG. 1 illustrates a system block diagram of a data communications system.
  • FIG. 2 illustrates a system block diagram of a programmable network processor.
  • FIG. 3 illustrates a system block diagram of a multiprocessor core.
  • FIG. 4 illustrates a system block diagram of an exemplary processing element.
  • FIG. 5 is a diagram illustrating concurrent processing of three threads of instructions.
  • FIG. 6 illustrates concurrent processing of two threads of instructions.
  • FIG. 7 illustrates dependency counter groups.
  • FIG. 8 illustrates an exemplary instruction
  • FIG. 9 illustrates an exemplary process for executing instructions.
  • FIG. 10 illustrates an exemplary process for executing instructions
  • Programmable network processors offer a number of advantages including flexibility, low cost, maintenance ease, decreased time to market, and increased service life. It is difficult, however, to develop a programmable network processor capable of meeting the demand for ever-increasing speed.
  • One technique for increasing the speed of a programmable network processor is instruction-level parallelism. In instruction-level parallelism, threads of parallel programs can execute concurrently on a single processing element. Instruction-level parallelism allows a processing element to continue processing instructions, even if one or more threads are waiting for long-latency operations to complete.
  • instruction-level parallelism One problem with instruction-level parallelism is maintaining synchronization of dependent instructions between the threads running on a processing element. Often, an instruction in one thread is dependent on the execution of instructions in another thread. Examples of instruction dependency are control dependency (i.e., the execution of one instruction is conditioned on the execution of another) and data dependency (i.e., one instruction uses the results of the execution of another instruction).
  • control dependency i.e., the execution of one instruction is conditioned on the execution of another
  • data dependency i.e., one instruction uses the results of the execution of another instruction.
  • Conventional techniques for synchronizing the execution of instructions among multiple threads do not lend themselves to programmable network processor applications. Conventional techniques introduce significant delays to processing, delays that are unsuitable for processing time critical network data elements.
  • the present invention is directed to a system and method for synchronizing the execution of multiple threads of instructions on a single processing element at high speed.
  • An instruction in a first thread can include dependence indicators, such as a bit or bits, that indicate dependence of the instruction on the execution of a second thread.
  • dependence indicators such as a bit or bits
  • the processing element checks, decrements, or increments one or more dependency counters that record satisfaction of dependencies between instructions and threads. If a dependency indicator indicates that an instruction in a first thread is dependent upon the execution of a second thread, a dependency counter is checked. If the dependency counter is not above a threshold, the processing element suspends the execution of the first thread until the dependency counter is incremented by a second thread to above the threshold.
  • FIG. 1 illustrates a block diagram of a network data communications system, according to an embodiment of the present invention.
  • Data communications system 100 can be, for example, of the type used by network service providers and telecommunication carriers to provide voice and data communications services to consumers.
  • Data communications system 100 includes network 102 , network line modules 104 1 – 104 N , and switch fabric 106 .
  • network 102 network line modules 104 1 – 104 N
  • switch fabric 106 a subscript “N” in the figures denotes a plurality of elements generally, and not a specific number or equality of number between different elements with a subscript “N.”
  • Network 102 is connected to network line modules 104 1 – 104 N which, in turn, are connected to switch fabric 106 .
  • data communications system 100 is shown as including physical connections between the various components, other configurations are possible, such as wireless connections. Connections between network 102 , network line modules 104 1 – 104 N , and switch fabric 106 can be, for example, wireless data connections, data over copper, fiber optic connections (e.g., OC-48, OC-192, OC-768), or other data communications connections as would be apparent.
  • Network line modules 104 1 – 104 N send and receive network data elements to (from) network 102 .
  • Network line modules 104 1 – 104 N process the network data elements and communicate the process network data elements with switch fabric 106 .
  • Network data elements are signals carrying information including communications information. Examples of network data elements are asynchronous transfer mode (“ATM”) cells, Frame Relay frames, Internet Protocol (“IP”) packets, etc., and portions (segments) of these.
  • Processing includes the concepts of performing a calculation or manipulation involving a network data element. Processing can include, for example, determining the next hop or egress port to which the network data element Star should be routed, network management, such as traffic shaping or policing, network monitoring, etc.
  • Network 102 is a network for communicating network data elements. Network 102 can be, for example, the Internet, a telecommunications data network, an intranet, an extranet, a voice over data communications network, etc., and combinations thereof.
  • Network line module 104 includes network line module ingress port 108 , network line module egress port 110 , and programmable network processors 112 1 – 112 2 .
  • network line modules 104 1 – 104 N is shown for illustrative purposes only, and alternate configurations for network line modules 104 1 – 104 N are possible. Alternate configurations include, for example, single or additional programmable network processors per network line module, additional network line module ingress ports, multiple egress ports, additional connections to network 102 , etc.
  • Network line module 1041 104 1 receives network data elements from network 102 at network line module ingress port 108 .
  • Programmable network processor 112 1 receives network data elements from network line module ingress port 108 .
  • Programmable network processor 112 enables network line module 1041 104 1 to process the received network data elements.
  • Programmable network processor 112 1 provides the network data elements to switch fabric 106 after processing.
  • Switch fabric 106 includes switch fabric ingress ports 114 1 – 114 N and switch fabric egress ports 116 1 – 116 N .
  • Switch fabric ingress ports 114 1 – 114 N receive data from network line modules 104 1 – 104 N and switch fabric egress ports 116 1 – 116 N ports provide data to network line modules 104 1 – 104 N .
  • Switch fabric 106 outputs network data elements received from network processor 112 1 on the desired switch fabric egress port 116 1 – 116 N .
  • Network line module 104 1 receives processed network data elements from switch fabric egress port 116 1 and performs additional processing, as required, and transmits the network data element to network 102 via network line module egress port 110 .
  • network line module ingress port 108 network element egress port 110 , switch fabric ingress ports 114 1 – 114 N , and switch fabric egress ports 116 1 – 116 N are logical representations of physical devices, and other combinations, such as single ports that transmit and receive network data elements, are possible.
  • FIG. 2 illustrates a system block diagram of a programmable network processor, according to an embodiment of the present invention.
  • Programmable network processor 200 can be considered an exemplary embodiment of both ingress and egress programmable network processors 112 1 – 112 N , as described above.
  • Programmable network processor 200 includes memory controller 204 , input interface 206 , multiprocessor core 202 , and output interface 208 .
  • Multiprocessor core 202 is connected to input interface 206 , output interface 208 , and memory controller 204 . Note that the particular configuration, number, and type of elements of programmable processor 200 are shown for illustrative purposes only and other configurations of programmable network processor 200 are possible as would be apparent.
  • the programmable network processor 200 of FIG. 2 corresponds to programmable network processor 112 1 .
  • a programmable network processor 200 receives network data elements from network line module ingress port 108 via input interface 206 .
  • Input interface 206 receives the network data elements and provides them to multiprocessor core 202 for processing as described above.
  • Multiprocessor core 202 processes the network data elements and provides the result to output interface 208 .
  • Output interface 208 receives processed network data elements from multiprocessor core 202 and forwards them to switch fabric 106 for routing.
  • Multiprocessor core 202 accesses storage located off programmable network processor 200 via memory controller 204 .
  • Multiprocessor core 202 is connected to host control processor 210 .
  • Host control processor 210 provides network management logic and information for programmable network processor 200 .
  • Such network management logic and information includes, for example, generating and receiving network data elements for controlling switch fabric 106 , network line modules 104 1 – 104 N and other network components.
  • Host control processor 210 performs other functions, such as generating network data elements for switch fabric control, setting up network connections and loading programs into multiprocessor core 202 for operation.
  • FIG. 3 illustrates a system block diagram of a multiprocessor core, according to an embodiment of the present invention.
  • Multiprocessor core 300 is an exemplary embodiment of multiprocessor core 202 , as described above. Although multiprocessor core 300 can be used for a generic form of data processing, multiprocessor core 300 can also be of the type employed in data communications system 100 .
  • Multiprocessor core 300 includes processing elements (PE) 302 1 – 302 N , data memories (DM) 304 1 – 304 N , program memories (PM) 306 1 – 306 N , intraswitch 314 , and host control interface 308 . Processing elements 302 1 – 302 N are connected to program memories 306 1 – 306 N , and intraswitch 314 .
  • PE processing elements
  • DM data memories
  • PM program memories
  • Data memories 304 1 – 304 N are connected to intraswitch 314 .
  • Program memories 306 1 – 306 N are connected to processing elements 302 1 – 302 N and intraswitch 314 .
  • Host control interface 308 is connected to intraswitch 314 .
  • Intraswitch 314 is connected to on-chip peripheral units 310 and 312 . Examples of on-chip peripheral units 310 and 312 are input interface 206 , output interface 208 , and memory controller 204 of FIG. 2 .
  • Processing elements 302 1 – 302 N process network data elements, thereby providing the processing functionality for multiprocessor core 300 .
  • Processing elements 302 1 – 302 N execute program instructions from program memories 306 1 – 306 N , and load and store data in data memories 304 1 – 304 N .
  • Each of processing elements 302 1 – 302 N can process multiple threads of instructions concurrently, according to an embodiment of the present invention.
  • Program memories 306 1 – 306 N and data memories 304 1 – 304 N provide data storage functionality for the various elements of multiprocessor core 300 .
  • Program memories 306 1 – 306 N store program instructions for the processing of network data elements by processing elements 302 1 – 302 N .
  • FIG. 3 depicts groups of four processing elements directly connected to one of program memories 306 1 – 306 N , other configurations connecting program memory to processing elements are possible, including for example, additional processing elements or program memories as would be apparent.
  • Data memories 304 1 – 304 N provide on-chip storage for data, such as intermediate-results data from processing network data elements, for the operation of processing elements 302 1 – 302 N .
  • Intraswitch 314 enables communication between the various components of multiprocessor core 300 .
  • processing elements 302 1 – 302 N access data memories 304 1 – 304 N through intraswitch 314 .
  • Intraswitch 314 can be, for example, a switching fabric in multiprocessor core 300 , or individual trace connections in multiprocessor core 300 .
  • Host control interface 308 connects multiprocessor core 300 to host control processor 210 .
  • Multiprocessor core 300 is connected to on-chip peripheral units 310 and 312 via intraswitch 314 .
  • multiprocessor core 300 receives network data elements from on-chip peripheral units 310 and 312 .
  • Processing elements 302 1 – 302 N receive the network data elements and process them according to the programs stored as instructions in program memories 306 1 – 306 N .
  • the intermediate results and final results of the processing operations are stored in data memories 304 1 – 304 N .
  • FIG. 4 illustrates a system block diagram of an exemplary processing element, according to an embodiment of the present invention.
  • Processing element 400 is an example of one of the processing elements shown in FIG. 3 , and can be employed in a generic form of data processing or can be of the type that is employed in data communications system 100 .
  • exemplary processing element 400 is an instruction-level parallel processing element, in which two or more threads of parallel programs execute concurrently. Processing element 400 can, therefore, maintain a high utilization under conditions where the processing element would otherwise idle waiting for long-latency operations to complete. Note that processing element 400 is provided for illustrative purposes only and that other processing element configurations are possible.
  • Processing element 400 includes instruction fetch unit 402 , instruction buffers 404 A, 404 B, 404 C, and 404 D. Processing element 400 also includes function decode and execution switch 406 , dependency counters 410 , instruction issue control 408 , memory/peripheral interface unit 4 ; 2 412, primary function unit 414 , auxiliary function unit 416 , and register file 418 . Note that although dependency counters 410 are shown as being part of instruction issue control 408 , other configurations are possible. For example, dependency counters 410 can also be connected to, but not part of, instruction issue control 408 .
  • Instruction fetch unit 402 is connected to each of instruction buffers 404 A– 404 D. Each of the connections between fetch unit 402 and instruction buffers 404 A– 404 D provides a path for instructions from a program thread. Instruction buffers 404 A– 404 D are, in turn, connected to function decode and execution switch 406 . Instruction buffers 404 A– 404 D are also connected to instruction issue control 408 . Instruction issue control 408 is connected to function decode and execution switch 406 . Function decode and execution switch 406 is connected to memory peripheral interface unit 412 , primary function unit 414 , and auxiliary function unit 416 .
  • Memory peripheral interface unit 412 , primary function unit 414 , and auxiliary function unit 416 are also referred to herein as execution units 412 – 416 .
  • Memory peripheral interface unit is connected to intraswitch 314 , and register file 418 .
  • Primary function unit 414 is connected to register file 418 .
  • Auxiliary function unit 416 is connected to register file 418 .
  • Register file 418 includes read ports 420 and write port 422 .
  • Read ports 420 allow execution units 412 – 416 to read data from the various registers in register file 418 .
  • Write port 422 allows execution units 412 – 416 to write data to register file 418 .
  • Exemplary processing element 400 is shown as supporting four concurrent threads of instructions.
  • Instruction fetch unit 402 fetches instructions from program memory 306 .
  • the instructions are entered in the four instruction buffers 404 A– 404 D according to the program thread they belong to.
  • Each of instruction buffers 404 A– 404 D is associated with one of four threads.
  • thread 0 (T 0 ) with instruction buffer 404 A
  • thread 1 (T 1 ) with instruction buffer 404 B
  • thread 2 (T 2 ) with instruction buffer 404 C thread 3 (T 3 ) with instruction buffer 404 D
  • Function decode and execution switch 406 receives the instructions associated with the four threads from instruction buffers 404 A– 404 D. Function decode and execution switch 406 provides the instructions to execution units 412 – 416 .
  • FIG. 5 is a diagram illustrating concurrent processing of three threads of instructions.
  • Instruction processing diagram 500 illustrates the problem of instruction synchronization between multiple threads.
  • the instructions of one thread can be dependent on the results of instructions in another thread. For example, the contents of a register that is set by a first instruction in one thread can be used by a second instruction in another thread. In such a case, if the first instruction is not executed before the second instruction, the register will not include data valid for the execution of the first second instruction.
  • synchronization problems may result in a program execution error.
  • Instruction processing diagram 500 shows three threads of instructions, thread 502 , thread 504 , and thread 506 .
  • Threads 502 – 506 can be of the type employed in a generic form of data processing or can be of the type that are employed in data communications system 100 . Note that three threads are shown for descriptive clarity only, and other configurations are possible.
  • a processing element can process as few as two threads, and as many threads as is accommodated by a processing element architecture. For example, processing element 400 accommodates four concurrent threads of instructions.
  • Threads 502 – 506 is shown including two instructions.
  • Thread 502 includes instruction 508 (i 1 ) and instruction 510 (i 2 ).
  • Thread 504 includes instruction 512 (i 3 ) and instruction 514 (i 4 ).
  • Thread 506 includes instruction 516 (i 5 ) and instruction 518 (i 6 ).
  • instruction processing diagram 500 shows two instructions per thread for descriptive clarity only, and other configurations are possible.
  • each of threads 502 – 506 can include additional instructions (not shown) before the first instruction (e.g., instruction 508 in thread 502 ), between the first and second instruction (e.g., instructions 508 and 510 in thread 502 ), and after the second instruction (e.g., instruction 510 in thread 502 ).
  • Threads 502 – 506 can include as many instructions as are required to perform generic data processing or perform processing for data communications system 100 .
  • Instruction processing diagram 500 shows instruction execution proceeding from left to right, and the relative spacing of instructions indicates when an instruction is being executed.
  • instruction processing diagram 500 shows instruction 508 is executed before instruction 510 of thread 502 .
  • the processing element executes instruction 508 of thread 502 before instruction 512 of thread 504 , and instruction 512 before instruction 516 of thread 506 .
  • instruction processing diagram 500 shows the dependency between the instructions of threads 502 – 506 .
  • Dependency is when the execution of a second instruction is conditional on the execution of a first instruction.
  • a first instruction in a first thread writes a value to a register file, such as register file 418
  • a second instruction in a second thread subsequently reads the value from the register file and uses the value as an operand in a calculation.
  • the first instruction is referred to as the dependee instruction
  • the second instruction is referred to as the dependent instruction.
  • a dependent instruction is an instruction that must not be executed before the instruction on which it depends.
  • a dependee instruction is an instruction on which a dependent instruction depends. As long as the dependee instruction is executed before the dependent instruction, the register file includes the correct value for the execution of the dependent instruction.
  • Depends indicators 520 – 526 are used to show dependencies between the instructions of threads 502 – 506 .
  • Depends indicators are drawn from a dependent instruction to a dependee instruction (i.e., the arrow of the depends indicator points to the dependee instruction).
  • Depends indicator 520 indicates that the execution of instruction 512 depends on the execution of instruction 508 .
  • Depends indicator 522 indicates that the execution of instruction of 510 depends on the execution of instruction 514 .
  • Depends indicator 524 indicates that the execution of instruction 516 depends on the execution of instruction 510 .
  • Depends indicator 526 indicates that the execution of instruction 518 is dependent on the execution of instruction 514 .
  • Instruction processing diagram 500 shows instruction 512 and instruction 516 dependent on earlier executed instructions. Program errors may occur, however, if a first instruction depends on a later executed instruction. Instruction processing diagram 500 shows the synchronization problem as instruction 510 depending on a later executed instruction. As such, it is important for a processing element to synchronize the execution order of dependent and dependee instructions between threads to avoid such program errors.
  • the present invention provides a system and method that maintains the order of instruction execution between threads.
  • a processing element processes multiple threads of instructions. Instructions in the threads can include dependence indicators that indicate dependencies between instructions and threads.
  • the processing element encounters instructions that include dependence indicators identifying a dependent instruction or thread, it checks, decrements, or increments one or more dependency counters. If the dependency counter is not above a threshold, it indicates that a dependency has not been satisfied, and the processing element can suspend the execution of a thread until the dependency counter is incremented to above the threshold. This allows the processing element to maintain a form of synchronized execution of dependent instructions between threads.
  • instructions can include the dependence indicators as bits, called “depends” bits and “tells” bits.
  • a depends bit is an indicator in a dependent instruction that a particular other thread includes an instruction on which this one depends.
  • a tells bit is an indicator in a dependee instruction that a particular other thread includes an instruction dependent on this one.
  • the additional bits can be included with the instruction in a number of ways. For example, a compiler for instruction-level parallel processors can include the bits at compile time based on dependencies, or a programmer may specify the instruction execution order by including “depends” and “tells” bits when coding, etc.
  • each of the instructions in the four threads can include depends bits and tells bits.
  • each instruction in a thread can include three depends bits, each of which indicates that the instruction is dependent on one of the other three threads.
  • each instruction in a thread can include three tells bits, each of which indicates that one of the other three threads depends on the execution of the instruction.
  • the processing element can include four groups of dependency counters, each of which is associated with one of the four threads.
  • Each of the groups of dependency counters includes three individual dependency counters, each of which is associated with one of the other three threads. For instance, consider four exemplary threads, thread 0 , thread 1 , thread 2 , and thread 3 , each having an associated group of dependency counters.
  • the exemplary group of dependency counters associated with thread 0 includes three individual dependency counters, each of which is associated with one of thread 1 , thread 2 , or thread 3 .
  • the exemplary processing element processes the instructions of the four threads.
  • the exemplary processing element encounters an instruction in a first thread that includes a tells bit identifying a second thread (i.e., one of the other three threads)
  • the exemplary processing element increments the dependency counter associated with the first thread of the group of dependency counters associated with the second thread.
  • the processing element checks the dependency counter associated with the second thread of the group of dependency counters associated with the first thread to determine whether the instruction can be executed. If the value of the exemplary dependency counter is above a threshold (e.g., non-zero), the processing element executes the instruction. If, on the other hand, the value of the exemplary dependency counter is below a threshold, processing of the first thread is inhibited. The processing element increments the dependency counter when instructions including tells bits in the second thread are executed, and processing the first thread is resumed once the dependency counter is above the threshold.
  • a threshold e.g., non-zero
  • the processing element increments the dependency counter when instructions including tells bits in the second thread are executed, and processing the first thread is resumed once the dependency counter is above the threshold.
  • an instruction can include multiple dependency indicators, such as one or more tells bits in combination with one or more depends bits. When an instruction includes more than one depends bit, the associated dependency counters must be above the threshold before the instruction is executed.
  • the threshold is a dependency counter value chosen to ensure that dependent instructions are not executed before the instructions in other threads on which they depend.
  • the threshold value can be set to ensure correct instruction level synchronization.
  • the threshold can be chosen to be zero, so that a dependency counter must be incremented before a dependent instruction can be executed, as is described in further detail, below.
  • Network data element processing is often repetitive and predictable. As such, a programmer, or compiler, can determine that value at which the threshold can be set. Note that although one embodiment of the present invention is explained in terms of a “threshold,” “above a threshold,” and “not above a threshold,” other configurations that record dependency between instructions and threads are possible. For example, in an alternate embodiment, the processing element can suspend processing a thread if a dependency counter falls below a threshold.
  • depends bits, tells bits, and dependency counters are used to record the satisfaction of dependencies between instructions in a first thread and the processing of a second thread. This is in contrast to instruction processing diagram 500 of FIG. 5 that shows dependencies between individual instructions. It is sufficient to record dependency at this level because the present invention provides a system and method that ensures that dependent instructions are executed after the instructions on which they depend.
  • instruction 512 would include a depends bit identifying instruction 512 as dependent upon instructions in thread 502 .
  • the depends bit identifies the thread that includes the instruction on which instruction 512 is dependent, which is, in this case, thread 502 .
  • the depends bits can identify the type or particular one of the instructions in thread 502 .
  • the instruction can include more bits (i.e., more information) that identify instruction characteristics (such as type, priority, etc.).
  • depends bits and tells bits are described herein as identifying threads, and not instructions.
  • instruction 508 would include a tells bit that identifies thread 504 as including an instruction or instructions that are dependent upon the execution of instruction 508 .
  • instruction 510 would include a tells bit identifying thread 506 as including instructions dependent upon the execution of instruction 510 .
  • Instruction 510 would also include a depends bit identifying instruction 510 as dependent on the execution of instructions in thread 504 .
  • Instruction 514 would include a tells bit identifying thread 502 as including instructions that are dependent on the execution of instruction 514 .
  • Instruction 514 also would include a tells bit identifying thread 506 as including instructions dependent on the execution of instruction 514 .
  • Instruction 516 would include a bit identifying instruction 516 as dependent on instructions in thread 502 .
  • Instruction 518 would include a depends bit identifying instruction 518 as dependent on the execution of instructions in thread 504 .
  • FIG. 8 illustrates an exemplary instruction, according to an embodiment of the present invention.
  • Instruction 800 includes opcode 802 , source 0804 0 804, source 1806 1 806, result 808 , depends bit 810 , depends bit 812 , depends bit 814 , tells bit 816 , tells bit 818 , and tells bit 820 .
  • Opcode 802 is the operator for instruction 800 .
  • Source 0804 0 804 specifies a first operand operated upon by opcode 802 .
  • Source 1806 1 806 specifies a second operand operated upon by opcode 802 .
  • Result 808 identifies a register to which the results of opcode 1302 are stored.
  • Depends bits 810 – 814 indicate that instruction 800 depends upon the execution of instructions in other threads.
  • Instruction 800 is configured for a processing element that supports the operation of four threads. Note that although instruction 800 includes three depends bits which identify three other threads, and three tells bits, which also identify three other threads, other configurations are possible. By adding additional bits or changing how the bits are used, instruction 800 can be configured for a processing element that supports more than four threads.
  • depend bits 810 – 814 can represent up to eight other threads, extending instruction 800 to a processing element supporting nine threads.
  • additional depends and tells bits can be added as is necessary for a given processing element architecture.
  • instruction 800 is executing in thread 1 . If instruction 800 is executing in thread 1 , the other three threads on which the execution of instruction 800 may depend are thread 0 , thread 2 , and thread 3 .
  • depends bit 810 can identify instruction 800 as dependent on thread 0
  • depends bit 812 can identify instruction 800 as dependent on thread 2
  • depends bid 814 can identify instruction 800 as dependent on thread 3 .
  • tells bit 816 can identify thread 0 as dependent on instruction 800 .
  • Tells bit 818 can identify thread 2 as dependent on instruction 800 .
  • Tells bit 820 can identify thread 3 as dependent on instruction 800 .
  • dependency counter groups are a set of dependency counters associated with each thread.
  • Each of threads 502 – 506 of instruction processing diagram 500 would have, or be associated with, a dependency counter group.
  • Each dependency counter group could include a number of individual dependency counters, each of which is associated with one of the other threads executing on the processing element.
  • the dependency counter group associated with thread 502 of instruction processing diagram 500 would include two dependency counters, one related to, or associated with, thread 504 , and one related to, or associated with, thread 506 .
  • FIG. 7 illustrates exemplary dependency counter groups, according to an embodiment of the present invention.
  • FIG. 7 shows four dependency counter groups, each of which is associated with one of four threads.
  • Dependency counter group 702 (T 0 ) is associated with thread 0
  • dependency counter group 704 (T 1 ) is associated with thread 1
  • dependency counter group 706 (T 2 ) is associated with thread 2
  • dependency counter group 708 (T 3 ) is associated with thread 3 .
  • Each of dependency counter groups 702 – 708 includes three dependency counters, each of which is associated with one of the other three threads.
  • Dependency counter group 702 includes dependency counter T 0 1 , dependency counter T 0 2 , and dependency counter T 0 3 .
  • Dependency counter T 0 1 is that dependency counter of thread 0 that is related to, or associated with, thread 1 .
  • dependency counter T 0 2 and dependency counter T 0 3 are thread 0 dependency counters associated with, or related to, threads 2 and 3 , respectively.
  • dependency counter group 704 includes dependency counter T 1 0 , dependency counter T 1 2 , and dependency counter T 1 3 .
  • Dependency counter T 1 0 is associated with thread 0
  • dependency counter T 1 2 is associated with thread 2
  • dependency counter T 1 3 is associated with thread 3 .
  • dependency counter group 706 includes dependency counter T 2 0 , dependency counter T 2 1 , and dependency counter T 2 3 .
  • Dependency counter T 2 0 is associated with thread 0
  • dependency counter T 2 1 is associated with thread 1
  • dependency counter T 1 3 is associated with thread 3
  • Dependency counter group 708 includes dependency counter T 3 0 , dependency counter T 3 1 , and dependency counter T 3 2 .
  • Dependency counter T 3 0 is associated with thread 0
  • dependency counter T 3 1 is associated with thread 1
  • dependency counter T 3 2 is associated with thread 2 .
  • dependency counter groups 702 – 708 can include more or fewer dependency counters, depending on the processing element architecture.
  • a bi-state element associated with a first thread can be set when a corresponding dependee instruction in a second thread is executed, and reset when the dependent instruction is executed.
  • a processing element suspends processing the first thread when it encounters an instruction including a depends bit if the bi-state element is not set.
  • tri-state elements, and other state retaining elements can be set and reset by the processing element. In this embodiment, however, care should be taken to avoid overflowing the state elements. For example, a bi-state element may be incremented, or changed, only once in response to an instruction that includes a tells bit.
  • the implementation of the present invention should account for the size of the dependency counters to avoid overflow.
  • Dependency counters should be specified large enough to ensure that overflow will never occur, or limits should be set on the number of times a dependency counter can be incremented. For example, a first thread that includes many instructions that include tells bits identifying a second thread can be suspended once the dependency counter associated with the second thread has reached a limit. The limit can ensure that the dependency counter does not overflow, and can also ensure that a dependee thread does not get too far ahead of a dependent thread.
  • a tells bit affects one or more dependency counters of the threads other than the one on which the tells bit appears.
  • a depends bit affects one or more dependency counters of the thread on which the depends bit appears.
  • the processing element increments the particular dependency counter in dependency counter group 702 associated with thread 1 .
  • dependency counter T 0 1 is associated with thread 1 .
  • the processing element increments T 0 1 of dependency counter group 704 when the thread 1 instruction tells bit is detected.
  • the dependency counters are checked, and the processing element either suspends the dependent thread or executes the instruction and decrements the associated dependency counter.
  • thread 1 can include an instruction that includes a depends bit that identifies the instruction as depending on the execution of thread 0 .
  • the dependency counter associated with thread 0 of the dependency counter group associated with the thread 1 is checked.
  • dependency counter T 1 0 of dependency counter group 704 is associated with thread T 0 .
  • the processing element either suspends processing thread 1 or both decrements T 1 0 and continues processing the thread 1 , thereby executing the instruction. Once suspended, the processing element resumes processing thread 1 when dependency counter T 1 0 is incremented by the processing element (i.e., when an instruction in thread 0 with a tells bit is executed).
  • FIG. 6 illustrates concurrent processing of two threads of instructions, according to an embodiment of the present invention.
  • Thread synchronization diagram 600 shows thread 602 and thread 604 as a series of processing steps.
  • a processing step is an action or actions performed by a processing element in the implementation of one embodiment of the present invention.
  • a processing step can be, for example, the execution of an instruction, incrementing a dependency counter, decrementing a dependency counter, etc.
  • Thread 602 includes processing step 606 , processing step 608 , processing step 610 , processing step 612 , processing step 614 , and processing step 616 .
  • Thread 604 includes processing step 618 , processing step 620 , and processing step 622 .
  • synchronization diagram 600 only shows two threads of instructions, other configurations are possible.
  • the system and method of the present invention can be extended to three, four, and more than four threads, as described above.
  • thread synchronization diagram 600 For the purpose of descriptive clarity, the instructions of thread synchronization diagram 600 are referred to as instruction 508 (i 1 ), instruction 510 (i 2 ), instruction 512 (i 3 ), and instruction 514 (i 4 ). Note, however, that instruction processing diagram 500 shows instruction 512 as dependent on instruction 508 , and shows instruction 510 as dependent on instruction 514 .
  • Thread synchronization diagram 600 shows the instructions of thread 602 dependent on the execution of instructions in thread 604 generally, and the instructions of thread 604 dependent on the execution of instructions in thread 602 generally.
  • instruction processing diagram 500 The dependencies between instructions 508 – 514 shown in instruction processing diagram 500 are implemented in the operation of one embodiment of the present invention through the general dependency of instructions within one thread on the processing of another thread (i.e., rather than particular instructions). This concept is illustrated in further detail below.
  • thread synchronization diagram 600 shows tells bits 624 and 630 and depends bit 626 and 628 as arrows pointing from processing steps to the threads that the bits identify.
  • the arrows are shown to indicate that an instruction being processed in a processing step includes a tells bit or depends bit, and identifies the thread to which the bit points. Either the thread pointed to depends on the instruction (i.e., tells bit), or the instruction depends on the thread (i.e., depends bit).
  • tells bit 624 identifies thread 604 as dependent on instruction 508 of processing step 606 .
  • depends bit 626 identifies instruction 512 of processing step 618 as dependent on thread 602 .
  • Processing of thread 602 and thread 604 begins when the processing element executes instruction 508 , in processing step 606 .
  • Instruction 508 includes tells bit 624 that identifies thread 604 as dependent on instruction 508 .
  • the processing element detects tells bit 624 and increments a dependency counter in a dependency counter group 704 associated with thread T 1 , 604 .
  • a dependency counter group is associated with a thread, and the dependency counter group includes dependency counters, each of which is associated with one of the other threads executing on the processing element.
  • Thread synchronization diagram 600 is described in terms of dependency counter group 702 (associated with thread 602 ) and dependency counter group 704 (associated with thread 604 ).
  • Dependency counter T 10 T1 0 of dependency counter group 704 is associated with thread 602
  • dependency counter T 0 is associated with thread 602 .
  • the processing element receives instruction 512 , in processing step 618 .
  • Instruction 512 includes depends bit 626 identifying instruction 512 as dependent on the execution of instructions in thread 602 .
  • the processing element determines if dependency counter T 1 0 is above a predefined threshold. For the purposes of explanation, dependency counter T 1 0 is assumed to have been above, or at the threshold, so that it is above the threshold after being incremented. Since the processing element has incremented dependency counter T 1 0 , when the dependency counter is checked in response to instruction 512 , the processing element determines that dependency counter T 1 0 is above the threshold.
  • dependency counter T 1 0 is above the threshold, the processing element continues processing instruction 512 , at processing step 620 .
  • the processing element executes instruction 512 and decrements dependency counter T 1 0 .
  • the processing element processes thread 602 in processing step 608 .
  • the processing element receives instruction 510 from program memory.
  • Instruction 510 includes depends bit 628 , which identifies instruction 510 as dependent on the execution of instructions in thread 604 .
  • the processing element checks the dependency counter group of thread 602 , particularly the dependency counter related to thread 604 , in response to detecting depends bit 628 . This corresponds to dependency counter T 0 1 .
  • the value can be, for example, zero, or some other number representing a predetermined threshold. For exemplary purposes, however, dependency counter T 0 1 is defined as having a value of the predetermined threshold.
  • dependency counter T 0 1 indicates that instructions in thread 604 upon which instruction 510 depends, have not yet been executed.
  • the processing element suspends execution of thread 602 in processing step 610 .
  • the processing element continues processing thread 604 .
  • the processing element receives instruction 514 in processing step 622 .
  • Instruction 514 includes tells bit 630 that identifies thread 602 as including instructions dependent on instruction 514 .
  • the processing element increments that dependency counter of the thread 602 dependency counter group that is related to thread 604 (namely, dependency counter T 0 1 ) in response to detecting tells bit 630 , and executes instruction 514 , in processing step 622 .
  • dependency counter T 0 1 dependency counter
  • the order of executing the instruction and incrementing or decrementing dependency counters is chosen for illustrative purposes only, and the same outcome can be achieved with reversed order.
  • the processing element detects that dependency counter T 0 1 has been incremented to above the threshold, in processing step 612 . As such, the processing element resumes processing thread 602 at instruction 510 in processing step 614 . After resuming processing thread 602 , the processing element executes instruction 510 , decrements dependency counter T 0 1 , and continues processing the instructions of thread 602 , in step 616 . Note that in the example of FIG. 6 , dependency counter T 0 1 is now equal to the threshold value, and any additional instructions in thread 602 that include depends bits identifying thread 604 will cause the processing element to suspend execution of the thread (absent prior instructions in thread 604 with tells bits identifying thread 602 ).
  • thread synchronization diagram 600 begins in processing step 606 .
  • thread 602 is associated with instruction buffer 404 A
  • thread 604 is associated with instruction buffer 404 B.
  • instruction fetch unit 402 fetches program instructions from program memory 306 .
  • Instruction fetch unit 402 distributes the instructions associated with the four threads to one of instruction buffers 404 A, 404 B, 404 C, or 404 D.
  • each of instruction buffers 404 A– 404 D is associated with a particular thread.
  • Instruction issue control 408 detects the presence of depends bits such as depends bits 810 – 814 or the presence of tells bits, such as tells bits 816 – 820 included in instructions in instruction buffers 404 A– 404 D. Based on presence or absence of depends bits and tells bits in the instruction, instruction issue control 408 controls function decode and execution switch 406 . Based on signals from instruction issue control 408 , function decode and execution switch 406 issues instructions from instruction buffers 404 A– 404 D to one of execution units 412 – 416 (i.e., memory peripheral interface unit 412 , primary function unit 414 , or auxiliary function unit 416 ).
  • execution units 412 – 416 i.e., memory peripheral interface unit 412 , primary function unit 414 , or auxiliary function unit 416 .
  • instruction 508 is received in instruction buffer 404 A.
  • Instruction issue control 408 detects the presence of tells bit 624 in instruction 508 .
  • instruction issue control increments one of the dependency counters in dependency counters 410 .
  • instruction issue control 408 increments dependency counter T 1 0 .
  • Instruction issue control 408 then causes function decode and execution switch 406 to provide instruction 508 to one of execution units 412 – 416 for execution.
  • processing element 400 is also processing thread 604 .
  • Instruction buffer 404 B receives instruction 512 , in processing step 618 .
  • Instruction issue control 408 detects the existence of depends bit 626 in instruction 512 .
  • Depends bit 626 identifies instruction 512 as dependent on instructions in thread 602 .
  • instruction issue control 408 checks dependency counter T 1 0 in processing step 618 . Since dependency counter T 1 0 is above the threshold (as described above), instruction issue control 408 enables function decode and execution switch 406 to provide instruction 512 to one of execution units 412 – 416 for execution. Additionally, instruction issue control decrements dependency counter T 1 0 in dependency counters 410 .
  • processing element 400 receives instruction 510 in processing step 608 .
  • Instruction issue control 408 detects the existence of depends bit 628 in instruction buffer 404 A. Depends bit 628 identifies instruction 510 as dependent on instructions in thread 604 .
  • instruction issue control 408 checks dependency counter T 0 1 in dependency counters 410 . In this particular example, dependency counter T 0 1 is equal to the threshold necessary to continue processing instruction 510 . Since dependency counter T 0 1 is not above the threshold, instruction issue control 408 suspends execution of thread 602 by holding instruction 510 in function decode and execution switch 406 .
  • Processing element 400 continues processing thread 604 , and receives instruction 514 in processing step 622 .
  • Instruction 514 includes tells bit 630 identifying thread 602 as dependent on the execution of instruction 514 .
  • Instruction issue control 408 increments dependency counter T 0 1 in response to detecting tells bit 630 , in processing step 622 .
  • Instruction issue control 408 causes function decode and execution switch 406 to send instruction 514 to one of execution units 412 – 416 for execution. After dependency counter T 0 1 has been incremented in processing step 622 , instruction issue control 408 detects that dependency counter T 0 1 has been incremented. Instruction issue control 408 checks dependency counter T 0 1 to determine if it is above the threshold.
  • instruction issue control 408 determines that dependency counter T 0 1 is above the threshold, in processing step 612 . In response to detecting dependency counter T 0 1 above the threshold, instruction issue control 408 resumes processing thread 602 by issuing instruction 510 to one of execution units 412 – 416 , in processing step 614 . Instruction 510 is executed, and instruction issue control 408 decrements dependency counter T 0 1 in processing step 616 .
  • FIG. 9 illustrates a process for executing instructions, according to an embodiment of the present invention.
  • a processing element receives an instruction in a first thread, in step 904 .
  • the processing element determines if the execution of the instruction in the first thread is dependent on the execution of instructions in a second thread.
  • method 900 ends in step 916 .
  • step 908 the processing element examines a dependency counter group that includes a dependency counter associated with the second thread.
  • step 910 the processing element determines whether the dependency counter includes a value above a threshold. If the dependency counter includes a value above a threshold, method 900 continues in step 914 . In step 914 , the processing element executes the first thread instruction and decrements the dependency counter.
  • step 912 the processing element suspends execution of the first thread until the dependency counter is incremented to above a threshold. Once the dependency counter is incremented to above a threshold, processing the first thread resumes, method 900 continues in step 914 .
  • step 914 the processing element executes the first thread instruction.
  • FIG. 10 illustrates an exemplary process for executing instructions, according to an embodiment of the present invention.
  • a processing element receives a first thread instruction, in step 1004 .
  • the processing element determines whether a second thread is dependent on the first thread instruction, in step 1006 .
  • step 1008 the processing element increments a dependency counter included in a dependency counter group associated with the second thread. After the dependency counter is incremented, the processing element executes the first thread instruction, in step 1010 .
  • step 1010 the processing element executes the first thread instruction.
  • step 1010 After step 1010 , method 1000 ends in step 1012 .
  • the present invention provides a system and method for high speed processing of network data elements.
  • a network line module such as network line module 104 1 , receives network data elements from a network or switch fabric via a network line module ingress port.
  • the network line module provides the network data elements to a multiprocessor core.
  • the received network data elements are distributed to multiple processing elements within the multiprocessor core for processing according to a program.
  • the processing elements process the network data elements according to program instructions stored in program memory. Each of the processing elements uses instruction-level parallelism to process multiple threads of instructions concurrently. Instruction execution is synchronized by recording dependencies between instructions and threads. Instructions in the threads can include dependence indicators identifying dependencies between instructions and threads. When a processing element encounters an instruction that includes dependence indicators identifying a dependent instruction or thread, the processing element checks, decrements, or increments one or more dependency counters that records dependency between instructions and threads. If an instruction in a first thread is dependent upon the execution of instructions in a second thread, a dependency counter is checked. If the dependency counter is not above a predetermined threshold, the processing element suspends the execution of the first thread until the dependency counter is incremented by the second thread to above the threshold.
  • the multiprocessor core After processing, the multiprocessor core provides processed network data elements to the network line module.
  • the network line module provides the processed network data element to an egress port connected to a network or switch fabric.

Abstract

A system and method process data elements with instruction-level parallelism. An instruction buffer holds a first instruction and a second instruction, the first instruction being associated with a first thread, and the second instruction being associated with a second thread. A dependency counter counts satisfaction of dependencies of instructions of the second thread on instructions of the first thread. An instruction control unit is coupled to the instruction buffer and the dependency counter, the instruction control unit increments and decrements the dependency counter according to dependency information included in instructions. An execution switch is coupled to the instruction control unit and the instruction buffer, and the execution switch routes instructions to instruction execution units.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS
The present invention is related to patent applications “System And Method For Processing Overlapping Tasks In A Programmable Network Processor Environment” (Ser. No. 09/833,581) and “System and Method for Data Forwarding in a Programmable Multiple Network Processor Environment” (Ser. No. 09/833,578), both of which are incorporated herein by reference.
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates generally to digital computing. More specifically, the present invention relates to network processors for processing network data elements.
2. Discussion of the Related Art
Network switches and routers, or network switch elements, form the backbone of digital networks, such as the Internet. Network switch elements connect network segments by receiving network data from ingress network segments and transferring the network data to egress network segments. Because large telecommunications switching facilities and central offices aggregate network traffic from extensive networks and many network segments, they require high-speed and high-availability switches and routers.
Network switch elements select the egress network segment by processing the address or destination included in the network data according to network data processing program logic. Traditionally, network switch elements included Application Specific Integrated Circuits (ASICs) that provided the program logic. Because ASICs are “hard-coded” with program logic for handling network traffic, they provide the high speed necessary to process a large volume of network data. ASICs, however, make it difficult to upgrade or reconfigure a network switch element, and it is expensive to design and fabricate a new ASIC for each new type of network rig switch element.
In response to these drawbacks, manufacturers of network switch elements are turning to programmable network processors to enable network switch elements to process network data. Programmable network processors process network data according to program instructions, or software, stored in a memory. The software allows manufacturers and users to define the functionality of the network switch elements-functionality that can be altered and changed as needed. With programmable network processors, manufacturers and users can change the software to respond to new services quickly, without costly system upgrades, as well as implement new designs quickly.
To the extent that there is a drawback to the use of programmable network processors in network switch elements, that drawback relates to speed. Because programmable network processors process network data using software, they are usually slower than a comparable hard-coded ASIC. One of the major design challenges, therefore, is developing programmable network processors fast enough to process the large volume of network data at large telecommunications switching facilities.
One technique used to increase speed in traditional processor design is “instruction-level parallelism,” or processing multiple threads of instructions on a processing element in parallel. However, traditional instruction-level parallelism techniques are either highly complex, or would introduce unacceptable delays and timing problems into the processing of network data, which must be processed on a time critical basis.
SUMMARY OF THE INVENTION
The present invention provides a system and method for processing information using instruction-level parallelism. In the system, an instruction buffer holds a first instruction and a second instruction, the first instruction being associated with a first thread, and the second instruction being associated with a second thread. In this system, one or more instructions from the second thread may be dependent on the execution of one or more instructions in the first thread. A dependency counter is used to record dependencies of instructions between the first thread and the second thread. An instruction control unit is coupled to the instruction buffer and the dependency counter, the instruction control unit increments and decrements the dependency counter on the basis of information in the instructions. An execution switch is coupled to the instruction control unit and the instruction buffer, the execution switch sends instructions to an execution unit.
In the method, a first instruction associated with a first thread is loaded on a processing element. The processing element determines that execution of a second instruction depends on the execution of the first instruction, where the second instruction is associated with a second thread. A dependency counter associated with the second thread is incremented if the processing element determines that execution of a second instruction depends on the execution of the first instruction.
BRIEF DESCRIPTION OF THE DRAWINGS
The present invention is described with reference to the accompanying drawings. In the drawings, like reference numbers indicate identical or functionally similar elements. Additionally, the left-most digit(s) of a reference number identifies the drawing in which the reference number first appears.
FIG. 1 illustrates a system block diagram of a data communications system.
FIG. 2 illustrates a system block diagram of a programmable network processor.
FIG. 3 illustrates a system block diagram of a multiprocessor core.
FIG. 4 illustrates a system block diagram of an exemplary processing element.
FIG. 5 is a diagram illustrating concurrent processing of three threads of instructions.
FIG. 6 illustrates concurrent processing of two threads of instructions.
FIG. 7 illustrates dependency counter groups.
FIG. 8 illustrates an exemplary instruction.
FIG. 9 illustrates an exemplary process for executing instructions.
FIG. 10 illustrates an exemplary process for executing instructions
DETAILED DESCRIPTION
Exemplary embodiments of the invention are discussed in detail below. While specific implementations are discussed, it should be understood that this is done for illustrative purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without parting from the spirit and scope of the invention.
Programmable network processors offer a number of advantages including flexibility, low cost, maintenance ease, decreased time to market, and increased service life. It is difficult, however, to develop a programmable network processor capable of meeting the demand for ever-increasing speed. One technique for increasing the speed of a programmable network processor is instruction-level parallelism. In instruction-level parallelism, threads of parallel programs can execute concurrently on a single processing element. Instruction-level parallelism allows a processing element to continue processing instructions, even if one or more threads are waiting for long-latency operations to complete.
One problem with instruction-level parallelism is maintaining synchronization of dependent instructions between the threads running on a processing element. Often, an instruction in one thread is dependent on the execution of instructions in another thread. Examples of instruction dependency are control dependency (i.e., the execution of one instruction is conditioned on the execution of another) and data dependency (i.e., one instruction uses the results of the execution of another instruction). Unfortunately, conventional techniques for synchronizing the execution of instructions among multiple threads do not lend themselves to programmable network processor applications. Conventional techniques introduce significant delays to processing, delays that are unsuitable for processing time critical network data elements.
The present invention is directed to a system and method for synchronizing the execution of multiple threads of instructions on a single processing element at high speed. An instruction in a first thread can include dependence indicators, such as a bit or bits, that indicate dependence of the instruction on the execution of a second thread. When a processing element encounters an instruction that includes dependence indicators that indicate dependence between threads, the processing element checks, decrements, or increments one or more dependency counters that record satisfaction of dependencies between instructions and threads. If a dependency indicator indicates that an instruction in a first thread is dependent upon the execution of a second thread, a dependency counter is checked. If the dependency counter is not above a threshold, the processing element suspends the execution of the first thread until the dependency counter is incremented by a second thread to above the threshold. This allows the processing element to maintain synchronized execution of dependent instructions between threads in a highly efficient manner. It should be recognized that the concepts described below are not restricted to processing network data elements but are extensible to a generic form of data processing. Prior to discussing the features of the present invention, a brief description of a data communications system is provided.
FIG. 1 illustrates a block diagram of a network data communications system, according to an embodiment of the present invention. Data communications system 100 can be, for example, of the type used by network service providers and telecommunication carriers to provide voice and data communications services to consumers. Data communications system 100 includes network 102, network line modules 104 1104 N, and switch fabric 106. Note that a subscript “N” in the figures denotes a plurality of elements generally, and not a specific number or equality of number between different elements with a subscript “N.”
Network 102 is connected to network line modules 104 1104 N which, in turn, are connected to switch fabric 106. Although data communications system 100 is shown as including physical connections between the various components, other configurations are possible, such as wireless connections. Connections between network 102, network line modules 104 1104 N, and switch fabric 106 can be, for example, wireless data connections, data over copper, fiber optic connections (e.g., OC-48, OC-192, OC-768), or other data communications connections as would be apparent.
Network line modules 104 1104 N send and receive network data elements to (from) network 102. Network line modules 104 1104 N process the network data elements and communicate the process network data elements with switch fabric 106. Network data elements are signals carrying information including communications information. Examples of network data elements are asynchronous transfer mode (“ATM”) cells, Frame Relay frames, Internet Protocol (“IP”) packets, etc., and portions (segments) of these. Processing includes the concepts of performing a calculation or manipulation involving a network data element. Processing can include, for example, determining the next hop or egress port to which the network data element Star should be routed, network management, such as traffic shaping or policing, network monitoring, etc. Network 102 is a network for communicating network data elements. Network 102 can be, for example, the Internet, a telecommunications data network, an intranet, an extranet, a voice over data communications network, etc., and combinations thereof.
For descriptive clarity, operation of data communication system 100 is described in terms of network line module 104 1. Network line module 104, includes network line module ingress port 108, network line module egress port 110, and programmable network processors 112 1112 2. Note that the configuration of network line modules 104 1104 N is shown for illustrative purposes only, and alternate configurations for network line modules 104 1104 N are possible. Alternate configurations include, for example, single or additional programmable network processors per network line module, additional network line module ingress ports, multiple egress ports, additional connections to network 102, etc.
Network line module 1041 1041 receives network data elements from network 102 at network line module ingress port 108. Programmable network processor 112 1 receives network data elements from network line module ingress port 108. Programmable network processor 112 enables network line module 1041 1041 to process the received network data elements. Programmable network processor 112 1 provides the network data elements to switch fabric 106 after processing.
Switch fabric 106 includes switch fabric ingress ports 114 1114 N and switch fabric egress ports 116 1116 N. Switch fabric ingress ports 114 1114 N receive data from network line modules 104 1104 N and switch fabric egress ports 116 1116 N ports provide data to network line modules 104 1104 N. Switch fabric 106 outputs network data elements received from network processor 112 1 on the desired switch fabric egress port 116 1116 N. Network line module 104 1 receives processed network data elements from switch fabric egress port 116 1 and performs additional processing, as required, and transmits the network data element to network 102 via network line module egress port 110. Note that network line module ingress port 108, network element egress port 110, switch fabric ingress ports 114 1114 N, and switch fabric egress ports 116 1116 N are logical representations of physical devices, and other combinations, such as single ports that transmit and receive network data elements, are possible.
FIG. 2 illustrates a system block diagram of a programmable network processor, according to an embodiment of the present invention. Programmable network processor 200 can be considered an exemplary embodiment of both ingress and egress programmable network processors 112 1112 N, as described above. Programmable network processor 200 includes memory controller 204, input interface 206, multiprocessor core 202, and output interface 208. Multiprocessor core 202 is connected to input interface 206, output interface 208, and memory controller 204. Note that the particular configuration, number, and type of elements of programmable processor 200 are shown for illustrative purposes only and other configurations of programmable network processor 200 are possible as would be apparent.
For the purposes of this description, it is presumed that the programmable network processor 200 of FIG. 2 corresponds to programmable network processor 112 1. In operation, such a programmable network processor 200 receives network data elements from network line module ingress port 108 via input interface 206. Input interface 206 receives the network data elements and provides them to multiprocessor core 202 for processing as described above. Multiprocessor core 202 processes the network data elements and provides the result to output interface 208. Output interface 208 receives processed network data elements from multiprocessor core 202 and forwards them to switch fabric 106 for routing. Multiprocessor core 202 accesses storage located off programmable network processor 200 via memory controller 204.
Multiprocessor core 202 is connected to host control processor 210. Host control processor 210 provides network management logic and information for programmable network processor 200. Such network management logic and information includes, for example, generating and receiving network data elements for controlling switch fabric 106, network line modules 104 1104 N and other network components. Host control processor 210 performs other functions, such as generating network data elements for switch fabric control, setting up network connections and loading programs into multiprocessor core 202 for operation.
FIG. 3 illustrates a system block diagram of a multiprocessor core, according to an embodiment of the present invention. Multiprocessor core 300 is an exemplary embodiment of multiprocessor core 202, as described above. Although multiprocessor core 300 can be used for a generic form of data processing, multiprocessor core 300 can also be of the type employed in data communications system 100. Multiprocessor core 300 includes processing elements (PE) 302 1302 N, data memories (DM) 304 1304 N, program memories (PM) 306 1306 N, intraswitch 314, and host control interface 308. Processing elements 302 1302 N are connected to program memories 306 1306 N, and intraswitch 314. Data memories 304 1304 N are connected to intraswitch 314. Program memories 306 1306 N are connected to processing elements 302 1302 N and intraswitch 314. Host control interface 308 is connected to intraswitch 314. Intraswitch 314 is connected to on-chip peripheral units 310 and 312. Examples of on-chip peripheral units 310 and 312 are input interface 206, output interface 208, and memory controller 204 of FIG. 2.
Processing elements 302 1302 N process network data elements, thereby providing the processing functionality for multiprocessor core 300. Processing elements 302 1302 N execute program instructions from program memories 306 1306 N, and load and store data in data memories 304 1304 N. Each of processing elements 302 1302 N can process multiple threads of instructions concurrently, according to an embodiment of the present invention.
Program memories 306 1306 N and data memories 304 1304 N provide data storage functionality for the various elements of multiprocessor core 300. Program memories 306 1306 N store program instructions for the processing of network data elements by processing elements 302 1302 N. Although FIG. 3 depicts groups of four processing elements directly connected to one of program memories 306 1306 N, other configurations connecting program memory to processing elements are possible, including for example, additional processing elements or program memories as would be apparent. Data memories 304 1304 N provide on-chip storage for data, such as intermediate-results data from processing network data elements, for the operation of processing elements 302 1302 N.
Intraswitch 314 enables communication between the various components of multiprocessor core 300. For example, processing elements 302 1302 N access data memories 304 1304 N through intraswitch 314. Intraswitch 314 can be, for example, a switching fabric in multiprocessor core 300, or individual trace connections in multiprocessor core 300. Host control interface 308 connects multiprocessor core 300 to host control processor 210. Multiprocessor core 300 is connected to on-chip peripheral units 310 and 312 via intraswitch 314.
In operation, multiprocessor core 300 receives network data elements from on-chip peripheral units 310 and 312. Processing elements 302 1302 N receive the network data elements and process them according to the programs stored as instructions in program memories 306 1306 N. The intermediate results and final results of the processing operations are stored in data memories 304 1304 N. After a network data element has been processed, it is sent to on-chip peripheral unit 310 and 312.
FIG. 4 illustrates a system block diagram of an exemplary processing element, according to an embodiment of the present invention. Processing element 400 is an example of one of the processing elements shown in FIG. 3, and can be employed in a generic form of data processing or can be of the type that is employed in data communications system 100.
Moreover, exemplary processing element 400 is an instruction-level parallel processing element, in which two or more threads of parallel programs execute concurrently. Processing element 400 can, therefore, maintain a high utilization under conditions where the processing element would otherwise idle waiting for long-latency operations to complete. Note that processing element 400 is provided for illustrative purposes only and that other processing element configurations are possible.
Processing element 400 includes instruction fetch unit 402, instruction buffers 404A, 404B, 404C, and 404D. Processing element 400 also includes function decode and execution switch 406, dependency counters 410, instruction issue control 408, memory/peripheral interface unit 4; 2 412, primary function unit 414, auxiliary function unit 416, and register file 418. Note that although dependency counters 410 are shown as being part of instruction issue control 408, other configurations are possible. For example, dependency counters 410 can also be connected to, but not part of, instruction issue control 408.
Instruction fetch unit 402 is connected to each of instruction buffers 404A–404D. Each of the connections between fetch unit 402 and instruction buffers 404A–404D provides a path for instructions from a program thread. Instruction buffers 404A–404D are, in turn, connected to function decode and execution switch 406. Instruction buffers 404A–404D are also connected to instruction issue control 408. Instruction issue control 408 is connected to function decode and execution switch 406. Function decode and execution switch 406 is connected to memory peripheral interface unit 412, primary function unit 414, and auxiliary function unit 416. Memory peripheral interface unit 412, primary function unit 414, and auxiliary function unit 416 are also referred to herein as execution units 412416. Memory peripheral interface unit is connected to intraswitch 314, and register file 418. Primary function unit 414 is connected to register file 418. Auxiliary function unit 416 is connected to register file 418.
Register file 418 includes read ports 420 and write port 422. Read ports 420 allow execution units 412416 to read data from the various registers in register file 418. Write port 422 allows execution units 412416 to write data to register file 418.
Exemplary processing element 400 is shown as supporting four concurrent threads of instructions. Instruction fetch unit 402 fetches instructions from program memory 306. The instructions are entered in the four instruction buffers 404A–404D according to the program thread they belong to. Each of instruction buffers 404A–404D is associated with one of four threads. For descriptive clarity, the convention of associating thread 0 (T0) with instruction buffer 404A, thread 1 (T1) with instruction buffer 404B, thread 2 (T2) with instruction buffer 404C, and thread 3 (T3) with instruction buffer 404D is adopted.
Function decode and execution switch 406 receives the instructions associated with the four threads from instruction buffers 404A–404D. Function decode and execution switch 406 provides the instructions to execution units 412416.
FIG. 5 is a diagram illustrating concurrent processing of three threads of instructions. Instruction processing diagram 500 illustrates the problem of instruction synchronization between multiple threads. The instructions of one thread can be dependent on the results of instructions in another thread. For example, the contents of a register that is set by a first instruction in one thread can be used by a second instruction in another thread. In such a case, if the first instruction is not executed before the second instruction, the register will not include data valid for the execution of the first second instruction. These types of problems are referred to as synchronization problems, and may result in a program execution error.
Instruction processing diagram 500 shows three threads of instructions, thread 502, thread 504, and thread 506. Threads 502506 can be of the type employed in a generic form of data processing or can be of the type that are employed in data communications system 100. Note that three threads are shown for descriptive clarity only, and other configurations are possible. A processing element can process as few as two threads, and as many threads as is accommodated by a processing element architecture. For example, processing element 400 accommodates four concurrent threads of instructions.
Each of threads 502506 is shown including two instructions. Thread 502 includes instruction 508 (i1) and instruction 510 (i2). Thread 504 includes instruction 512 (i3) and instruction 514 (i4). Thread 506 includes instruction 516 (i5) and instruction 518 (i6). Note that instruction processing diagram 500 shows two instructions per thread for descriptive clarity only, and other configurations are possible. For example, each of threads 502506 can include additional instructions (not shown) before the first instruction (e.g., instruction 508 in thread 502), between the first and second instruction (e.g., instructions 508 and 510 in thread 502), and after the second instruction (e.g., instruction 510 in thread 502). Threads 502506 can include as many instructions as are required to perform generic data processing or perform processing for data communications system 100.
Generally, a processing element processes the three threads by executing their respective instructions. Instruction processing diagram 500 shows instruction execution proceeding from left to right, and the relative spacing of instructions indicates when an instruction is being executed. For example, instruction processing diagram 500 shows instruction 508 is executed before instruction 510 of thread 502. Note also the chronological relationships between instructions of different threads. For example, the processing element executes instruction 508 of thread 502 before instruction 512 of thread 504, and instruction 512 before instruction 516 of thread 506.
Additionally, instruction processing diagram 500 shows the dependency between the instructions of threads 502506. Dependency is when the execution of a second instruction is conditional on the execution of a first instruction. Consider, for example, a situation in which a first instruction in a first thread writes a value to a register file, such as register file 418, and a second instruction in a second thread subsequently reads the value from the register file and uses the value as an operand in a calculation. In this situation, the first instruction is referred to as the dependee instruction, and the second instruction is referred to as the dependent instruction. A dependent instruction is an instruction that must not be executed before the instruction on which it depends. A dependee instruction is an instruction on which a dependent instruction depends. As long as the dependee instruction is executed before the dependent instruction, the register file includes the correct value for the execution of the dependent instruction.
Depends indicators 520526 are used to show dependencies between the instructions of threads 502506. Depends indicators are drawn from a dependent instruction to a dependee instruction (i.e., the arrow of the depends indicator points to the dependee instruction). Depends indicator 520 indicates that the execution of instruction 512 depends on the execution of instruction 508. Depends indicator 522 indicates that the execution of instruction of 510 depends on the execution of instruction 514. Depends indicator 524 indicates that the execution of instruction 516 depends on the execution of instruction 510. Depends indicator 526 indicates that the execution of instruction 518 is dependent on the execution of instruction 514.
As described above, if a first instruction depends on a second, earlier executed, instruction, processing may proceed normally. Instruction processing diagram 500 shows instruction 512 and instruction 516 dependent on earlier executed instructions. Program errors may occur, however, if a first instruction depends on a later executed instruction. Instruction processing diagram 500 shows the synchronization problem as instruction 510 depending on a later executed instruction. As such, it is important for a processing element to synchronize the execution order of dependent and dependee instructions between threads to avoid such program errors.
The present invention provides a system and method that maintains the order of instruction execution between threads. Generally, a processing element processes multiple threads of instructions. Instructions in the threads can include dependence indicators that indicate dependencies between instructions and threads. When the processing element encounters instructions that include dependence indicators identifying a dependent instruction or thread, it checks, decrements, or increments one or more dependency counters. If the dependency counter is not above a threshold, it indicates that a dependency has not been satisfied, and the processing element can suspend the execution of a thread until the dependency counter is incremented to above the threshold. This allows the processing element to maintain a form of synchronized execution of dependent instructions between threads.
In one embodiment, instructions can include the dependence indicators as bits, called “depends” bits and “tells” bits. A depends bit is an indicator in a dependent instruction that a particular other thread includes an instruction on which this one depends. A tells bit is an indicator in a dependee instruction that a particular other thread includes an instruction dependent on this one. The additional bits can be included with the instruction in a number of ways. For example, a compiler for instruction-level parallel processors can include the bits at compile time based on dependencies, or a programmer may specify the instruction execution order by including “depends” and “tells” bits when coding, etc.
An exemplary embodiment is described herein to provide context for discussion, and the present invention encompasses other embodiments, as are described further below. Consider an exemplary processing element processing four threads of instructions. Each of the instructions in the four threads can include depends bits and tells bits. In an exemplary embodiment each instruction in a thread can include three depends bits, each of which indicates that the instruction is dependent on one of the other three threads. Similarly, each instruction in a thread can include three tells bits, each of which indicates that one of the other three threads depends on the execution of the instruction.
In the exemplary embodiment, the processing element can include four groups of dependency counters, each of which is associated with one of the four threads. Each of the groups of dependency counters includes three individual dependency counters, each of which is associated with one of the other three threads. For instance, consider four exemplary threads, thread 0, thread 1, thread 2, and thread 3, each having an associated group of dependency counters. The exemplary group of dependency counters associated with thread 0 includes three individual dependency counters, each of which is associated with one of thread 1, thread 2, or thread 3.
In operation, the exemplary processing element processes the instructions of the four threads. When the exemplary processing element encounters an instruction in a first thread that includes a tells bit identifying a second thread (i.e., one of the other three threads), the exemplary processing element increments the dependency counter associated with the first thread of the group of dependency counters associated with the second thread.
When the exemplary processing element processes an instruction in a first thread that includes a depends bit identifying a second thread, the processing element checks the dependency counter associated with the second thread of the group of dependency counters associated with the first thread to determine whether the instruction can be executed. If the value of the exemplary dependency counter is above a threshold (e.g., non-zero), the processing element executes the instruction. If, on the other hand, the value of the exemplary dependency counter is below a threshold, processing of the first thread is inhibited. The processing element increments the dependency counter when instructions including tells bits in the second thread are executed, and processing the first thread is resumed once the dependency counter is above the threshold. Note that an instruction can include multiple dependency indicators, such as one or more tells bits in combination with one or more depends bits. When an instruction includes more than one depends bit, the associated dependency counters must be above the threshold before the instruction is executed.
The threshold is a dependency counter value chosen to ensure that dependent instructions are not executed before the instructions in other threads on which they depend. The threshold value can be set to ensure correct instruction level synchronization. For example, the threshold can be chosen to be zero, so that a dependency counter must be incremented before a dependent instruction can be executed, as is described in further detail, below. Network data element processing is often repetitive and predictable. As such, a programmer, or compiler, can determine that value at which the threshold can be set. Note that although one embodiment of the present invention is explained in terms of a “threshold,” “above a threshold,” and “not above a threshold,” other configurations that record dependency between instructions and threads are possible. For example, in an alternate embodiment, the processing element can suspend processing a thread if a dependency counter falls below a threshold.
According to an embodiment of the present invention, depends bits, tells bits, and dependency counters are used to record the satisfaction of dependencies between instructions in a first thread and the processing of a second thread. This is in contrast to instruction processing diagram 500 of FIG. 5 that shows dependencies between individual instructions. It is sufficient to record dependency at this level because the present invention provides a system and method that ensures that dependent instructions are executed after the instructions on which they depend.
Consider, for example, the application of “depends” bits and “tells” bits to instruction processing diagram 500 of FIG. 5. In this example, instruction 512 would include a depends bit identifying instruction 512 as dependent upon instructions in thread 502. In one embodiment, the depends bit identifies the thread that includes the instruction on which instruction 512 is dependent, which is, in this case, thread 502. In another embodiment, the depends bits can identify the type or particular one of the instructions in thread 502. For example, the instruction can include more bits (i.e., more information) that identify instruction characteristics (such as type, priority, etc.). For descriptive clarity, however, depends bits and tells bits are described herein as identifying threads, and not instructions. As such, instruction 508 would include a tells bit that identifies thread 504 as including an instruction or instructions that are dependent upon the execution of instruction 508.
Similarly, instruction 510 would include a tells bit identifying thread 506 as including instructions dependent upon the execution of instruction 510. Instruction 510 would also include a depends bit identifying instruction 510 as dependent on the execution of instructions in thread 504. Instruction 514 would include a tells bit identifying thread 502 as including instructions that are dependent on the execution of instruction 514. Instruction 514 also would include a tells bit identifying thread 506 as including instructions dependent on the execution of instruction 514. Instruction 516 would include a bit identifying instruction 516 as dependent on instructions in thread 502. Instruction 518 would include a depends bit identifying instruction 518 as dependent on the execution of instructions in thread 504.
FIG. 8 illustrates an exemplary instruction, according to an embodiment of the present invention. Instruction 800 includes opcode 802, source 0804 0 804, source 1806 1 806, result 808, depends bit 810, depends bit 812, depends bit 814, tells bit 816, tells bit 818, and tells bit 820. Opcode 802 is the operator for instruction 800. Source 0804 0 804 specifies a first operand operated upon by opcode 802. Source 1806 1 806 specifies a second operand operated upon by opcode 802. Result 808 identifies a register to which the results of opcode 1302 are stored.
Depends bits 810814 indicate that instruction 800 depends upon the execution of instructions in other threads. Instruction 800 is configured for a processing element that supports the operation of four threads. Note that although instruction 800 includes three depends bits which identify three other threads, and three tells bits, which also identify three other threads, other configurations are possible. By adding additional bits or changing how the bits are used, instruction 800 can be configured for a processing element that supports more than four threads. Consider, for example, binary coding of depends bits 810814, and tells bits 816818 816-820. In such an example, depends bits 810814 can represent up to eight other threads, extending instruction 800 to a processing element supporting nine threads. Similarly, additional depends and tells bits can be added as is necessary for a given processing element architecture.
Consider, for example, the case in which instruction 800 is executing in thread 1. If instruction 800 is executing in thread 1, the other three threads on which the execution of instruction 800 may depend are thread 0, thread 2, and thread 3. In this case, depends bit 810 can identify instruction 800 as dependent on thread 0, depends bit 812 can identify instruction 800 as dependent on thread 2, and depends bid 814 can identify instruction 800 as dependent on thread 3. Likewise, tells bit 816 can identify thread 0 as dependent on instruction 800. Tells bit 818 can identify thread 2 as dependent on instruction 800. Tells bit 820 can identify thread 3 as dependent on instruction 800.
As suggested by the relationships described above, dependency counter groups are a set of dependency counters associated with each thread. Each of threads 502506 of instruction processing diagram 500, for example, would have, or be associated with, a dependency counter group. Each dependency counter group could include a number of individual dependency counters, each of which is associated with one of the other threads executing on the processing element. For example, the dependency counter group associated with thread 502 of instruction processing diagram 500 would include two dependency counters, one related to, or associated with, thread 504, and one related to, or associated with, thread 506.
FIG. 7 illustrates exemplary dependency counter groups, according to an embodiment of the present invention. FIG. 7 shows four dependency counter groups, each of which is associated with one of four threads. Dependency counter group 702 (T0) is associated with thread 0, dependency counter group 704 (T1) is associated with thread 1, dependency counter group 706 (T2) is associated with thread 2, and dependency counter group 708 (T3) is associated with thread 3. Each of dependency counter groups 702708 includes three dependency counters, each of which is associated with one of the other three threads. Dependency counter group 702 includes dependency counter T0 1, dependency counter T0 2, and dependency counter T0 3. Dependency counter T0 1 is that dependency counter of thread 0 that is related to, or associated with, thread 1. Similarly, dependency counter T0 2 and dependency counter T0 3 are thread 0 dependency counters associated with, or related to, threads 2 and 3, respectively. In the same manner, dependency counter group 704 includes dependency counter T1 0, dependency counter T1 2, and dependency counter T1 3. Dependency counter T1 0 is associated with thread 0, dependency counter T1 2 is associated with thread 2, and dependency counter T1 3 is associated with thread 3. Also, dependency counter group 706 includes dependency counter T2 0, dependency counter T2 1, and dependency counter T2 3. Dependency counter T2 0 is associated with thread 0, dependency counter T2 1 is associated with thread 1, and dependency counter T1 3 is associated with thread 3. Dependency counter group 708 includes dependency counter T3 0, dependency counter T3 1, and dependency counter T3 2. Dependency counter T3 0 is associated with thread 0, dependency counter T3 1 is associated with thread 1, and dependency counter T3 2 is associated with thread 2.
Note that although four dependency counter groups are shown (as are implemented in one embodiment to support four threads), and the dependency counter groups include three dependency counters each, other configurations are possible. For example, greater or fewer than four dependency counter groups can be used according to the number of threads a processing element can execute concurrently. Additionally, dependency counter groups 702708 can include more or fewer dependency counters, depending on the processing element architecture.
Moreover, although the invention and illustrative examples are described in terms of dependency counter groups, and dependency counters, other configurations are possible. Consider, for example, bi-state, or tri-state elements substituted for dependency counters 702708. A bi-state element associated with a first thread can be set when a corresponding dependee instruction in a second thread is executed, and reset when the dependent instruction is executed. In this example, a processing element suspends processing the first thread when it encounters an instruction including a depends bit if the bi-state element is not set. Similarly, tri-state elements, and other state retaining elements can be set and reset by the processing element. In this embodiment, however, care should be taken to avoid overflowing the state elements. For example, a bi-state element may be incremented, or changed, only once in response to an instruction that includes a tells bit.
Similarly, the implementation of the present invention should account for the size of the dependency counters to avoid overflow. Consider, for example, the case in which multiple instructions including tells bits identifying one thread are executed. In such a case, it is possible to overflow the dependency counter. Dependency counters, therefore, should be specified large enough to ensure that overflow will never occur, or limits should be set on the number of times a dependency counter can be incremented. For example, a first thread that includes many instructions that include tells bits identifying a second thread can be suspended once the dependency counter associated with the second thread has reached a limit. The limit can ensure that the dependency counter does not overflow, and can also ensure that a dependee thread does not get too far ahead of a dependent thread.
In operation, a tells bit affects one or more dependency counters of the threads other than the one on which the tells bit appears. By contrast, a depends bit affects one or more dependency counters of the thread on which the depends bit appears. Thus, when the processing element detects a first instruction in a first thread as including a tells bit that identifies a second thread, the processing element increments one of the dependency counters in the dependency counter group of the second thread. In particular, it increments that dependency counter of the second thread that is associated with the first thread. Consider, for example, the case in which thread 1 is executing a stream of instructions. One of the instructions in thread 1 includes a tells bit that identifies thread 0. In response to the tells bit, the processing element increments the particular dependency counter in dependency counter group 702 associated with thread 1. In the example of dependency counter group 702, dependency counter T0 1, is associated with thread 1. The processing element, therefore, increments T0 1 of dependency counter group 704 when the thread 1 instruction tells bit is detected. Similarly, when the processing element detects an instruction in a thread that includes a depends bit, the dependency counters are checked, and the processing element either suspends the dependent thread or executes the instruction and decrements the associated dependency counter.
For example, thread 1 can include an instruction that includes a depends bit that identifies the instruction as depending on the execution of thread 0. In this case, when the processing element detects the depends bit, the dependency counter associated with thread 0 of the dependency counter group associated with the thread 1 is checked. In this case, dependency counter T1 0 of dependency counter group 704 is associated with thread T0. Depending on the value of dependency counter T1 0, the processing element either suspends processing thread 1 or both decrements T1 0 and continues processing the thread 1, thereby executing the instruction. Once suspended, the processing element resumes processing thread 1 when dependency counter T1 0 is incremented by the processing element (i.e., when an instruction in thread 0 with a tells bit is executed).
FIG. 6 illustrates concurrent processing of two threads of instructions, according to an embodiment of the present invention. Thread synchronization diagram 600 shows thread 602 and thread 604 as a series of processing steps. A processing step is an action or actions performed by a processing element in the implementation of one embodiment of the present invention. A processing step can be, for example, the execution of an instruction, incrementing a dependency counter, decrementing a dependency counter, etc. Thread 602 includes processing step 606, processing step 608, processing step 610, processing step 612, processing step 614, and processing step 616. Thread 604 includes processing step 618, processing step 620, and processing step 622. Although synchronization diagram 600 only shows two threads of instructions, other configurations are possible. For example, the system and method of the present invention can be extended to three, four, and more than four threads, as described above.
For the purpose of descriptive clarity, the instructions of thread synchronization diagram 600 are referred to as instruction 508 (i1), instruction 510 (i2), instruction 512 (i3), and instruction 514 (i4). Note, however, that instruction processing diagram 500 shows instruction 512 as dependent on instruction 508, and shows instruction 510 as dependent on instruction 514. Thread synchronization diagram 600, on the other hand, shows the instructions of thread 602 dependent on the execution of instructions in thread 604 generally, and the instructions of thread 604 dependent on the execution of instructions in thread 602 generally. The dependencies between instructions 508514 shown in instruction processing diagram 500 are implemented in the operation of one embodiment of the present invention through the general dependency of instructions within one thread on the processing of another thread (i.e., rather than particular instructions). This concept is illustrated in further detail below.
Additionally, thread synchronization diagram 600 shows tells bits 624 and 630 and depends bit 626 and 628 as arrows pointing from processing steps to the threads that the bits identify. The arrows are shown to indicate that an instruction being processed in a processing step includes a tells bit or depends bit, and identifies the thread to which the bit points. Either the thread pointed to depends on the instruction (i.e., tells bit), or the instruction depends on the thread (i.e., depends bit). For example, tells bit 624 identifies thread 604 as dependent on instruction 508 of processing step 606. Similarly, depends bit 626 identifies instruction 512 of processing step 618 as dependent on thread 602.
Processing of thread 602 and thread 604 begins when the processing element executes instruction 508, in processing step 606. Instruction 508 includes tells bit 624 that identifies thread 604 as dependent on instruction 508. The processing element detects tells bit 624 and increments a dependency counter in a dependency counter group 704 associated with thread T1, 604.
As described above, a dependency counter group is associated with a thread, and the dependency counter group includes dependency counters, each of which is associated with one of the other threads executing on the processing element. Thread synchronization diagram 600 is described in terms of dependency counter group 702 (associated with thread 602) and dependency counter group 704 (associated with thread 604). Dependency counter T10 T10 of dependency counter group 704 is associated with thread 602, and dependency counter T0, is associated with thread 602.
After processing step 606, the processing element receives instruction 512, in processing step 618. Instruction 512 includes depends bit 626 identifying instruction 512 as dependent on the execution of instructions in thread 602. The processing element determines if dependency counter T1 0 is above a predefined threshold. For the purposes of explanation, dependency counter T1 0 is assumed to have been above, or at the threshold, so that it is above the threshold after being incremented. Since the processing element has incremented dependency counter T1 0, when the dependency counter is checked in response to instruction 512, the processing element determines that dependency counter T1 0 is above the threshold.
Since dependency counter T1 0 is above the threshold, the processing element continues processing instruction 512, at processing step 620. In processing step 620, the processing element executes instruction 512 and decrements dependency counter T1 0.
Meanwhile, the processing element processes thread 602 in processing step 608. In processing step 608, the processing element receives instruction 510 from program memory. Instruction 510 includes depends bit 628, which identifies instruction 510 as dependent on the execution of instructions in thread 604. The processing element checks the dependency counter group of thread 602, particularly the dependency counter related to thread 604, in response to detecting depends bit 628. This corresponds to dependency counter T0 1. The value can be, for example, zero, or some other number representing a predetermined threshold. For exemplary purposes, however, dependency counter T0 1 is defined as having a value of the predetermined threshold. In any case, the value of dependency counter T0 1 indicates that instructions in thread 604 upon which instruction 510 depends, have not yet been executed. In response to detecting that dependency counter T0 1 is not above a threshold, the processing element suspends execution of thread 602 in processing step 610.
Meanwhile, the processing element continues processing thread 604. The processing element receives instruction 514 in processing step 622. Instruction 514 includes tells bit 630 that identifies thread 602 as including instructions dependent on instruction 514. The processing element increments that dependency counter of the thread 602 dependency counter group that is related to thread 604 (namely, dependency counter T0 1) in response to detecting tells bit 630, and executes instruction 514, in processing step 622. Note that the order of executing the instruction and incrementing or decrementing dependency counters is chosen for illustrative purposes only, and the same outcome can be achieved with reversed order.
After processing step 622, the processing element detects that dependency counter T0 1 has been incremented to above the threshold, in processing step 612. As such, the processing element resumes processing thread 602 at instruction 510 in processing step 614. After resuming processing thread 602, the processing element executes instruction 510, decrements dependency counter T0 1, and continues processing the instructions of thread 602, in step 616. Note that in the example of FIG. 6, dependency counter T0 1 is now equal to the threshold value, and any additional instructions in thread 602 that include depends bits identifying thread 604 will cause the processing element to suspend execution of the thread (absent prior instructions in thread 604 with tells bits identifying thread 602).
The operation of thread synchronization diagram 600 is now described with reference to the elements of exemplary processing element 400. The execution of thread 602 begins in processing step 606. For descriptive clarity, thread 602 is associated with instruction buffer 404A, and thread 604 is associated with instruction buffer 404B. In general, instruction fetch unit 402 fetches program instructions from program memory 306. Instruction fetch unit 402 distributes the instructions associated with the four threads to one of instruction buffers 404A, 404B, 404C, or 404D. In one embodiment, each of instruction buffers 404A–404D is associated with a particular thread.
Instruction issue control 408 detects the presence of depends bits such as depends bits 810814 or the presence of tells bits, such as tells bits 816820 included in instructions in instruction buffers 404A–404D. Based on presence or absence of depends bits and tells bits in the instruction, instruction issue control 408 controls function decode and execution switch 406. Based on signals from instruction issue control 408, function decode and execution switch 406 issues instructions from instruction buffers 404A–404D to one of execution units 412416 (i.e., memory peripheral interface unit 412, primary function unit 414, or auxiliary function unit 416).
In processing step 606, instruction 508 is received in instruction buffer 404A. Instruction issue control 408 detects the presence of tells bit 624 in instruction 508. In response to detecting the presence of tells bit 624, instruction issue control increments one of the dependency counters in dependency counters 410. As described above, instruction issue control 408 increments dependency counter T1 0. Instruction issue control 408 then causes function decode and execution switch 406 to provide instruction 508 to one of execution units 412416 for execution. Meanwhile, processing element 400 is also processing thread 604. Instruction buffer 404B receives instruction 512, in processing step 618. Instruction issue control 408 detects the existence of depends bit 626 in instruction 512. Depends bit 626 identifies instruction 512 as dependent on instructions in thread 602. In response to detecting depends bit 626, instruction issue control 408 checks dependency counter T1 0 in processing step 618. Since dependency counter T1 0 is above the threshold (as described above), instruction issue control 408 enables function decode and execution switch 406 to provide instruction 512 to one of execution units 412416 for execution. Additionally, instruction issue control decrements dependency counter T1 0 in dependency counters 410.
Meanwhile, processing element 400 receives instruction 510 in processing step 608. Instruction issue control 408 detects the existence of depends bit 628 in instruction buffer 404A. Depends bit 628 identifies instruction 510 as dependent on instructions in thread 604. In response to detecting depends bit 628, instruction issue control 408 checks dependency counter T0 1 in dependency counters 410. In this particular example, dependency counter T0 1 is equal to the threshold necessary to continue processing instruction 510. Since dependency counter T0 1 is not above the threshold, instruction issue control 408 suspends execution of thread 602 by holding instruction 510 in function decode and execution switch 406.
Processing element 400 continues processing thread 604, and receives instruction 514 in processing step 622. Instruction 514 includes tells bit 630 identifying thread 602 as dependent on the execution of instruction 514. Instruction issue control 408 increments dependency counter T0 1 in response to detecting tells bit 630, in processing step 622. Instruction issue control 408 causes function decode and execution switch 406 to send instruction 514 to one of execution units 412416 for execution. After dependency counter T0 1 has been incremented in processing step 622, instruction issue control 408 detects that dependency counter T0 1 has been incremented. Instruction issue control 408 checks dependency counter T0 1 to determine if it is above the threshold. In the example of thread synchronization diagram 600, instruction issue control 408 determines that dependency counter T0 1 is above the threshold, in processing step 612. In response to detecting dependency counter T0 1 above the threshold, instruction issue control 408 resumes processing thread 602 by issuing instruction 510 to one of execution units 412416, in processing step 614. Instruction 510 is executed, and instruction issue control 408 decrements dependency counter T0 1 in processing step 616.
FIG. 9 illustrates a process for executing instructions, according to an embodiment of the present invention. After method 900 starts in step 902, a processing element receives an instruction in a first thread, in step 904. In step 906, the processing element determines if the execution of the instruction in the first thread is dependent on the execution of instructions in a second thread.
If the processing element determines that the execution of the instruction in the first thread is not dependent on the execution of instructions in a second thread, method 900 ends in step 916.
If, on the other hand, the processing element determines that the execution of the instruction in the first thread is dependent on the execution of instructions in a second thread, the process of method 900 continues in step 908. In step 908, the processing element examines a dependency counter group that includes a dependency counter associated with the second thread.
In step 910, the processing element determines whether the dependency counter includes a value above a threshold. If the dependency counter includes a value above a threshold, method 900 continues in step 914. In step 914, the processing element executes the first thread instruction and decrements the dependency counter.
If, on the other hand, the processing element determines that the dependency counter does not include a value above a threshold, method 900 continues in step 912. In step 912, the processing element suspends execution of the first thread until the dependency counter is incremented to above a threshold. Once the dependency counter is incremented to above a threshold, processing the first thread resumes, method 900 continues in step 914. In step 914, the processing element executes the first thread instruction.
FIG. 10 illustrates an exemplary process for executing instructions, according to an embodiment of the present invention. After method 1000 starts in step 1002, a processing element receives a first thread instruction, in step 1004. After the first thread instruction has been received, the processing element determines whether a second thread is dependent on the first thread instruction, in step 1006.
If a second thread is dependent on the execution of the first thread instruction, method 1000 continues in step 1008. In step 1008, the processing element increments a dependency counter included in a dependency counter group associated with the second thread. After the dependency counter is incremented, the processing element executes the first thread instruction, in step 1010.
If, on the other hand, the processing element determines that a second thread is not dependent on the first thread instruction, the process of method 1000 continues in step 1010. In step 1010, the processing element executes the first thread instruction.
After step 1010, method 1000 ends in step 1012.
The present invention provides a system and method for high speed processing of network data elements. A network line module, such as network line module 104 1, receives network data elements from a network or switch fabric via a network line module ingress port. The network line module provides the network data elements to a multiprocessor core. The received network data elements are distributed to multiple processing elements within the multiprocessor core for processing according to a program.
The processing elements process the network data elements according to program instructions stored in program memory. Each of the processing elements uses instruction-level parallelism to process multiple threads of instructions concurrently. Instruction execution is synchronized by recording dependencies between instructions and threads. Instructions in the threads can include dependence indicators identifying dependencies between instructions and threads. When a processing element encounters an instruction that includes dependence indicators identifying a dependent instruction or thread, the processing element checks, decrements, or increments one or more dependency counters that records dependency between instructions and threads. If an instruction in a first thread is dependent upon the execution of instructions in a second thread, a dependency counter is checked. If the dependency counter is not above a predetermined threshold, the processing element suspends the execution of the first thread until the dependency counter is incremented by the second thread to above the threshold.
After processing, the multiprocessor core provides processed network data elements to the network line module. The network line module provides the processed network data element to an egress port connected to a network or switch fabric.
It will be apparent to one skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope thereof. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents.

Claims (26)

What is claimed is:
1. An apparatus for instruction-level parallelism in a processing element, comprising: an instruction control unit; The apparatus of claim 7, wherein the instruction buffer comprises:
a first instruction buffer coupled to said instruction control unit, the first instruction buffer configured to hold a the first instructionincluding a dependency indicator and being associated with a first thread;, and
a second instruction buffer coupled to said instruction control unit, the second instruction buffer configured to hold a the second instructionincluding a dependency indicator and being associated with a second thread; a dependency counter coupled to said instruction control unit;; and wherein
anthe execution switch is coupled to said instruction control unit, said first instruction buffer, and said second instruction buffer; and
an execution unit coupled to said execution switch;
said instruction control unit configured to detect the dependency indicators and change the value of said dependency counter in response to detecting the dependency indicators and configured to disallow execution of the first instruction if said dependency counter includes a value less than a threshold value.
2. The apparatus of claim 1, wherein said dependency counter includes a first counter associated with the first instruction buffer and a second counter associated with the second instruction buffer.
3. The apparatus of claim 1, wherein said instruction control unit identifies instruction dependency bits in said first instruction buffer, the instruction dependency bits being associated with instructions.
4. The apparatus of claim 1, said instruction control unit generating control signals based on the dependency bits and values included in said dependency counter.
5. The apparatus of claim 4, said execution switch providing instructions from said first instruction buffer to said execution unit based on control signals from said instruction control unit.
6. The apparatus of claim 1, said execution switch providing instructions from said first instruction buffer to said execution unit based on control signals from said instruction control unit.
7. An apparatus for processing instructions in multiple threads in an execution unit, comprising:
an instruction buffer holding configured to hold a first instruction and a second instruction, the first instruction being associated with a first thread, and the second instruction being associated with a second thread, the first instruction and the second instruction including one or more instruction dependency bits;
a dependency counter,
an instruction control unit coupled to said instruction buffer and said dependency counter, said instruction control unit detecting configured to detect the instruction dependency bits and incrementing and decrementing to increment and decrement said dependency counter in response to detecting the instruction dependence bits, said instruction control unit configured to disallow execution of the first instruction if in response to said dependency counter includes including a value less than a threshold value; and
an execution switch coupled to said instruction control unit and said instruction buffer, said execution switch sending configured to send instructions to the execution unit.
8. The apparatus of claim 7, wherein said dependency counter includes a first counter associated with the first thread and a second counter associated with the second thread.
9. The apparatus of claim 7, wherein said instruction buffer includes the instruction dependency bits, the instruction dependency bits being associated with instructions.
10. The apparatus of claim 7, wherein said instruction control detects dependency between the first instruction and the second thread based on dependency bits in said instruction buffer and a value of said dependency counter.
11. A method for processing instructions in multiple threads, comprising:
receiving a first instruction associated with a first thread;
determining whether execution of the first instruction depends on execution of a second instruction, the second instruction being associated with a second thread;
examining a counter logic element associated with the first thread if in response to said determining indicates indicating that the first instruction depends on the execution of the second instruction, wherein the logic element comprises a single bi-state element or a tri-state element;
decrementing the counter ifmodifying the logic element in response to said examining indicatesindicating that the second instruction has already been executed; and
executing the first instruction; and
suspending the processing of the first thread until said examining indicates that the second instruction has already been executed and then resuming processing.
12. The method of claim 11, further comprising suspending the processing of the first thread until said examining indicates that the second instruction has already been executed.
13. A method for processing instructions in multiple threads, comprising:
receiving a first instruction associated with a first thread;
determining whether execution of a second instruction depends on the execution of the first instruction, the second instruction being associated with a second thread;
incrementing a counter associated with the second thread if in response to said determining indicates indicating that execution of a second instruction depends on the execution of the first instruction; and
executing the first instruction; and
suspending the processing of the second thread in response to the counter associated with the second thread not exceeding a threshold and resuming the processing of the second thread in response to the counter associated with the second thread exceeding the threshold;
wherein the first instruction and the second instruction include one or more instruction dependency bits.
14. The method of claim 13, further comprising suspending the processing of the second thread if the counter associated with the second thread does not exceed a threshold.
15. A method for processing instructions in multiple threads, comprising:
receiving a first instruction associated with a first thread, the first instruction including one or more instruction dependency bits;
determining whether a second thread depends on said first instruction;
incrementing a counter associated with the second thread if in response to the second thread depends depending on said first instruction;
loading a second instruction associated with a second thread; and
processing the second instruction in a manner related to the value of the counter associated with the second thread; and
suspending, the processing of the second thread in response to the counter not exceeding a threshold and resuming the processing of the second thread in response to the counter exceeding said threshold.
16. The method of claim 15, further comprising suspending the processing the second thread if the counter indicates that a dependent thread has not been executed.
17. The method of claim 15, further comprising executing the second instruction if the counter indicates that said first instruction has been executed.
18. An apparatus for processing instructions in multiple threads, comprising:
an instruction buffer configured to hold a first instruction and a second instruction, the first instruction including a dependency indicator and being associated with a first thread, and the second instruction including a dependency indicator and being associated with a second thread;
an instruction control unit coupled to said instruction buffer;
a dependency counter coupled to said instruction control unit, said dependency counter associated with the first thread;
said instruction control unit configured to detect the dependency indicators and change the value of increment and decrement said dependency counter in response to detecting the dependency indicators; and
said instruction control unit configured to disallow execution of the first instruction if in response to said dependency counter includes including a value less than a threshold value.
19. The apparatus of claim 18, wherein said instruction control unit is configured to determine that the dependency indicator included in the first instruction indicates that the second thread includes an instruction on which the first instruction depends.
20. The apparatus of claim 18, wherein the dependency indicator included in the first instruction is a depends bit.
21. The apparatus of claim 18, wherein said instruction control unit is configured to determine that the dependency indicator included in the second instruction indicates that the first thread includes an instruction that is dependent on the second instruction.
22. The apparatus of claim 18, wherein the dependency indicator included in the second instruction is a tells bit.
23. The apparatus of claim 18 25, wherein said instruction control unit is configured to increment said dependency counter in response to detecting the dependency indicator included in the second instruction.
24. The apparatus of claim 18 25, wherein said instruction control unit is configured to decrement said dependency counter in response to detecting the dependency indicator included in the first instruction.
25. The apparatus according to claim 18, wherein said dependency counter is coupled to said instruction control unit and associated with the first thread.
26. A method for processing instructions in multiple threads, comprising:
receiving a first instruction associated with a first thread;
determining that execution of the first instruction depends on execution of a second instruction, the second instruction being associated with a second thread;
examining a dependency counter associated with the first thread to determine whether the second instruction has already been executed;
incrementing the dependency counter in response to said determining indicating that execution of the first instruction depends on execution of the second instruction; and
suspending the processing of the first thread when examining indicates that the dependency counter does not exceed a threshold and resuming the processing after the dependency counter exceeds said threshold,
wherein the first instruction and the second instruction include one or more instruction dependency bits.
US11/862,815 2001-04-13 2007-09-27 System and method for instruction-level parallelism in a programmable multiple network processor environment Expired - Lifetime USRE44129E1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US11/862,815 USRE44129E1 (en) 2001-04-13 2007-09-27 System and method for instruction-level parallelism in a programmable multiple network processor environment

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US09/833,580 US6950927B1 (en) 2001-04-13 2001-04-13 System and method for instruction-level parallelism in a programmable multiple network processor environment
US11/862,815 USRE44129E1 (en) 2001-04-13 2007-09-27 System and method for instruction-level parallelism in a programmable multiple network processor environment

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US09/833,580 Reissue US6950927B1 (en) 2001-04-13 2001-04-13 System and method for instruction-level parallelism in a programmable multiple network processor environment

Publications (1)

Publication Number Publication Date
USRE44129E1 true USRE44129E1 (en) 2013-04-02

Family

ID=34992770

Family Applications (2)

Application Number Title Priority Date Filing Date
US09/833,580 Ceased US6950927B1 (en) 2001-04-13 2001-04-13 System and method for instruction-level parallelism in a programmable multiple network processor environment
US11/862,815 Expired - Lifetime USRE44129E1 (en) 2001-04-13 2007-09-27 System and method for instruction-level parallelism in a programmable multiple network processor environment

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US09/833,580 Ceased US6950927B1 (en) 2001-04-13 2001-04-13 System and method for instruction-level parallelism in a programmable multiple network processor environment

Country Status (1)

Country Link
US (2) US6950927B1 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150035843A1 (en) * 2013-07-31 2015-02-05 Sandia Corporation Graphics processing unit management system for computed tomography

Families Citing this family (60)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6968447B1 (en) 2001-04-13 2005-11-22 The United States Of America As Represented By The Secretary Of The Navy System and method for data forwarding in a programmable multiple network processor environment
US7225301B2 (en) * 2002-11-22 2007-05-29 Quicksilver Technologies External memory controller node
US7574439B2 (en) * 2004-05-20 2009-08-11 International Business Machines Corporation Managing a nested request
US20060212450A1 (en) * 2005-03-18 2006-09-21 Microsoft Corporation Temporary master thread
US8645959B2 (en) * 2005-03-30 2014-02-04 Intel Corporaiton Method and apparatus for communication between two or more processing elements
CN103646009B (en) 2006-04-12 2016-08-17 索夫特机械公司 The apparatus and method that the instruction matrix of specifying parallel and dependent operations is processed
US8766995B2 (en) * 2006-04-26 2014-07-01 Qualcomm Incorporated Graphics system with configurable caches
US20070260856A1 (en) * 2006-05-05 2007-11-08 Tran Thang M Methods and apparatus to detect data dependencies in an instruction pipeline
US20070268289A1 (en) * 2006-05-16 2007-11-22 Chun Yu Graphics system with dynamic reposition of depth engine
US8884972B2 (en) * 2006-05-25 2014-11-11 Qualcomm Incorporated Graphics processor with arithmetic and elementary function units
US8869147B2 (en) * 2006-05-31 2014-10-21 Qualcomm Incorporated Multi-threaded processor with deferred thread output control
US8644643B2 (en) * 2006-06-14 2014-02-04 Qualcomm Incorporated Convolution filtering in a graphics processor
US8766996B2 (en) * 2006-06-21 2014-07-01 Qualcomm Incorporated Unified virtual addressed register file
US8291431B2 (en) * 2006-08-29 2012-10-16 Qualcomm Incorporated Dependent instruction thread scheduling
US8261046B2 (en) * 2006-10-27 2012-09-04 Intel Corporation Access of register files of other threads using synchronization
CN107368285B (en) 2006-11-14 2020-10-09 英特尔公司 Multi-threaded architecture
US9317290B2 (en) * 2007-05-04 2016-04-19 Nvidia Corporation Expressing parallel execution relationships in a sequential programming language
US8200947B1 (en) * 2008-03-24 2012-06-12 Nvidia Corporation Systems and methods for voting among parallel threads
US8751211B2 (en) 2008-03-27 2014-06-10 Rocketick Technologies Ltd. Simulation using parallel processors
US9032377B2 (en) * 2008-07-10 2015-05-12 Rocketick Technologies Ltd. Efficient parallel computation of dependency problems
US8542247B1 (en) 2009-07-17 2013-09-24 Nvidia Corporation Cull before vertex attribute fetch and vertex lighting
US8564616B1 (en) 2009-07-17 2013-10-22 Nvidia Corporation Cull before vertex attribute fetch and vertex lighting
US8468539B2 (en) * 2009-09-03 2013-06-18 International Business Machines Corporation Tracking and detecting thread dependencies using speculative versioning cache
US8976195B1 (en) 2009-10-14 2015-03-10 Nvidia Corporation Generating clip state for a batch of vertices
US8384736B1 (en) 2009-10-14 2013-02-26 Nvidia Corporation Generating clip state for a batch of vertices
US10241799B2 (en) * 2010-07-16 2019-03-26 Qualcomm Incorporated Out-of-order command execution with sliding windows to maintain completion statuses
US9830157B2 (en) * 2010-08-18 2017-11-28 Wisconsin Alumni Research Foundation System and method for selectively delaying execution of an operation based on a search for uncompleted predicate operations in processor-associated queues
EP2616928B1 (en) 2010-09-17 2016-11-02 Soft Machines, Inc. Single cycle multi-branch prediction including shadow cache for early far branch prediction
TWI533129B (en) 2011-03-25 2016-05-11 軟體機器公司 Executing instruction sequence code blocks by using virtual cores instantiated by partitionable engines
CN108108188B (en) 2011-03-25 2022-06-28 英特尔公司 Memory fragments for supporting code block execution by using virtual cores instantiated by partitionable engines
CN108376097B (en) 2011-03-25 2022-04-15 英特尔公司 Register file segments for supporting code block execution by using virtual cores instantiated by partitionable engines
CN103649931B (en) 2011-05-20 2016-10-12 索夫特机械公司 For supporting to be performed the interconnection structure of job sequence by multiple engines
WO2012162188A2 (en) 2011-05-20 2012-11-29 Soft Machines, Inc. Decentralized allocation of resources and interconnect structures to support the execution of instruction sequences by a plurality of engines
US9529596B2 (en) * 2011-07-01 2016-12-27 Intel Corporation Method and apparatus for scheduling instructions in a multi-strand out of order processor with instruction synchronization bits and scoreboard bits
KR101703401B1 (en) 2011-11-22 2017-02-06 소프트 머신즈, 인크. An accelerated code optimizer for a multiengine microprocessor
US20150039859A1 (en) 2011-11-22 2015-02-05 Soft Machines, Inc. Microprocessor accelerated code optimizer
CN104025027B (en) * 2011-12-30 2017-08-15 英特尔公司 Structural reference processor, method, system and instruction
US20130246761A1 (en) * 2012-03-13 2013-09-19 International Business Machines Corporation Register sharing in an extended processor architecture
US9400653B2 (en) 2013-03-14 2016-07-26 Samsung Electronics Co., Ltd. System and method to clear and rebuild dependencies
US10275255B2 (en) 2013-03-15 2019-04-30 Intel Corporation Method for dependency broadcasting through a source organized source view data structure
WO2014150806A1 (en) 2013-03-15 2014-09-25 Soft Machines, Inc. A method for populating register view data structure by using register template snapshots
US9086873B2 (en) 2013-03-15 2015-07-21 Intel Corporation Methods and apparatus to compile instructions for a vector of instruction pointers processor architecture
US9904625B2 (en) 2013-03-15 2018-02-27 Intel Corporation Methods, systems and apparatus for predicting the way of a set associative cache
CN105210040B (en) 2013-03-15 2019-04-02 英特尔公司 For executing the method for being grouped blocking multithreading instruction
US10140138B2 (en) 2013-03-15 2018-11-27 Intel Corporation Methods, systems and apparatus for supporting wide and efficient front-end operation with guest-architecture emulation
WO2014150971A1 (en) 2013-03-15 2014-09-25 Soft Machines, Inc. A method for dependency broadcasting through a block organized source view data structure
US9891924B2 (en) 2013-03-15 2018-02-13 Intel Corporation Method for implementing a reduced size register view data structure in a microprocessor
US9811342B2 (en) 2013-03-15 2017-11-07 Intel Corporation Method for performing dual dispatch of blocks and half blocks
US9569216B2 (en) 2013-03-15 2017-02-14 Soft Machines, Inc. Method for populating a source view data structure by using register template snapshots
CN105247484B (en) 2013-03-15 2021-02-23 英特尔公司 Method for emulating a guest centralized flag architecture using a locally distributed flag architecture
WO2014150991A1 (en) 2013-03-15 2014-09-25 Soft Machines, Inc. A method for implementing a reduced size register view data structure in a microprocessor
US9886279B2 (en) 2013-03-15 2018-02-06 Intel Corporation Method for populating and instruction view data structure by using register template snapshots
JP6515771B2 (en) * 2015-10-07 2019-05-22 富士通コネクテッドテクノロジーズ株式会社 Parallel processing device and parallel processing method
US10339063B2 (en) * 2016-07-19 2019-07-02 Advanced Micro Devices, Inc. Scheduling independent and dependent operations for processing
GB2563582B (en) * 2017-06-16 2020-01-01 Imagination Tech Ltd Methods and systems for inter-pipeline data hazard avoidance
GB2576457B (en) * 2017-06-16 2020-09-23 Imagination Tech Ltd Queues for inter-pipeline data hazard avoidance
US10564989B2 (en) 2017-11-28 2020-02-18 Microsoft Technology Licensing Thread independent parametric positioning for rendering elements
US10424041B2 (en) * 2017-12-11 2019-09-24 Microsoft Technology Licensing, Llc Thread independent scalable vector graphics operations
US11740907B2 (en) * 2020-03-16 2023-08-29 Arm Limited Systems and methods for determining a dependency of instructions
US11740908B2 (en) * 2020-03-16 2023-08-29 Arm Limited Systems and methods for defining a dependency of preceding and succeeding instructions

Citations (36)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4941143A (en) 1987-11-10 1990-07-10 Echelon Systems Corp. Protocol for network having a plurality of intelligent cells
US5029169A (en) 1989-07-11 1991-07-02 Bell Communications Research, Inc. Methods and apparatus for fault detection
US5197130A (en) 1989-12-29 1993-03-23 Supercomputer Systems Limited Partnership Cluster architecture for a highly parallel scalar/vector multiprocessor system
US5274809A (en) 1988-05-26 1993-12-28 Hitachi, Ltd. Task execution control method for a multiprocessor system with enhanced post/wait procedure
US5488730A (en) * 1990-06-29 1996-01-30 Digital Equipment Corporation Register conflict scoreboard in pipelined computer using pipelined reference counts
US5522083A (en) 1989-11-17 1996-05-28 Texas Instruments Incorporated Reconfigurable multi-processor operating in SIMD mode with one processor fetching instructions for use by remaining processors
US5524212A (en) 1992-04-27 1996-06-04 University Of Washington Multiprocessor system with write generate method for updating cache
US5623670A (en) 1995-02-17 1997-04-22 Lucent Technologies Inc. Method and apparatus for crash safe enforcement of mutually exclusive access to shared resources in a multitasking computer system
US5710902A (en) * 1995-09-06 1998-01-20 Intel Corporation Instruction dependency chain indentifier
US5761474A (en) * 1996-05-24 1998-06-02 Hewlett-Packard Co. Operand dependency tracking system and method for a processor that executes instructions out of order
US5805915A (en) 1992-05-22 1998-09-08 International Business Machines Corporation SIMIMD array processing system
US5850533A (en) * 1997-06-25 1998-12-15 Sun Microsystems, Inc. Method for enforcing true dependencies in an out-of-order processor
US5913925A (en) * 1996-12-16 1999-06-22 International Business Machines Corporation Method and system for constructing a program including out-of-order threads and processor and method for executing threads out-of-order
US5964841A (en) 1997-03-03 1999-10-12 Cisco Technology, Inc. Technique for handling forwarding transients with link state routing protocol
US5978900A (en) * 1996-12-30 1999-11-02 Intel Corporation Renaming numeric and segment registers using common general register pool
US5978855A (en) 1994-05-27 1999-11-02 Bell Atlantic Network Services, Inc. Downloading applications software through a broadcast channel
US6016540A (en) * 1997-01-08 2000-01-18 Intel Corporation Method and apparatus for scheduling instructions in waves
US6044438A (en) 1997-07-10 2000-03-28 International Business Machiness Corporation Memory controller for controlling memory accesses across networks in distributed shared memory processing systems
US6065105A (en) * 1997-01-08 2000-05-16 Intel Corporation Dependency matrix
US6065112A (en) 1997-06-18 2000-05-16 Matsushita Electric Industrial Co., Ltd. Microprocessor with arithmetic processing units and arithmetic execution unit
US6108770A (en) * 1998-06-24 2000-08-22 Digital Equipment Corporation Method and apparatus for predicting memory dependence using store sets
US6182210B1 (en) * 1997-12-16 2001-01-30 Intel Corporation Processor having multiple program counters and trace buffers outside an execution pipeline
US6212623B1 (en) * 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Universal dependency vector/queue entry
US20010023479A1 (en) 2000-03-16 2001-09-20 Michihide Kimura Information processing unit, and exception processing method for specific application-purpose operation instruction
US6334182B2 (en) * 1998-08-18 2001-12-25 Intel Corp Scheduling operations using a dependency matrix
US20020138714A1 (en) * 2001-03-22 2002-09-26 Sun Microsystems, Inc. Scoreboard for scheduling of instructions in a microprocessor that provides out of order execution
US6463522B1 (en) * 1997-12-16 2002-10-08 Intel Corporation Memory system for ordering load and store instructions in a processor that performs multithread execution
US6493804B1 (en) 1997-10-01 2002-12-10 Regents Of The University Of Minnesota Global file system and data storage device locks
US6496871B1 (en) 1998-06-30 2002-12-17 Nec Research Institute, Inc. Distributed agent software system and method having enhanced process mobility and communication in a computer network
US6557095B1 (en) * 1999-12-27 2003-04-29 Intel Corporation Scheduling operations using a dependency matrix
US6567840B1 (en) 1999-05-14 2003-05-20 Honeywell Inc. Task scheduling and message passing
US6629233B1 (en) 2000-02-17 2003-09-30 International Business Machines Corporation Secondary reorder buffer microprocessor
US6763519B1 (en) 1999-05-05 2004-07-13 Sychron Inc. Multiprogrammed multiprocessor system with lobally controlled communication and signature controlled scheduling
US6782469B1 (en) * 2000-09-29 2004-08-24 Intel Corporation Runtime critical load/data ordering
US6968447B1 (en) 2001-04-13 2005-11-22 The United States Of America As Represented By The Secretary Of The Navy System and method for data forwarding in a programmable multiple network processor environment
US6978459B1 (en) 2001-04-13 2005-12-20 The United States Of America As Represented By The Secretary Of The Navy System and method for processing overlapping tasks in a programmable network processor environment

Patent Citations (38)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4941143A (en) 1987-11-10 1990-07-10 Echelon Systems Corp. Protocol for network having a plurality of intelligent cells
US5274809A (en) 1988-05-26 1993-12-28 Hitachi, Ltd. Task execution control method for a multiprocessor system with enhanced post/wait procedure
US5029169A (en) 1989-07-11 1991-07-02 Bell Communications Research, Inc. Methods and apparatus for fault detection
US5522083A (en) 1989-11-17 1996-05-28 Texas Instruments Incorporated Reconfigurable multi-processor operating in SIMD mode with one processor fetching instructions for use by remaining processors
US5197130A (en) 1989-12-29 1993-03-23 Supercomputer Systems Limited Partnership Cluster architecture for a highly parallel scalar/vector multiprocessor system
US5640524A (en) 1989-12-29 1997-06-17 Cray Research, Inc. Method and apparatus for chaining vector instructions
US5488730A (en) * 1990-06-29 1996-01-30 Digital Equipment Corporation Register conflict scoreboard in pipelined computer using pipelined reference counts
US5524212A (en) 1992-04-27 1996-06-04 University Of Washington Multiprocessor system with write generate method for updating cache
US5805915A (en) 1992-05-22 1998-09-08 International Business Machines Corporation SIMIMD array processing system
US5978855A (en) 1994-05-27 1999-11-02 Bell Atlantic Network Services, Inc. Downloading applications software through a broadcast channel
US5623670A (en) 1995-02-17 1997-04-22 Lucent Technologies Inc. Method and apparatus for crash safe enforcement of mutually exclusive access to shared resources in a multitasking computer system
US5710902A (en) * 1995-09-06 1998-01-20 Intel Corporation Instruction dependency chain indentifier
US5761474A (en) * 1996-05-24 1998-06-02 Hewlett-Packard Co. Operand dependency tracking system and method for a processor that executes instructions out of order
US5913925A (en) * 1996-12-16 1999-06-22 International Business Machines Corporation Method and system for constructing a program including out-of-order threads and processor and method for executing threads out-of-order
US5978900A (en) * 1996-12-30 1999-11-02 Intel Corporation Renaming numeric and segment registers using common general register pool
US6016540A (en) * 1997-01-08 2000-01-18 Intel Corporation Method and apparatus for scheduling instructions in waves
US6065105A (en) * 1997-01-08 2000-05-16 Intel Corporation Dependency matrix
US5964841A (en) 1997-03-03 1999-10-12 Cisco Technology, Inc. Technique for handling forwarding transients with link state routing protocol
US6065112A (en) 1997-06-18 2000-05-16 Matsushita Electric Industrial Co., Ltd. Microprocessor with arithmetic processing units and arithmetic execution unit
US5850533A (en) * 1997-06-25 1998-12-15 Sun Microsystems, Inc. Method for enforcing true dependencies in an out-of-order processor
US6044438A (en) 1997-07-10 2000-03-28 International Business Machiness Corporation Memory controller for controlling memory accesses across networks in distributed shared memory processing systems
US6493804B1 (en) 1997-10-01 2002-12-10 Regents Of The University Of Minnesota Global file system and data storage device locks
US6463522B1 (en) * 1997-12-16 2002-10-08 Intel Corporation Memory system for ordering load and store instructions in a processor that performs multithread execution
US6182210B1 (en) * 1997-12-16 2001-01-30 Intel Corporation Processor having multiple program counters and trace buffers outside an execution pipeline
US6493820B2 (en) * 1997-12-16 2002-12-10 Intel Corporation Processor having multiple program counters and trace buffers outside an execution pipeline
US6108770A (en) * 1998-06-24 2000-08-22 Digital Equipment Corporation Method and apparatus for predicting memory dependence using store sets
US6496871B1 (en) 1998-06-30 2002-12-17 Nec Research Institute, Inc. Distributed agent software system and method having enhanced process mobility and communication in a computer network
US6334182B2 (en) * 1998-08-18 2001-12-25 Intel Corp Scheduling operations using a dependency matrix
US6212623B1 (en) * 1998-08-24 2001-04-03 Advanced Micro Devices, Inc. Universal dependency vector/queue entry
US6763519B1 (en) 1999-05-05 2004-07-13 Sychron Inc. Multiprogrammed multiprocessor system with lobally controlled communication and signature controlled scheduling
US6567840B1 (en) 1999-05-14 2003-05-20 Honeywell Inc. Task scheduling and message passing
US6557095B1 (en) * 1999-12-27 2003-04-29 Intel Corporation Scheduling operations using a dependency matrix
US6629233B1 (en) 2000-02-17 2003-09-30 International Business Machines Corporation Secondary reorder buffer microprocessor
US20010023479A1 (en) 2000-03-16 2001-09-20 Michihide Kimura Information processing unit, and exception processing method for specific application-purpose operation instruction
US6782469B1 (en) * 2000-09-29 2004-08-24 Intel Corporation Runtime critical load/data ordering
US20020138714A1 (en) * 2001-03-22 2002-09-26 Sun Microsystems, Inc. Scoreboard for scheduling of instructions in a microprocessor that provides out of order execution
US6968447B1 (en) 2001-04-13 2005-11-22 The United States Of America As Represented By The Secretary Of The Navy System and method for data forwarding in a programmable multiple network processor environment
US6978459B1 (en) 2001-04-13 2005-12-20 The United States Of America As Represented By The Secretary Of The Navy System and method for processing overlapping tasks in a programmable network processor environment

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
Zhou et al. (Zhou) (Thread Scheduling for Out-of-Core Applications with Memory Server on Multicomputers); IOPADS '99 Proceedings of the sixth workshop on I/O in parallel and distributed systems; 11 pages total; 1999. *

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150035843A1 (en) * 2013-07-31 2015-02-05 Sandia Corporation Graphics processing unit management system for computed tomography
US10062135B2 (en) * 2013-07-31 2018-08-28 National Technology & Engineering Solutions Of Sandia, Llc Graphics processing unit management system for computed tomography

Also Published As

Publication number Publication date
US6950927B1 (en) 2005-09-27

Similar Documents

Publication Publication Date Title
USRE44129E1 (en) System and method for instruction-level parallelism in a programmable multiple network processor environment
US6978459B1 (en) System and method for processing overlapping tasks in a programmable network processor environment
USRE43825E1 (en) System and method for data forwarding in a programmable multiple network processor environment
US7965624B2 (en) Data link fault tolerance
US6330584B1 (en) Systems and methods for multi-tasking, resource sharing and execution of computer instructions
US5524250A (en) Central processing unit for processing a plurality of threads using dedicated general purpose registers and masque register for providing access to the registers
US8055879B2 (en) Tracking network contention
US9110714B2 (en) Systems and methods for multi-tasking, resource sharing, and execution of computer instructions
US8752051B2 (en) Performing an allreduce operation using shared memory
US7673011B2 (en) Configuring compute nodes of a parallel computer in an operational group into a plurality of independent non-overlapping collective networks
US9882801B2 (en) Providing full point-to-point communications among compute nodes of an operational group in a global combining network of a parallel computer
US7376952B2 (en) Optimizing critical section microblocks by controlling thread execution
KR20040010789A (en) A software controlled content addressable memory in a general purpose execution datapath
US20090125703A1 (en) Context Switching on a Network On Chip
US20090040946A1 (en) Executing an Allgather Operation on a Parallel Computer
US20060136681A1 (en) Method and apparatus to support multiple memory banks with a memory block
US8270295B2 (en) Reassigning virtual lane buffer allocation during initialization to maximize IO performance
EP0473777A4 (en) High-speed packet switching apparatus and method
US10558485B2 (en) Information processing apparatus and method for shifting buffer
WO2001018977A2 (en) Integrated circuit switch with embedded processor
US9246792B2 (en) Providing point to point communications among compute nodes in a global combining network of a parallel computer
US7702717B2 (en) Method and apparatus for controlling management agents in a computer system on a packet-switched input/output network
US8296457B2 (en) Providing nearest neighbor point-to-point communications among compute nodes of an operational group in a global combining network of a parallel computer
US20040246956A1 (en) Parallel packet receiving, routing and forwarding
US20090319762A1 (en) Dynamic reconfigurable circuit and data transmission control method

Legal Events

Date Code Title Description
CC Certificate of correction
FPAY Fee payment

Year of fee payment: 12