Functional-level instruction-set computer architecture for processing application-layer content-service requests such as file-access requests

1. A functional-level instruction-set computing (FLIC) processor comprising:

a plurality of processing units for executing functional-level instructions on variable-length operands to produce results that are also variable-length operands;

an execution buffer, coupled to the plurality of processing units, for storing the variable-length operands;

fixed-length registers that store

(1) fixed-length operands,

(2) a pointer that indicates a location of a variable-length operand in the execution buffer, and

(3) an operand-length that indicates a length of a variable-length operand in the execution buffer;

wherein the functional-level instructions identify a fixed-length operand for input to a processing unit in the plurality of processing units by specifying a register number of one of the fixed-length registers that contains the fixed-length operand;

wherein the functional-level instructions identify a variable-length operand for input to a processing unit in the plurality of processing units by specifying a register number of one of the fixed-length registers that contains the pointer or the operand-length of the variable-length operand stored in the execution buffer, whereby variable-length operands are stored in the execution buffer and executed by the processing unit when identified by the functional-level instructions;

a lookup cache for storing entries that contain variable-length tags;

wherein the functional-level instructions include a lookup instruction;

a lookup unit in the plurality of processing units that executes the lookup instruction by reading a variable-length operand from the execution buffer and searching for a variable-length tag in the lookup cache that matches the variable-length operand,

whereby variable-length operands are matched to variable-length tags by the lookup instruction.

2. The FLIC processor of claim 1 wherein the functional-level instructions include a variable-length compare instruction;

further comprising:

a variable-length compare unit in the plurality of processing units that executes the variable-length compare instruction by reading two variable-length operands from the execution buffer comparing the two variable-length operands to generate a result,

whereby two variable-length operands are compared by the variable-length compare instruction.

3. The FLIC processor of claim 1 wherein the plurality of processing units further comprises:

an arithmetic-logic-unit (ALU) that receives fixed-length operands from the fixed-length registers;

a branch unit that determines when to execute a first branch of the functional-level instructions and when to execute a second branch of the functional-level instructions;

a find-first unit that receives a variable-length operand from the execution buffer and finds a location of a leading one or a leading zero in the variable-length operand.

4. The FLIC processor of claim 1 further comprising:

an immediate table that contains a plurality of pre-defined constant values;

wherein a functional-level instruction that specifies an immediate constant is executed by the plurality of processing units that read a pre-defined constant from the immediate table,

whereby immediate constants are read from the immediate table during execution.

5. The FLIC processor of claim 1 further comprising:

a plurality of processing slices, each processing slice being a FLIC processor each comprising:

a plurality of processing units for executing functional-level instructions on variable-length operands to produce results that are also variable-length operands;

an execution buffer, coupled to the plurality of processing units, for storing the variable-length operands; and

fixed-length registers, whereby a plurality of FLIC processors operate in parallel.

6. The FLIC processor of claim 5 further comprising:

a copy/move unit, coupled to the plurality of processing slices, for moving the variable-length operands to the execution buffer.

7. The FLIC processor of claim 6 further comprising:

an input buffer, coupled to the copy/move unit, for storing input requests to be processed by a FLIC processor;

wherein the input requests include the variable-length operands;

an output buffer, coupled to the copy/move unit, for storing responses to the input requests, the responses generated by execution of a routine of the functional-level instructions by the FLIC processor;

wherein the responses include results that are variable-length operands.

8. A functional-level instruction-set computing (FLIC) Processor comprising:

a plurality of processing units for executing functional-level instructions on variable-length operands to produce results that are also variable-length operands;

an execution buffer, coupled to the plurality of processing units, for storing the variable-length operands;

fixed-length registers that store

(1) fixed-length operands,

(2) a pointer that indicates a location of a variable-length operand in the execution buffer, and

(3) an operand-length that indicates a length of a variable-length operand in the execution buffer;

wherein the functional-level instructions identify a fixed-length operand for input to a processing unit in the plurality of processing units by specifying a register number of one of the fixed-length registers that contains the fixed-length operand;

wherein the functional-level instructions identify a variable-length operand for input to a processing unit in the plurality of processing units by specifying a register number of one of the fixed-length registers that contains the pointer or the operand-length of the variable-length operand stored in the execution buffer, whereby variable-length operands are stored in the execution buffer and executed by the processing unit when identified by the functional-level instructions;

an expansion buffer, coupled to the execution buffer, for expanding storage space for a set of the execution buffer,

whereby execution space of a context in the execution buffer is expandable using storage from the expansion buffer.

9. The FLIC processor of claim 8 further comprising:

