Virtual address table
The present disclosure includes apparatuses and methods related to virtual address tables. An example method comprises generating an object file that comprises: an instruction comprising a number of arguments; and an address table comprising a number of indexed address elements. Each one of the number of indexed address elements can correspond to a virtual address of a respective one of the number of arguments, wherein the address table can serves as a target for the number of arguments. The method can include storing the object file in a memory.
1. A method, comprising:
generating an object file comprising:
an instruction comprising a number of arguments; and
an address table comprising a number of indexed address elements;
wherein each one of the number of indexed address elements corresponds to a virtual address of a respective one of the number of arguments, and wherein the address table serves as a target for the number of arguments;
wherein the instruction is one of multiple instructions of the object file, and wherein the method further comprises generating an address table for each of the respective multiple instructions; and
storing the object file in a memory.
2. The method of claim 1 , further comprising executing the object file;
wherein executing the object file comprises populating the indexed address elements of the address table with the virtual addresses corresponding to the respective number of arguments; and
wherein the indexed address elements are not populated with the virtual addresses corresponding to the respective number of arguments prior to executing the object file.
3. The method of claim 1 , further comprising executing the instruction, wherein the instruction comprises an instruction for performing a number of operations involving the number of arguments without transferring data corresponding to the arguments, from a memory array in which the arguments are stored, to an external register.
4. The method of claim 3 , wherein the number of arguments correspond to a respective number of vectors, and wherein executing the instruction comprises performing a number of logical operations using the number of vectors.
5. The method of claim 4 , further including performing at least one of:
an arithmetic operation; and
a compare operation.
6. The method of claim 1 , wherein the object file further comprises a number of additional instructions, wherein arguments to the number of additional instructions comprise a number of external register indices.
7. The method of claim 1 , further comprising populating, at runtime, the number of indexed address elements of the address table with the virtual addresses corresponding to the respective number of arguments.
8. The method of claim 7 , further comprising translating, via a controller, the virtual addresses corresponding to the respective number of arguments to respective physical row and/or column addresses of a particular memory array, wherein the controller is external to a memory device comprising the particular memory array.
9. The method of claim 8 , further comprising:
generating, via the controller, an instruction block to be dispatched from the controller to the memory device, the instruction block comprising:
a location of the address table;
an operation code corresponding to the instruction; and
the address table indices corresponding to the respective number of arguments corresponding to the instruction;
dispatching the instruction block to a control component of the memory device for execution of the instruction; and
providing a response to a host external to the memory device indicating whether the instruction was executed.
10. A method, comprising:
executing an object file stored in memory, wherein the object file comprises:
an instruction whose arguments are indices of a table of indexed address elements, with each index corresponding to a particular one of the arguments; and
the table of indexed address elements;
populating the indexed address elements of the table, upon execution of the object file, with the virtual addresses of the arguments to which they correspond;
generating an instruction block that conforms to a particular instruction set architecture specification corresponding to a particular instruction type of the instruction; and
dispatching, from a controller external to a memory device comprising an array of memory cells, the instruction block to the memory device, wherein the instruction block comprises:
a location of the populated table;
an operation code corresponding to the instruction; and
the indices corresponding to the arguments.
11. The method of claim 10 , wherein dispatching the instruction block to the memory device comprises providing the instruction block to a control component of the memory device configured to control execution of the instruction; and
wherein the particular instruction type corresponds to instructions executed to perform operations on operands stored in an array of memory cells of a memory device without transferring the operands to an external register.
12. The method of claim 10 , further comprising initiating execution of the object file via a host external to the memory device.
13. An apparatus, comprising:
an array of memory cells storing an object file, wherein the object file comprises:
for each one of a number of instructions of a particular instruction type, a respective address table comprising a number of indexed address elements;
wherein each one of the number of indexed address elements of a respective address table corresponds to a virtual address of one of a number of arguments corresponding to a respective instruction; and
wherein the number of indexed address elements are configured to be populated with appropriate corresponding virtual addresses upon execution of the object file; and
a channel controller external to a memory device, the memory device comprising the array of memory cells, wherein the channel controller is configured to:
translate the populated virtual addresses in the address table to physical rows and columns of the memory array; and
populate a dispatch block with a location in the memory array of at least one of the address tables.
14. The apparatus of claim 13 , wherein the object file is a relocatable object file.
15. The apparatus of claim 13 , wherein the number of instructions of the particular instruction type are instructions to be executed in a memory array in-situ.
16. The apparatus of claim 15 , wherein the object file further comprises a number of instructions of a different particular instruction type, and wherein the number of instructions of the different particular instruction type have corresponding arguments that are indices of registers external to the array.
17. The apparatus of claim 13 , further comprising a host external to the memory device and configured to populate the number of indexed address elements with the appropriate virtual addresses at runtime.
18. An apparatus, comprising:
a host;
a memory device coupled to the host, wherein the memory device comprises an array of memory cells configured to store an object file;
wherein the host is configured to initiate execution of the object file, the object file comprising:
an instruction comprising a number of arguments; and
an address table comprising a number of indexed address elements;
wherein each one of the number of indexed address elements corresponds to a virtual address of a respective one of the number of arguments, and wherein the address table serves as a target for the number of arguments;
wherein the host is configured to populate, at runtime, the address elements with virtual addresses corresponding to the number of arguments; and
wherein the host comprises a channel controller configured to translate the virtual addresses corresponding to the number of arguments to physical locations in the memory array prior to providing an instruction dispatch block to the memory device.
19. The apparatus of claim 18 , wherein the instruction is an instruction whose corresponding machine level instruction set architecture accepts physical row/column indices as instruction arguments and does not accept indices to external functional units as instruction arguments.
20. An apparatus, comprising:
a host configured to generate an object file; and
a memory device comprising an array of memory cells configured to store the object file, wherein the object file comprises:
an object code instruction comprising a number of arguments; and
an address table comprising a number of indexed address elements;
wherein the number of arguments of the object code instruction are respective indices of the address table, and wherein the number of address elements represent addresses to be populated at runtime and corresponding to a respective number of source code arguments; and
wherein the host is configured to:
populate the address elements with virtual addresses corresponding to the number of source code arguments; and
translate the virtual addresses to physical rows and columns prior to dispatching an instruction block corresponding to the object code instruction to the memory device.
21. A method, comprising:
generating an object file comprising:
an instruction comprising a number of arguments; and
an address table comprising a number of indexed address elements;
wherein each one of the number of indexed address elements corresponds to a virtual address of a respective one of the number of arguments, and wherein the address table serves as a target for the number of arguments;
storing the object file in a memory;
populating, at runtime, the number of indexed address elements of the address table with the virtual addresses corresponding to the respective number of arguments; and
translating, via a controller, the virtual addresses corresponding to the respective number of arguments to respective physical row and/or column addresses of a particular memory array, wherein the controller is external to a memory device comprising the particular memory array.
22. An apparatus, comprising:
a host configured to generate an object file;
a memory device comprising an array of memory cells configured to store the object file, wherein the object file comprises:
an object code instruction comprising a number of arguments; and
an address table comprising a number of indexed address elements;
wherein the number of arguments of the object code instruction are respective indices of the address table, and wherein the number of address elements represent addresses to be populated at runtime and corresponding to a respective number of source code arguments; and
a channel controller that is external to the memory device and comprises a translation component configured to perform virtual address to physical address translation and dispatch an instruction block corresponding to the object code instruction to the memory device.
23. The apparatus of claim 22 , wherein the host is external to the memory device and coupled thereto via a memory channel, and wherein the host comprises:
a processor comprising a number of registers; and
the channel controller.
24. The apparatus of claim 23 , wherein the object code instruction corresponds to a number of arithmetic operations to be performed on operands stored in the memory array without transferring the operands to the number of registers.