Method and system for configuring and using virtual pointers to access one or more independent address spaces

A method of providing a plurality of large independent data access address spaces accessible within a software application program which make use of physical memory and or physical storage devices, the method comprising:

• specifying the properties of one or more independent address spaces;
• processing computer program code source statements into an executable image suitable to run on a particular software engine and or hardware processor which supports virtual pointer functionality;
• and
• running the executable image on the particular software engine or hardware processor which executes an instruction set that resolves accesses to data referenced by the address space by using a fast access limited size main memory and slower access but larger size secondary storage;
• and
• (1) for each independent address space, creating, and maintaining a number of real memory pages all of a single specific size;
• (2) when accesses to data logically in the independent address space are made, resolving the access and returning a value or pointer to main memory containing the value to the instruction or program making the access, using the following procedure:
• (a) determining if the data is in one of the main memory pages;
• (b) if the data is not in one of the main memory pages performing the following procedure:
• (i) determining if the data is in the secondary storage;
• (ii) if it is not in the secondary storage, perform one or more of the following procedures:
• (1) return a default value;
• (2) return with a pointer to a main memory data element that contains a default value;
• and
• (3) return with an access to unknown data code or other indicator that there is no known value for the data;
• (c) if the data is in the secondary storage, perform the following procedure:
• (i) selecting a real memory page and starting address that will hold the block of data that contains the data value needed;
• (ii) if the selected real memory page is marked as dirty then writing out or otherwise cause the values in the selected real memory page to be written to secondary storage;
• (iii) reading or otherwise loading the contiguous range of addressable data into the real memory page that is the size and has the same new starting address as the real memory page;
• (iv) mark the data in the real memory page as being not dirty;
• and
• (v) return the value of the data now in the selected main memory page or a pointer to the data now in the selected main memory page;
• and
• (d) if the data is in one of the main memory pages perform the following procedure:
• (i) if the access is known to be one that indicates that the consumer of the value may change the value of the data, mark the main memory page as dirty;
• and
• (ii) return the value of the data main memory page or a pointer to the data in the main memory page that is found to include the data.

The method claim of 1, wherein the method advantageously provides one or more of the following properties in any combination:

• (a) multiple large independent address spaces;
• (b) application specific control over the number of real memory pages for each individual independent address space;
• (c) device specific control over real memory page sizes to match storage device performance characteristics;
• (d) no need for the programmer to predict or administrate the amount of memory needed for data structures or lists because the virtual pointer automatically logically includes values for an address space larger than the expected largest such data structure or list used to access it;
• (e) automatic saving of data in a form independent of page sizes or number of pages;
• (f) effective caching of data from a larger and possibly slower data store with a minimal amount of precious RAM allowing applications to run as if they have much larger RAM memories than they physically do;
• and
• (g) a base infrastructure for indexed database operations where the data and indexes are kept in different virtual pointer address spaces.

A computer program product for use in conjunction with a computer system or information appliance, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:

• a program module that directs the computer system or information appliance to function in a specified manner for providing a plurality of large independent data access address spaces accessible within a software application program which make use of physical memory and or physical storage devices, the program module including instructions for:
• (1) specifying the properties of one or more independent address spaces;
• (2) processing computer program code source statements into an executable image suitable to run on a particular software engine and or hardware processor which supports virtual pointer functionality;
• and
• (3) running the executable image on the particular software engine or hardware processor which executes an instruction set that resolves accesses to data referenced by the address space by using a fast access limited size main memory and slower access but larger size secondary storage;
• and
• (4) for each independent address space, creating, and maintaining a number of real memory pages;
• and when accesses to data logically in the independent address space are made, resolving the access and returning a data value or pointer to main memory containing the data value to the instruction or program making the access, using a multiple step procedure for moving data between main memory pages and secondary storage.

A virtual pointer data structure, comprising:

• a memory storage;
• a plurality of pointers stored in the memory storage;
• the pointers permitting specification and access to a plurality of large independent data access address spaces accessible within a software application program which make use of physical memory and physical storage devices;
• the pointers specifying the properties of one or more independent address spaces;
• and
• the pointers permitting resolution of access to data referenced by the address space by using a fast access limited size main memory and slower access but larger size secondary storage;
• wherein each virtual pointer is specified with a plurality of parameters including:
• (i) a name of a pointer variable that will hold the starting address of a virtual address space when a program using or referencing the virtual pointer starts execution;
• (ii) a suggested number of real memory pages for use;
• (iii) a binary flag indicating if values in the address space are to be automatically saved along with the application;
• and
• (iv) a suggested size of the real memory pages.

A method of providing a plurality of large independent data access address spaces accessible within an application program which makes use of physical memory and or physical storage devices, the method comprising:

• (1) specifying at least one application program source language specified pointer variables that is to be mapped to an independent address space;
• (2) compiling the application program source to create compiled instructions where the specified pointer variables are accessed by specially encoded and formatted address fields of the compiled instructions generated by the compiler carrying out the specifying in the source code the compiler compiles;
• (3) running the compiled instructions on an instruction decoding engine which:
• (i) decodes the specially formatted address fields;
• and
• (ii) performs a intended read or write memory accesses using memory caching and paging to limit the number of read, write, and/or erase operations to a slower or limited read, write, and/or erase cycle secondary storage;
• and
• (4) automatically saving the values stored by the application program of all such independent address spaces as part of a single save instruction that is part of the instruction decoding engine into permanent secondary storage.

A method for constructing an application program code that may reference a large independent data access address space within the application program and that eliminates any need to specify without the need for explicit file operations, explicit memory allocations, explicit memory management, or explicit saving of data, the method comprising:

• (1) specifying an application program source language pointer variable that is to be mapped to an independent address space;
• (2) identifying a compiler that is configured to compile the application program source language to create compiled instructions in which the specified pointer variables refer to encoded and formatted address fields of the compiled instructions;
• (3) configuring the compiled instructions for decoding during execution so that the execution will (i) decode the specially formatted address fields;
• and (ii) perform an intended read or write memory accesses using memory caching and paging to limit the number of read, write, and/or erase operations to a secondary storage;
• and
• (4) automatically saving the values stored by the application program of all such independent address spaces as part of a single save instruction that is part of the instruction decoding engine into permanent secondary storage.