a state identifier, stored in a set of the execution buffer that is executing the functional-level instructions, for identifying a state used by the context, whereby state identifiers are stored in the execution buffer.

10. The FLIC processor of claim 9 further comprising: a state memory containing state information for a plurality of contexts, wherein the state identifier identifies the state information used by one of the contexts in the state memory.

11. A file server comprising:

input buffer means for receiving requests for content-services, the requests containing variable-length strings;

output buffer means for outputting responses to the requests, the responses containing variable-length strings;

memory means for storing lookup tables having entries that comprise tags storing variable-length strings;

functional-level processing means for executing functional-level instructions belonging to a functional-level instruction-set, the functional-level instructions including operand-identifier fields that identify variable-length strings as operands;

variable-length storage means, in the functional-level processing means and accessed in response to the operand-identifier fields in the functional-level instructions, for storing the variable-length strings for access during execution of the functional-level instructions;

lookup means, in the functional-level processing means, for searching the lookup tables in the memory means for tags that match a variable-length string stored in the variable-length storage means; and

move means, coupled to the functional-level processing means, for moving the variable-length strings from the input buffer means to the functional-level processing means and from the functional-level processing means to the output buffer means,

whereby variable-length strings are looked up in the lookup tables by execution of the functional-level instructions.

12. The file server of claim 11 wherein the lookup table further stores file meta-data;

wherein the functional-level processing means generates responses for the output buffer means by executing functional-level instructions to copy the file meta-data from the memory means to the output buffer means,

whereby the file meta-data are copied to generate responses.

13. The file server of claim 11 further comprising:

host general-purpose processing means, coupled to receive partial responses from the output buffer means, for executing routines of general-purpose instructions belonging to a general-purpose instruction set to further process requests that are partially processed by the functional-level processing means,

whereby the host general-purpose processing means further processes requests.

14. The file server of claim 13 further comprising:

file storage means, coupled to the host general-purpose processing means, for storing file content requested by requests in the input buffer means;

wherein the host general-purpose processing means further processes requests by accessing file content stored in the file storage means at a location indicated by a data pointer read from the lookup table by the functional-level processing means,

whereby the functional-level processing means looks up the data pointer used by the host general-purpose processing means.

15. The file server of claim 11 further comprising:

local general-purpose processing means, coupled to receive partial responses from the output buffer means, for executing routines of general-purpose instructions belonging to a general-purpose instruction set to generate local requests to the input buffer means,

whereby the local general-purpose processing means further processes requests partially processed by the functional-level processing means.

16. The file server of claim 15 further comprising:

co-processors, coupled to the input buffer means and to the output buffer means, for further processing requests by decrypting or encrypting the variable-length strings.

17. A processor comprising:

a lookup memory that stores a lookup table having entries;

one or more processor slices, each processor slice comprising: general-purpose registers that store fixed-length operands;

execution buffers that store variable-length operands that are pointed to by a register in the general-purpose registers that contains a pointer to a variable-length operand;

processing units, coupled to receive the fixed-length operands from the general-purpose registers and to receive the variable-length operands from the execution buffers, for performing operations specified by functional-level instructions on operands specified by the functional-level instructions;

wherein the functional-level instructions include native instructions that specify input of the variable-length operands to the processing units;

a lookup unit, in the processing units, the lookup unit activated by execution of a single instruction that is a lookup instruction in the functional-level instructions, the lookup unit searching the lookup memory for an entry that matches a variable-length operand stored in the execution buffers and specified by the lookup instruction; and

a move unit, coupled to each processor slice and to the lookup memory, for moving variable-length operands, whereby variable-length operands are operated upon by native instruction execution.

18. The processor of claim 17 further comprising:

an input buffer, coupled to the move unit, receiving requests;

an output buffer, coupled to the move unit, storing responses to the requests and secondary requests to a host processor;

wherein the processor slice executes routines of the functional-level instructions to authenticate the request, extract a variable-length operand from the request, lookup the variable-length operand to find a matching entry in the lookup memory, and generate the response by copying data associated with the matching entry to the output buffer.

19. The processor of claim 17 wherein a general-purpose register contains a list pointer, the list pointer being a pointer to a variable-length list stored in the execution buffers, the variable-length list being an operand list of a plurality of variable-length operands;

wherein the processing units receive the plurality of variable-length operands on the operand list;

wherein the processing units perform operations specified by functional-level instructions on the plurality of variable-length operands on the operand list;

wherein the functional-level instructions include native instructions that specify input to the processing units of a variable number of the variable-length operands specified by the operand list,

whereby variable numbers of variable-length operands are processed.