text:
|Número de publicación
|Tipo de publicación
|Número de solicitud
|Fecha de publicación
|13 Jun 2006
|Fecha de presentación
|10 Jul 2001
|Fecha de prioridad
|10 Jul 2001
|También publicado como
|Número de publicación
|Keith R Slavin, Shane C. Hu
|Cesionario original
|Micron Technology, Inc.
|Exportar cita
|BiBTeX, EndNote, RefMan
|Citas de patentes (37), Otras citas (6), Citada por (114), Clasificaciones (17), Eventos legales (4)
|Enlaces externos: USPTO, Cesión de USPTO, Espacenet
This invention relates generally to systems and methods for writing processing code to access data arrays.
Programming languages can be viewed as belonging to one of three levels: low, middle, and high. One example of a low-level programming language is assembly language, which is a mnemonic representation of machine language intended to be understandable by humans. In contrast, a high-level programming language such as Java uses syntax and concepts that more closely align with human reasoning. A high-level programming language also provides high levels of run-time access security and memory protection at the expense of some program execution speed. "Mid-level" programming languages, as used herein, have some of the "look and feel" of high-level programming languages in that, in comparison to low level languages, they appear and read in a fashion more similar to ordinary human reasoning. Mid-level programming languages allow a programmer to directly manipulate and access memory addresses, and as such, they are more computationally efficient than high level languages. In other words, for improved execution speed, mid-level programming languages omit the run-time memory access checks that a high level language might perform. Such languages may also allow direct access to memory for driving hardware devices that have control registers at fixed addresses. However, mid-level programming languages allow a program to access an illegal memory address, and as such, are often dangerous. The illegal memory accesses sometimes occur without the detection of any error at the time. Potential consequences include subsequent unpredictable behavior, and accumulated errors that result in an illegal operation and the termination of the program.
Examples of mid-level programming languages are C and C++. The version of the C language familiar to most C programmers at present is the ANSI 1989 C programming language referred herein as C89, that has the mid-level features discussed above. C++is an object-oriented version of C89. As used herein, the term C99 refers to the publication: International Standard ISO/IEC 9899:1999(E) Programming Languages—C. As an improvement on the C89 standard, the C99 standard is used throughout this specification to illustrate examples of the possible logical mistakes, dangers, and limitations associated with mid-level programming languages, particularly with respect to the way in which mid-level programming languages handle arrays.
Since this application includes programming terms, some of these terms are introduced and defined below. These definitions are intended to assist the reader with understanding the description contained herein. Unless otherwise stated, these definitions are not intended to override the ordinary meaning that one of ordinary skill in the art would give them upon reading this description and the appended claims.
A language is defined by a grammar, such as the rules that define good sentence structures in spoken languages. Programming languages are used to express a program as text—usually contained in files. Files can be translated into low-level machine code or assembler for a target computer type by a computer program called a compiler. A cross compiler is a compiler that runs on one computer and produces machine code targeted for a different type of computer. A native compiler runs on the target computer or a computer of the same type. The resulting low-level machine code is placed in an executable file. The file can be loaded into memory to run on the target computer.
A compiler will not compile programs that do not comply with its grammar, which is the basis for programming language definitions. Some aspects of a programming language are lexical or word-based. For example, certain keywords are used to express certain language ideas and instructions, similar to verbs. Special characters or character groupings like '=' or '+=' or ';' have properties similar to keywords. Identifiers are similar to nouns, and can take any alphanumeric name, excluding spaces, which allows complicated names to be used.
When defining the syntax of a grammar, the use of angle brackets like <numeric_expression> or <file_name> for example, indicates any text that matches the named type. Comments appear after //, and remain comments until the end of the line of text. A simple syntax is defined by the following example:
<variable_identifier>=<numeric_expression>; //assign value to variable
Variable names are types of identifiers that can hold values. For example, the syntax above matches only the first two lines of text below:
my_value=1+3; //match: left side is variable, right is numeric constant
counter=4.3; //match as above
a+b=3; //no match as a+b is not an identifier.
The compiler itself can perform some compile-time calculations on a program, such as evaluating constant numeric expressions. Other calculations depend on input to the compiled program when it is running. These calculations are run-time calculations, which are performed when the compiled program is running on a computer.
An array is an arrangement of information in one or more dimensions, such as a 1-dimensional list, or a color component of a 2-dimensional image. Multi-dimensional arrays are those with two dimensions or higher. The individual data items in the array are called elements. All elements in the array are of the same data type; and therefore all elements in the array are also the same size. The array elements are often stored contiguously in the computer's memory, and the subscript or index of the first element is normally zero in all the dimensions applied to the array. The array name, the element data type, the number of array dimensions, and the size of each dimension are all declared in some manner. Each occurrence of the array name in a program is an array identifier. The element data type also can yield the element size.
A pointer is a reference to an address in the computer memory. De-referencing a pointer provides access to the data in the memory that it points to, either to read the memory data, or over-write it with new data. An array identifier contains a pointer to the base address of the array in memory. The base address is the memory address of the first element in the array.
Processors are used in many different environments. For example, processors are used to perform the central processing tasks in a general-purpose computer, and are used to perform the more dedicated processing tasks of a device embedded in an appliance. A processor is a device that is programmed to execute a sequence of machine instructions stored in memory. Two characteristics that distinguish processors include the set of tasks they are expected to perform, and the speed at which they execute the tasks.
Digital Signal Processing (DSP) is a common term used to describe algorithms or special sequences of arithmetic operations on data to perform various functions. This data is usually represented in arrays. Typical examples include motion estimation, data compression and decompression, filtering, and re-sampling. DSP tasks are relatively easily described in a software program that is compiled to run on a processor. In comparison to a dedicated hardware design, processors provide flexibility as they facilitate algorithm changes.
In most DSP applications, the size of arrays can only be established at run-time. The C89 standard does not support run-time variable-length multi-dimensional arrays, making DSP coding difficult in the C language. The C99 standard addresses this shortcoming by including support for variable-length automatic arrays. C99 also includes the ability to declare arrays anywhere in the code, and to declare arrays of any number of dimensions and size, using expressions for each dimension that can be evaluated at run-time. The compiler generates machine code to allocate memory to store array elements before the elements are accessed. At the machine level, memory allocation usually occurs in units of bytes. A byte is the smallest processor-addressable unit in memory, which usually is 8 bits. The amount of memory allocated in bytes is equal to the total number of array elements multiplied by the element size in bytes. The compiler must also generate machine code to allow array element access, so that a processor can read or write data into array elements.
Subroutines are, as their name suggests, routines or functions that are called from another routine. A routine often calls subroutines to reduce its own complexity and enhance its effectiveness. In fact, almost all routines are called, and they are therefore subroutines too. Useful subroutines tend to encapsulate or embody a useful programming concept into a single re-usable block of code. Subroutines can be designed to be re-usable in many different situations, and they may be called from many different places.
Automatic storage is declared storage that is only available after its declaration, and only within the scope of a block of statements in which it is declared. The storage is released when code execution leaves the block.
The heap represents a pool of available memory that is usable by programs running on a computer. Subroutines are used in C to dynamically allocate a contiguous region of memory and free it after it is no longer needed. For example, C code syntax such as:
is often used. The sizeof(<element_type>) expression obtains the size of each array element in bytes from the element type. The malloc( ) function requests memory in byte quantities at run-time. The malloc( ) return value is a pointer to the allocated memory base address. This value is stored for use as a handle to the allocated memory. The memory is dynamically allocated. In other words, at run-time, an amount of memory is requested and then allocated. A handle is a value that can be used to selectively access an object as a whole (in this case, the object is the allocated memory). A handle is usually a pointer into memory that is used to select an object as a whole. In this case, the handle can be given to free( ) to free the dynamically allocated memory resource. In C, this value is also a pointer, but given its other role, it is preferable that a handle should not be modified using pointer arithmetic. The handle value could be modified and restored, but this practice is dangerous in mid-level languages, and not even allowed in high level languages.
The new C99 standard provides variable length array support so that as far as the programmer is concerned, the malloc( ) and free( ) calls are not explicitly required for dynamically allocated array element storage. This is very different from the C89 standard which required these functions for variable sized arrays. For example, in C99, a two-dimensional array can be declared using:
wherein <width_expr> or <height_expr> use expressions that must each evaluate to an integer at run-time. The underlying implementation of array element storage allocation in variable length arrays by the C99 compiler is not defined. Array element storage allocation in a typical compiler may therefore use the malloc( ) and free( ) functions, as these functions are generic and commonly available. A C99 variable length array declaration can occur anywhere within a block of program statements in a subroutine prior to use. The scope of the array is automatic, i.e. array access is limited to within the block of statements in which it is declared. For example, array element writes to the two-dimensional array declared above can use assignment statement syntax of the form:
Array elements can also be read as a value in expressions.
By convention, major dimensions represent array sizes or access indices in higher dimensions. The most major dimension is represented as the left-most term in square brackets following an array identifier. In contrast, minor dimensions represent lower-dimensional array sizes or access indices to the right. The <row_index> is major in the array access expression above, and the column index is minor. In the C language, according to the two-dimensional array declaration and access above, the values of <row_index> should be in the inclusive range 0 to <height_expr>−1, i.e. the most major index should comply with the size of the corresponding most major dimension size in the array, and so on down the more minor indices. If the number of indices applied to an array exceeds the declared array dimensionality then the remaining "unused" indices are applied to the array element by the compiler. This implies that the array elements must be arrays themselves in this case. If not (that is, all the indices cannot be used up), then there is a programming error. If the number of indices is less than the declared dimensionality, then the elements are arrays themselves, with sizes corresponding to the remaining unused declared minor sizes.
In hardware, memory is accessed as one-dimensional contiguous storage that is indexed by the memory address. In C, a base address is provided for an allocated region of memory, and then one-dimensional array access can be achieved by adding an index offset (scaled by the array element size) to the base address. If the base address is a memory pointer referenced by an array identifier in the C code, and if the type of data pointed to by the pointer is declared as the array element type, then the size of the elements are known at compile time. This allows the compiler to generate machine code to allow array elements to be accessed using a one-dimensional index without knowing anything about the size of the array.
An array base address passed down to a subroutine may actually have various attributes, such as its base address, and the number and size of its dimensions. The C99 standard treats array references as base addresses, so a compiler only knows about array attributes from their declarations within the scope of a block. In the C language, each subroutine can be separately compiled, so if a subroutine calls another and passes an array reference, a simple base address cannot contain array attribute information. The C language allows the definition and use of structures, which are aggregates of data. Members of the structure are accessed using the syntax <structure_reference>-><member>. Structures can be defined to include array attribute information, but only a reference to a member of a structure can obtain the array base address. For example, array->base_address[row][column] can be indexed. This syntax is cumbersome.
C99 declared arrays are either implemented as arrays of arrays, or by using index mapping expressions. In either case, multi-dimensional array access is slow. The array-of-arrays implementation uses a one-dimensional array to store references to other base addresses of sub-arrays in memory. Each sub-array may contain references to other arrays, etc. The number of array dimensions defines the number of one-dimensional array accesses required to obtain the desired array element. The index mapping approach performs calculations on sets of indices to map them onto an equivalent single index used to access an element from the one-dimensional array memory. In this case, an additional multiply is required for each additional array dimension.
To improve the execution speed of compiled C programs (or any mid-level programming language), index ranges are not automatically checked at compile-time or run-time. If out-of-bounds array indices are used, the underlying array access mechanism may access memory outside that allocated for the array, possibly causing a running program to terminate.
Many C programmers try to improve program speed in C by recognizing that for many algorithms, array elements are often accessed sequentially. Therefore memory access patterns such as: write to A[0][0], write to A[0][1], write to A[0][2] . . . are common. Programmers may write code to avoid indexing altogether, and instead use pointer arithmetic. For example, the code A[0]=1; A[1]=2; A[2]=3; . . . can be replaced by A[0]=1; A=A+1; A[0]=2; A=A+1; A[0]=3; A=A+1; etc. In other words, the memory pointed to by A is repeatedly written to, and then the pointer A itself is changed. The cumulative changes to the pointer A must be correct for the code to operate correctly, otherwise A may point outside of the original array bounds.
Since execution speed is important within a DSP environment, mid-level languages like C are often used with pointer arithmetic. The result is code that is complex and fragile, as it relies on the correct accumulation of address calculations throughout the entire program. Also, using pointer arithmetic makes programs harder to understand and maintain, because valid pointer de-referencing depends on correct prior address calculations. These calculations could be spread out in the program, so they have to be understood over a large scope before each instance of a de-reference can be understood.
Many programmers have to deal with legacy code. They may have to write new code to replace a lower level subroutine, and deal with pointers to arrays as inputs to the subroutine. It would be helpful if the programmer could access the memory as an array, rather than using pointer arithmetic. The C99 standard supports declaring a variable size array input to a subroutine, but it does not support the use of general expressions for array sizes within declarations. In many situations, legacy code may pass down an array base address, and other array information that is used by a subroutine to perform various array-based tasks. There is a requirement to be able to access this data using an array view based on calculations on the passed parameters. The C99 standard allows an array declaration within a subroutine declaration, and the number and size of array dimensions can be a direct function of the input parameters. However, insertion of non-trivial code in a declaration is not possible, thus limiting its use. In addition, as there is no way to release the view and impose new views within the scope of the subroutine.
Many DSP applications generate an output image based on a source or input image. Information outside of the bounds of the input image is often required to properly generate the output image. For example, digital filters may take several input array elements to generate an output array element. The input elements used are usually clustered around the output element if one visualizes the input and output arrays as superimposed images.
If an output element is at the edge of the output array, then input elements needed to calculate its value may lie beyond the edge of the input array. DSP programmers make decisions about how to treat out-of-bounds indexing, but then they write obscure code to control the behavior of their program at the edges of the source or input image. The intentions of boundary handling code are often not explicit, and the code tends to be very complex and error-prone, particularly when pointer arithmetic and multi-dimensional arrays are being used together.
Therefore, there is a need in the art to provide a system and method that overcomes these problems by including language features that allow programmers to use array indexing schemes instead of pointer arithmetic in both new and legacy code, and allowing the programmer to simply and explicitly specify array access behavior for invalid array access indices.
The above-mentioned problems are addressed by the present subject matter and will be understood by reading and studying the following specification. The invention provides a simple user interface for the most common array access problems, such as those encountered in developing source code for DSP applications. The invention provides an effective method for accessing dynamically allocated memory using indices, and simplifying code to handle invalid indices.
A dynamic overlay provides a method for overlaying a dimensional structure or view on a contiguous memory region starting at a provided base address pointer. The pointer must be a valid reference to within a currently allocated or safely accessible memory region. According to one embodiment, the overlay is declared with the base address, and the array dimensionality and size of the desired view on the allocated memory. The declaration can express array size in terms of expressions that are evaluated at run-time so that programmers have complete control of the view on the data appropriate to their problem. To allow this, the overlay declaration can occur anywhere in the code before the array is to be accessed. Dynamic overlays can be applied to any type of safely accessible memory such as allocated dynamic, automatic, or static types. In a preferred embodiment, the overlay resource behaves like automatic storage because the resource is freed when leaving the body of statements in which it is declared. A new overlay on existing data can be provided by either allowing changes on the dimensionality of an overlay, or in a preferred embodiment, by freeing the overlay resource, and creating a new overlay with the desired view.
A dynamic array combines dynamic allocation of memory with a dynamic overlay. Dynamic array declaration and dynamic array access syntax can be similar to the C99 standard for variable length arrays. One difference is that a handle to a set of dynamic overlay attributes is passed down to subroutines, instead of an array base address, and that these array attributes are then available to the called subroutine. This difference may require minor differences in the array declaration syntax in order to allow the compiler to support both dynamic arrays and the C99 variable length arrays. At run-time, an amount of memory is dynamically allocated that is sufficient to hold the declared array size. In addition, an overlay resource handle is selected and initialized. The dynamic overlay mechanism is then used to enable array access. Both the allocated memory and the overlay object are freed after leaving the subroutine or body of statements in which the dynamic array is declared.
One aspect provides a method of accessing a memory array. Data is provided within a region of memory starting at a base address. A dynamic overlay is declared on the data within a software subroutine or block of statements. The dynamic overlay declaration specifies the number and size of dimensions of the overlay view on the data. The data is then accessed as array elements from within the subroutine or block of statements. The program is then compiled and executed. At run-time, the dynamic overlay declaration causes both a dynamic overlay storage object, and a handle to this object to be provided. The dynamic overlay storage object attributes are initialized from the dynamic overlay declaration. The data is then accessed from within the subroutine or block of statements as an indexed array of elements using the handle and the dynamic overlay object attributes. The dynamic overlay storage object is automatically freed after leaving the block of statements in which the dynamic overlay was declared.
Another aspect provides a method of creating and accessing a dynamic array. A dynamic array is declared within a software subroutine or block of statements. The dynamic array declaration specifies the number and size of the array dimensions. The array elements are then accessed from within a software program block of statements. The program is then compiled and executed. At run-time, sufficient memory storage is dynamically allocated to store all the elements in the declared dynamic array. A dynamic overlay storage object is provided with attributes assigned from the dynamic array declaration. Dynamic array elements are then accessed from within the subroutine or block of statements using the handle and array indices. The array handle provides access to the dynamic overlay object attributes which are then used to facilitate array access. The dynamic overlay storage object and the dynamically allocated memory are both automatically freed after leaving the subroutine or block of statements in which the dynamic array was declared.
Another aspect provides a system, including a computer readable medium, an extended programming language encoded in the medium, and a compiler. The extended programming language includes dynamic array language extensions and dynamic overlay language extensions. The dynamic array language extensions are used to declare a dynamic array and an identifier for accessing the dynamic array elements using indices. The dynamic overlay language extensions are used to declare a dynamic overlay on existing data and create an identifier for accessing the data as array elements using indices. The attributes of dynamic overlays and dynamic arrays are also made available in the language extensions. The compiler converts the extended programming language into machine code instructions that are able to run on a target processor.
According to one embodiment, array boundary policies are applied to both dynamic overlays and dynamic arrays. Boundary policies allow the programmer to extend each declaration to define a policy for re-mapping out-of-bounds indices back to in-bounds indices. This process is called boundary policy enforcement. The index policies can be described in a natural way to, for example, reflect the array at a boundary, extend the array boundary values out to infinity, or surround the array with a constant level outside. Such policies reflect conscious decisions that algorithm developers and programmers make to improve the performance of their algorithms. Conventionally, programmers do not explicitly declare their boundary policies, but rather often write difficult and convoluted code to achieve correct behavior at array boundaries.
Boundary policies can provide memory protection for dynamic arrays because the memory allocation and overlay are defined together such that boundary policy enforcement always ensures valid memory access. Boundary policy enforcement occurs independently for each index. In contrast, an invalid index applied to a conventional index mapping expression may still result in a valid memory access. In the case of dynamic overlays, boundary policy enforcement protects memory accesses if the view lies within valid allocated memory. As the programmer specifies the dynamic overlay independently of memory allocation, the intent of array overlays is to facilitate array access, and not to provide invalid memory access protection.
In one embodiment, dynamic array or dynamic overlay extensions are provided. One embodiment of the dynamic array extension creates a dynamic overlay data structure, and a handle for it. This data structure includes another handle onto memory that is dynamically allocated, as well as array information with which index mapping and boundary policy calculations are made. According to one embodiment, the array information comprises the array height, array width, and array boundary policy. In one embodiment, a two-dimensional index mapping can be overlaid upon a contiguous one-dimensional array of contiguous data. In one embodiment, special hardware is included to regain the performance of array access calculations.
These and other aspects, embodiments, advantages, and features will become apparent from the following description of the invention and the referenced drawings.
The following detailed description of the invention refers to the accompanying drawings that show, by way of illustration, specific aspects and embodiments in which the invention may be practiced. In the drawings, like numerals describe substantially similar components throughout the several views. These embodiments are described in sufficient detail to enable those skilled in the art to practice the invention. Other embodiments may be utilized and structural, logical, and electrical changes may be made without departing from the scope of the present invention. The following detailed description is, therefore, not to be taken in a limiting sense, and the scope of the present invention is defined only by the appended claims, along with the full scope of equivalents to which such claims are entitled.
There are several aspects associated with the invention that combine in such a way as to allow simplification of DSP source code, while also showing that with a few special additional processor machine-code instructions, the compiled code can run faster than C code using address arithmetic.
The term "dynamic array" is used to describe a combination of run-time dynamic allocation and a dynamic overlay array access mechanism. It is noted that others have defined "dynamic arrays" as arrays that appear to automatically increase their size to accommodate any hither-to out-of-bounds index used to access an array. In fact, some "weakly typed" computer languages like Perl support only this type of dynamic resizing of arrays rather than using any form of strongly typed array declaration. This type of programming specification leads to undetected program indexing errors, and is not useful in DSP code where the dimensional organization of the input array data is known. The term "dynamic array" is not used herein to define dynamically resizable arrays; but rather, as stated above, is used to describe the combination of a run-time dynamic allocation and dynamic overlay array access mechanism.
One aspect provides a method for writing simpler array processing code using dynamic arrays, dynamic overlays, and array indices instead of pointer arithmetic. As DSP programming often requires the fastest possible system performance, the only way programmers will abandon using pointer arithmetic is by speeding up array index access using a modified processor with dedicated dynamic overlay machine-code instructions and support hardware. In one implementation, some simple extensions to the C language standard are proposed.
The following code is an example showing the use of dynamic array extensions to the C language:
int Find_Sum(int n, int m) { // DYN_ARRAY prefix tells compiler that this declaration is // different from C99 variable length arrays DYN_ARRAY int arry[n][m]; // pass arry as pointer to cda_array structure with attributes return(Sum2d(arry)); } int Sum2d(dyn_array *arry) // dyn_array is the array attribute structure type { int row, col, sum; // don't allow indexing outside the array array−>boundary_policy = ABORT_OUTSIDE_BOUNDARY; sum = 0; // height and width are attributes of 2-d dynamic array // so systematically read the entire input array using loops for(row = 0; row < arry−>height; ++row) for(col = 0; col < arry−>width; ++col) sum += arry[row] [col]; // sum all array elements return(sum); }
According to one embodiment, the arry reference used above is a handle to an aggregate storage structure that contains attribute values including "boundary_policy", "width", and "height". The array attributes are used directly in the second subroutine, making the code easier to read and maintain. According to one embodiment, the arry handle is also accessed as both a structure and as an array in the sum loop as array[row][col], something that the C99 grammar does not allow. In the C99 language, the array width and height have to be passed as separate parameters in the function call, with more likelihood of programmer error.
For true multi-dimensional support, an array attribute can reference a one-dimensional array of sizes for the required number of array dimensions. In practice, higher dimensional arrays are rare in code, so it may be practical to set an upper limit in the dimensionality supported with dynamic overlays. In one embodiment, for up to three declared array dimensions, a program can access array attribute using names like "width" (for the minor dimension), "height" (for two or three-dimensional support), and "depth" (for three-dimensional support only) to describe the array dimension sizes. A fixed limit on the number of dimensions also allows dedicated fast hardware storage to be used for dynamic overlay attributes.
At compile time, the array element type and element size attributes are known. According to one embodiment, the array element storage memory size is dynamically calculated and allocated at run-time, and the returned base address value is copied into the dynamic overlay structure's base address attribute.
According to one embodiment, the compiler protects array attributes set from an array declaration from being over-written. Protected attributes include the base address, dimensionality, array dimension sizes, and element size.
According to one embodiment, dynamic arrays are given an additional attribute called an array boundary policy. This policy states what should occur if an out-of-bounds array access occurs. Most DSP algorithms take several array input elements to support and generate each output array element. This means that code is usually written to systematically fill an output array based on its declared size. The algorithm then calculates what input elements it needs based on the output element on which it is currently working. When working on generating some output elements near the output array boundary, this behavior could require supporting elements from the input array that are beyond its boundary. Therefore, array reads naturally go out of bounds, and array writes usually do not. Conventionally, programmers go to great lengths to detect invalid array read accesses and suppress them by modifying their algorithms to make some sort of assumption on how to 'fill in' the missing values based on the available input array values. This conventional boundary code is often messy and error prone, and is potentially slow. The present subject matter allows a programmer to explicitly state the behavior required using the array boundary policy attribute rather than writing special boundary code.
A boundary policy attribute assigned to an array results in run-time boundary policy enforcement on the array indices used for array element access. In the simple example above, the algorithm reads all the input array elements systematically, so an out-of-bounds read access is not acceptable, and it is appropriate to abort the program for array element access outside the array boundary.
Only two boundary policies make sense when writing an array element to an index outside of the ranges permitted by the array declaration; either the element is not written, or the program is aborted to signal an out-of-bounds error. The former is useful if an algorithm works in fixed size sub-blocks that do not align with the output array boundaries. The possibilities for array element reads are much richer in scope. Potential read policies include: abort if outside the boundary; surround the array with a constant value outside the boundary; independently clip each applied index to its declared boundary range and read the array element at the clipped index value; and perform odd or even reflection of the array at its boundaries. As a reflection example, a two-dimensional image array 'arry' is defined with its top left element at arry[0][0], its minor index selects an image column, and its major index selects an image row. Indexing beyond the left boundary of the image to element arry[0][−1] can be odd-reflected to arry[0][1]. For odd reflection policies, the pixels at the reflection boundary appear only once (i.e., arry[0][0] reflects to the same arry[0][0]). An even reflection would duplicate the boundary elements, so arry[0][1] reflects to arry[0][0], and arry[0][−2] reflects to arry[0][1], etc. For simplicity, an extreme index reflection that extends beyond the opposite side of an array is limited to the far edge index.
For dynamic arrays, attribute write protection combined with boundary policy enforcement gives array access protection. For one-dimensional arrays, this protection is similar to the run-time checking provided in languages such as Java.
The differences between dynamic arrays and C99 variable length arrays require different compiler handling. The DYN_ARRAY prefix is added to help the compiler generate the appropriate machine code in each case. In some restricted situations, a compiler could implement C99 variable length arrays using dynamic arrays.
According to one embodiment, a boundary policy is specified independently for each dynamic overlay structure. The policy selected is that which is most appropriate for the algorithm that is operating on the array at the time. Therefore, according to this embodiment, the boundary policy is not a protected attribute. Different algorithms may be applied to the same set of array data, which may require the array to have different boundary policies set for each algorithm stage. To allow the policy to be changed during program execution, it is preferable that an array boundary policy is set as an attribute, and not as part of an array declaration.
Dynamic array handles passed into a subroutine or function must be declared in function prototypes as having a special type. In the example above, the second subroutine includes the special dyn_array type within its declaration:
The compiler is then able to generate the correct array indexing instructions. The dyn_array handles that are passed into subroutines cannot be overlaid, freed or otherwise manipulated inside the subroutine. They can only be used for indexed array access, unprotected attribute changes, or as references to be passed down further into other subroutines.
A dynamic array declaration defines an array with attributes that do not normally need to be changed after the declaration. The dynamic array represents a "scratch-pad" array that can be used within a block of statements and then discarded when leaving the block, similar to automatic variable-length arrays in C99. In the case where memory is allocated and packed with multi-dimensional data, and the memory base address is passed elsewhere (into a subroutine for example), one needs to be able to impose an array access view on pre-existing data, rather than create a new array. A dynamic overlay can provide a view on existing data. This feature is partly available in C99 by declaring the dimensionality of the array at the subroutine input as a function of other input parameters. The problem with C99 is that overlaying a view is limited by the code executable inside a subroutine declaration. Furthermore, the scope of the C99 subroutine does not allow multiple overlays to be dynamically created and destroyed, as may be required within a loop for example.
If an existing memory reference identifier is used in the overlay declaration, then the overlay declaration can either specify a dynamic overlay handle with a new name, or if this is not provided, the compiler can usurp the array name. For example in 2 dimensions, usurpation can be declared using syntax like:
The <array_reference> must already have been defined as a pointer; otherwise there is no reference to usurp. Usurping names allows the use of dynamic overlay declarations to be very similar to dynamic array declarations, except that the element type is taken from the element type pointed to by the usurped memory reference. If the array name is usurped, then all subsequent array access code applied to the array reference in a program is compiled to use the dynamic overlay array access mechanism with the dynamic array handle, rather than compiled for normal C array access. When program control flow exits the statement block in which the overlay is declared, then the base address reference is no longer usurped and the compiler allows the array reference to be used as a base address or pointer in a conventional C manner. As the overlay is no longer used, the corresponding overlay resource is freed after its last use. The overlay resource is then available for new dynamic array or dynamic overlay declarations subsequently created at run-time. The memory pointed to by the base address attribute is not freed, because, unlike the dynamic array case, it is not known if this pointer is a handle. Instead, the base address may be from static or automatically allocated memory, or derived using pointer arithmetic.
The present invention is illustrated by way of an example of a dynamic array program disclosed in Tables 1, 2 and 3. As the scope of the present invention is defined by the appended claims and the full scope of equivalents to which such claims are entitled, the following example disclosed in Tables 1, 2 and 3 and in the supporting description should not be read to limit the present invention.
Referring to Table 1, the DYN_OVERLAY prefix is used in front of the first declaration, instead of DYN_ARRAY. In both types of declaration prefixes, multiple arrays of the same element type can be declared in the same line.
To explain the compilation process, the Filter( ) function of Table 1 is first compiled into conventional C89 code, using added functions that are called to implement the required array creation, array access and array freeing mechanisms. The added functions can be implemented by those skilled in programming art after reading the description of the current invention. The compilation stage uses a compiler program to recognize the C with extensions, and generate a standard C output file, as in Table 2 for example. The C code of Table 2 can be compiled with the added functions to run on a target processor. In one embodiment, the compiler compiles directly from the C with extensions to machine code for the target processor, using techniques well known in compiler art. The result is that the compiled program executes relatively slowly. If special hardware with new machine instructions is available, then the compiler can replace the added function calls with relatively few instructions that can execute much more rapidly. The nature of the special hardware is described later. In other embodiments, the extensions are modified appropriately to apply to languages other than C. This application may result in increased program execution speed when array accesses are used with the special hardware. Mid-level languages may also experience a gain in run-time robustness due to boundary policy enforcement.
The languages chosen for extension will determine the availability of compilers. The Filter( ) function is provided only as an example of extensions to the C language. One skilled in the art would be able to write other functions more appropriate to a particular problem, and expressed in their chosen language for which an extended-language compiler is available.
Referring to Table 2, function calls are used to implement some of the code expressed in Table 1. Dynamic arrays and dynamic overlays are created using Create—1d( ) and Create—2d( ) for one-dimensional and two-dimensional arrays respectively. NULL is passed as the base address reference to indicate a dynamic array declaration, so that memory is dynamically allocated inside the create functions. Overlay resources are freed using Free_Overlay( ). Arrays are accessed using get1( ) and get2( ) for one-dimensional and two-dimensional reads respectively, and put1( ), put2( ) for one-dimensional and two-dimensional array writes respectively. In the case of compiling from Table 1 to Table 2, the sequential program flow remains unchanged. The translation mostly consists of code substitutions. An exception is if Table 2 is C89 code, where declarations and executable code cannot mix. In this case, the dynamic array and dynamic overlay declarations also result in the insertion of additional separate handle declarations before the code body. For example, dyn_array *src=NULL declares and initializes a handle named src. In C99, this separation is not required. The substitutions of array access code with function calls are therefore understood by examining the differences between Table 1 and Table 2.
A dynamic array declaration results in a call to dynamically allocate memory of the declared size at run-time, and then a dynamic overlay is created over of the allocated memory. A dynamic array behaves like automatic array storage, so that when leaving the block of statements in which it is declared, both the dynamic overlay resource and the dynamically allocated memory are freed. In practice, a special function or hardware instruction is implemented and used by the compiler to free dynamic overlay resources. For example, a Free_Overlay( ) function call is used in Table 2 to free all overlay resources. The calls to dynamically allocate and free memory are encapsulated inside the calls for creating and freeing dynamic arrays and dynamic overlays. This allows any type of memory allocation mechanism to be used without changing Table 2.
If usurpation is used and the Free_Overlay( ) function is made available to the programmer, then an explicit Free_Overlay(<handle>) subroutine call requires that on all subsequent <handle> references, the compiler should correctly undo usurpation of the <handle> and re-associate all subsequent program references with the original overlaid base address.
According to one embodiment, a dynamic array declaration results in the run-time allocation of a dynamic overlay attribute storage resource and a run-time dynamic allocation (e.g., by using malloc( )) of array element storage memory, and the assignment of the memory base address to the array base-address attribute. When the dynamic overlay structure storage resource is later freed, the base address attribute is used as a handle to free the dynamically allocated memory in the appropriate manner. According to one embodiment, automatic memory allocation from the stack (e.g., using alloca( )) can dynamically allocate array element storage memory, thereby avoiding the need to explicitly free the memory.
Usurping a memory reference name can be avoided if a new reference name for the dynamic overlay can be given. For example, the following declaration syntax can be used:
In C, two-dimensional arrays are based on so-called row-major or column-minor indexing. In two-dimensions, another useful array attribute is called the array stride. The stride gives the number of elements in the allocated memory from an element to the one above or below it in an adjacent row. The stride attribute value is used in index mapping expressions instead of the width attribute value. The width attribute value is then used exclusively for detecting boundary violations as part of the boundary policy. For a given array, the stride attribute value should be greater than or equal to the width attribute value. The stride value is now used to impose the programmer's view of how to access pre-allocated data in two-dimensional dynamic overlays. The width, height, and boundary policy attributes impose a window on that two-dimensional data view which restricts the array elements that are accessible. C99 does not support boundary policies, so only the stride value has meaning.
Use of the stride attribute is shown in
If an algorithm is implemented with dynamic arrays supporting the stride attribute inside a subroutine, and the values of width, height, stride, and base address, are passed as parameters to the subroutine, then the subroutine can be instructed (e.g., through an additional subroutine parameter) to perform field 1, field 2, or frame processing. As the stride is needed to interpret an overlaid view of existing data, the stride can be part of the overlay declaration as shown by the following example of a declaration syntax:
According to one embodiment, if the stride value is not explicitly set, then the stride attribute value can be set to the width attribute value by default.
For dynamic overlays, changing a view by changing width, height and stride attributes after declaration can make acceleration hardware more complex. According to one embodiment, the attributes obtained from a dynamic overlay declaration are protected as for dynamic arrays. Therefore, changing an existing overlay view on data is accomplished by explicitly freeing the overlay, and then declaring a new one. Replacing dynamic overlays is a fast operation in hardware, as main memory allocation is not required.
Processor performance is usually substantially improved if array access can be made faster. Array indices normally slow down array access, but with dedicated processor instructions and hardware, speedups can occur if: array attributes are stored in dedicated memory ready for fast hardware access; an array handle and multiple array indices are able to be issued by the processor in dedicated array access instructions; boundary policy enforcement is performed in the memory access path from the processor; index mapping expressions are calculated in the memory access path from the processor; a fast array cache is used with slow main memory; and separate paths and caches are used for array element storage verses other data.
A summary of one embodiment of a set of extensions to the C language grammar is shown in Table 3. This embodiment demonstrates the nature and use of the extensions, and the application of those extensions to control hardware for faster array access. When using software emulation of array access hardware, statistical data for array and cache access can be extracted and summarized to help write better software.
The CPU 202 is coupled to and communicates with the cache memories 204 and 206 via memory interface input/output (i/o) paths 212, and 214 respectively. The processor 202 executes dedicated instructions for generating array handle values and indices that are sent via 224 to the block 220 for array access. The block 220 translates each array handle and set of array indices into array element access memory addresses that are forwarded to the CDA cache 222. A data path from the processor 202 to the block 220 also allows programming of memory within that block 220. The block 220 is described in more detail in
If the processor 220 requests access to data already in a cache, then the cache can rapidly return the requested data to the processor. This event is called a cache hit. Otherwise, if the cache does not have the requested data, i.e. a cache miss, then the cache takes the memory requests it receives from the processor and forwards it to the main memory. According to one embodiment, the compiler and processor instruction set separate out instruction, data, and CDA array access into memory requests from the instruction 204, data 206, and CDA caches 222 respectively. The memory arbitrator 208 resolves which cache has access to main memory 210 in the case where there are simultaneous requests for main memory access from different caches (each arising from cache misses).
Generally, cache memory such as the instruction cache memory 204, the general data cache 206, or the CDA cache 222, are each smaller, but much faster than the main memory 210. Cache memory stores a duplicate of certain data from the main memory 210. In particular, the data that was recently read from the main memory 210 has an excellent statistical chance of being read again soon after, so it is kept in the cache memory as long as possible. When a cache miss occurs, the requested data is retrieved from main memory 210, and forwarded to the processor 202. As this new data is not in the cache, the cache also updates its own local memory to store the new data in case the processor 202 needs it again soon.
Caches are considerably more complex for each bit of data storage when compared with main memory. Therefore caches are limited in size relative to main memory. When the cache is full of new data, further requests for new data will cause a cache to discard older data to make way for the new. The discarded data is then written back into the main memory.
Separating the dynamic array cache from the general program and data cache prevents regular data or instruction traffic from interrupting the contiguous nature of array data stored in the CDA cache. This separation also allows the CDA cache to take advantage of the contiguous nature of array data and speculatively load new array data into the CDA cache before it is needed. For a modest size CDA cache (e.g., 4 K Bytes), speculative loading effectively eliminates most cache misses for applications as complex as MPEG2 motion estimation, leading to very high performance, even with relatively slow main memory. This effectiveness allows DRAM (Dynamic Random Access Memory) to be used as main memory, so low-cost DSP processing systems can be built using embedded DRAM (i.e. the DRAM and the DSP processor are in the same IC). Embedded DRAM also allows very wide data busses between main memory and the CDA cache, so that parallel DSP processing can result in extremely high performance, and yet still be cost effective. Using indices for array access in programs makes it relatively simple to write compilers to generate code for CDA based parallel processing systems. In contrast, conventional C compilers and hardware do not separate out array data requests from other memory access requests, so a lot of unused data ends up being loaded, and speculative loading techniques are relatively ineffective in this case.
A finite number of arrays handles are simultaneously supported in hardware because of the hardware overhead required to store the attributes associated with each array handle. Therefore only a small number of control bits are needed to represent the handle selection. In one embodiment, a maximum of 32 arrays can be supported, which can be selected using 5 bits within dedicated processor array-handle-access instructions. This small number of bits frees up other processor bits within the dedicated instructions to be used for other purposes such as array index values. For example, two-dimensional array reads can be accomplished in one dedicated 32-bit processor instruction that emits two 12-bit immediate index values and the 5-bit handle value, with 3 remaining bits for instruction decoding.
When an array handle value 334 is presented to the attribute memory 330, the required set of attributes 336 and 338 are obtained as a memory lookup. The width, height and boundary policy attributes 336 are applied to the boundary policy enforcement unit 340 along with the row and column indices 334 from the processor. Based on the boundary policy attribute, a set of confined indices 342 is obtained. The confined indices 342 are forwarded to the index mapping calculation hardware 344, which also takes the stride, element size, and base address values 334 from the memory lookup 330 to calculate the element address 346. The element address 346 is forwarded to memory via the CDA cache 322, along with read/write control, data, and any other items needed for memory access.
* {1,4,6,4,1} 5-tap gaussian horizontal, {1,2,1} 3-taps gaussian vertical down-sampling filter.
* C language with dynamic array and dynamic overlay extensions. Boundary policies are also used.
* Both 'src' and 'out' arrays must be pre- allocated to w*h and (w/2)*(h/2) bytes respectively.
void Filter(char *src, char *out, int h, int w)
int i,j, n;
DYN_OVERLAY unsigned char src[h][w], out[h/2][w/2];
DYN_ARRAY unsigned char t[w];
/* note: 'out' array is never accessed out of bounds so it doesn't need a boundary policy */
SET_ATTRIBUTE t−>boundary_policy = ODD_REFLECT_AT_ALL_BOUNDARIES;
SET_ATTRIBUTE src−>boundary_policy = ODD_REFLECT_AT_ALL_BOUNDARIES;
for (j = 0; j < h; j+= 2)
/* vertical 121 filter, odd symmetric boundary policy extension of src */
for (i = 0; i < w; i++)
t[i] = src[j−1][i] + 2 * src[j][i] + src[j+1][i];
/* horizontal 1,4,6,4,1 filter, odd symmetric boundary policy extension of t */
for (i = 0; i < w; i += 2)
out[j/2][i/2]= t[i−2] + 4*t[i−1] + 6*t[i] + 4*t[i+1] + t[i+2];
# include <studio.h>
# include "cache_dynamic_array.h"
# define DYN_CONVERT(x) x ## —
void Filter (char *src, char *out, int h, int w)
dyn_array *src_ = NULL;
dyn_array *out_ = NULL;
dyn_array *t_ = NULL;
int i, j, n;
src_= Create_2d_((char *) src, h, w, w, "src", sizeof(unsigned char));
Get_Cache_Array_Entry_(src_) −−> unsigned_val = 1;
out_= Create_2d_((char *) out, h>>1, w / 2, w / 2, "out", sizeof(unsigned char));
Get_Cache_Array_Entry_(out_) −−> unsigned_val = 1;
t_= Create_1d_((NULL, w, "t", sizeof(unsigned char));
Get_Cache_Array_Entry_(t_) −−> unsigned_val = 1;
Get_Cache_Array_Entry_(t_) −−> index_policy = ODD_REFLECT_AT_ALL_BOUNDARIES;
Get_Cache_Array_Entry_(src_) −−> index_policy = ODD_REFLECT_AT_ALL_BOUNDARIES;
for(j = 0; j <h; j += 2)
{ /* vertical 121 filter, symmetric extension of src */
for (i = 0; i < w; i++)
n = (get2(src_, j−1, i)) + 2 * (get2(src_, j, i)) + (get2(src_)), j+1, i));
put1(t_,i, ((n + 2) / 4);
/* symmetric extension of t */
for (i = 0; i < w; i += 2)
n = (get1(t_, i−2)) + 4 * (get1(t_, i−1)) + 6 * (get1(t_, i)) + 4 * (get1(t_,i +1)) + (get1(t_, i+2));
put2(out_, j/2, i/2, ((n + 8) / 16));
means 0 or 1 item.
means 0 or more items.
<a> | <b> accepts either item <a> or <b> in syntax.
text other than inside < > is literal.
C++ style comments are not part of extended syntax specification.
Additions to the list of standard C statements:
// overlaying existing and usurping array to be an overlay handle
DYN_OVERLAY <array_spec> (,<array_spec>)? ;
// overlaying existing allocated memory and creating a new handle
DYN_OVERLAY <array_spec> = <base_address>;
// creating a new dynamic array
DYN_ARRAY <type_specifier> <array_spec> (,<array_spec>)? ;
// freeing existing dynamic arrays or dynamic overlays
DYN_FREE <array_ident> (,<array_ident>)* ;
<array_ident> [<int_height>] [<int_width>@<int_stride>]
<array_ident> [<int_height>] [<int_width>]
<array_ident> [<int_width>]
// setting array attributes
DYN_SET_ATTRIBUTE <array_identifier> −> <1_attribute> =
<expr> ;
DYN_GET_ATTRIBUTE <1value> = <array_identifier> −> <r_attribute> ;
r_attribute: default_val_outside_boundary | boundary_policy |
unsigned_val | element_size | width | height | stride |
1_attribute: default_val_outside_boundary | boundary_policy |
// expression values for attribute = boundary_policy
The present subject matter provides a simplified source code that indexes into arrays using explicit boundary policies. The dynamic array and dynamic overlay language extensions provide a simple user interface for the most common array access problems such as those encountered in DSP applications, for example. The language extensions simplify the writing of array-based DSP code, and eliminate most pointer arithmetic and array bounds considerations for DSP applications. The language extensions allow support of various actions for indexing outside of the array boundary. Array index access of dynamically allocated data is simplified since dynamic overlays can impose a structure on any passed array. Including explicit boundary policies in array declarations eliminates the need for complicated and error-prone array boundary code. Dynamic overlays and dynamic arrays behave like automatic data storage, which helps avoid memory leaks, and makes the code simpler and easier to understand. Special hardware, such as boundary policy enforcement, index mapping, and a cached dynamic array (CDA) cache memory, may be used to offset the execution speed that may otherwise be lost using the language extensions of the present invention. The CDA cache memory takes advantage of the contiguous nature of cache addresses for the arrays by using speculative loading techniques to achieve very high cache hit rates.
Although specific embodiments have been illustrated and described herein, it will be appreciated by those of ordinary skill in the art that any arrangement that is calculated to achieve the same purpose may be substituted for the specific embodiment shown. This application is intended to cover any adaptations or variations of the present invention. It is to be understood that the above description, and example contained therein, is intended to be illustrative, and not restrictive. Combinations of the above embodiments, and other embodiments will be apparent to those of skill in the art upon reviewing the above description. The scope of the invention includes any other applications in which the above structures and fabrication methods are used. The scope of the invention should be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled.
|Patente citada
|Fecha de presentación
|Fecha de publicación
|2 Dic 1974
|28 Feb 1978
|Compagnie Honeywell Bull
|Method and apparatus for executing an extended decor instruction
|21 Feb 1990
|2 Feb 1993
|Texas Instruments Incorporated
|Cached random access memory device and system
|21 Nov 1990
|28 Sep 1993
|Benchmarq Microelectronics, Inc.
|Integrated cache memory system with primary and secondary cache memories
|12 Feb 1993
|22 Mar 1994
|Zenith Data Systems Corporation
|Programmable cache memory which associates each section of main memory to be cached with a status bit which enables/disables the caching accessibility of the particular section, and with the capability of functioning with memory areas of varying size
|11 Ene 1995
|20 Feb 1996
|Apple Computer, Inc.
|Memory architecture using page mode writes and single level write buffering
|4 Sep 1990
|11 Jun 1996
|Hyatt; Gilbert P.
|Computer system having an improved memory architecture
|22 Nov 1994
|16 Jul 1996
|Kabushiki Kaisha Toshiba
|Memory device
|10 Dic 1993
|17 Dic 1996
|Cray Research, Inc.
|Method for the dynamic allocation of array sizes in a multiprocessor system
|17 Dic 1996
|12 May 1998
|Intel Corporation
|Method and apparatus for processing memory-type information within a microprocessor
|4 Dic 1995
|2 Jun 1998
|Microsoft Corporation
|Methods for safe and efficient implementations of virtual machines
|5 Mar 1997
|27 Oct 1998
|Monolithic System Technology, Inc.
|Method and structure for implementing a cache memory using a DRAM array
|28 Sep 1995
|27 Abr 1999
|Intel Corporation
|Method and apparatus for providing emulator overlay memory support for ball grid array microprocessor packages
|23 Ene 1997
|11 Ene 2000
|Sun Microsystems, Inc.
|Processor with accelerated array access bounds checking
|14 Oct 1997
|4 Abr 2000
|Advanced Micro Devices, Inc.
|Prefetching data using profile of cache misses from earlier code executions
|5 Sep 1997
|24 Oct 2000
|International Business Machines Corporation
|Data processing system and multi-way set associative cache utilizing class predict data structure and method thereof
|14 Abr 1997
|7 Nov 2000
|International Business Machines Corporation
|Precise method and system for selecting an alternative cache entry for replacement in response to a conflict between cache operation requests
|27 May 1998
|5 Dic 2000
|International Business Machines Corporation
|Real time invariant behavior cache
|30 Jun 1998
|6 Feb 2001
|Sun Microsystems, Inc.
|Apparatus and method for array bounds checking with a shadow register file
|1 Oct 1997
|6 Mar 2001
|Micron Electronics, Inc.
|Method for mapping environmental resources to memory for program access
|28 Ago 1998
|17 Abr 2001
|Hewlett-Packard Company
|Method and apparatus for performing direct memory access transfers involving non-sequentially-addressable memory locations
|27 Abr 2000
|29 May 2001
|International Business Machines Corporation
|Method and system for improving data storage and access for programs written in mid-level programming languages
|20 Oct 1997
|21 Ago 2001
|Fujitsu Limited
|Apparatus and method for high-speed memory access
|4 Jun 1991
|28 Ago 2001
|Silicon Graphics, Inc.
|Method and apparatus for memory access in a matrix processor computer
|14 Sep 2000
|11 Sep 2001
|Kabushiki Kaisha Toshiba
|Semiconductor memory mounted with cache memory
|22 Sep 2000
|16 Dic 2003
|Intel Corporation
|Cache dynamically configured for simultaneous accesses by multiple computing engines
|28 Dic 1999
|16 Dic 2003
|International Business Machines Corporation
|Method and apparatus for generating code for array range check and method and apparatus for versioning
|4 Abr 2000
|6 Ene 2004
|Hewlett-Packard Development Company, L.P.
|Dynamic routing of data across multiple data paths from a source controller to a destination controller
|25 Ago 2000
|13 Abr 2004
|Hitachi, Ltd.
|Method and apparatus for searching multi-dimensional database and storage medium stored search program of multi-dimensional database
|6 May 2002
|30 Nov 2004
|Lewiz Communications
|Multi-protocol memory lookup system and method
|9 Feb 2001
|6 Jun 2002
|Z-Force Corporation
|System for reusable software parts for supporting dynamic structures of parts and methods of use
|2 Mar 2001
|5 Sep 2002
|Yosuke Baba
|Object-oriented program with a memory accessing function
|30 Mar 2001
|3 Oct 2002
|Rakesh Krishnaiyer
|Compile-time memory coalescing for dynamic arrays
|10 May 2001
|14 Nov 2002
|Krick Robert F.
|System of and method for memory arbitration using multiple queues
|10 Jul 2001
|16 Ene 2003
|Micron Technology, Inc.
|Dynamic arrays and overlays with bounds policies
|6 May 2003
|16 Oct 2003
|Arm Limited
|Scratch pad memories
|24 Oct 2001
|22 Ene 2004
|Craig Hemsing
|Apparatus and method to reduce memory footprints in processor architectures
|24 Oct 2001
|14 Oct 2004
|Dave Hylands
|Transferring data along with code for program overlays
|Kandemir et al., Improving memory energy using access pattern classification, IEEE, Nov. 4-8, 2001 pp.: 201-206.
|Park, An efficient buffer memory system for subarray access. IEEE, vol. 12, Issue 3, Mar. 2001 pp.: 316-335.
|Sarawagi et al., Efficient Organization of Large Multidimensional Arrays, 1994, IEEE, pp. 328-336.
|Sheth et al., Real time failure analysis of Cu interconnect defectivity through bitmap overlay analysis, IEEE, Sep. 8-10, 1999 pp.: 8-13.
|Verdoer et al., Access and Alignment of Arrays for a Bidimensional Parallel Memory, 1994, IEEE, pp. 364-356.
|Weinhardt et al., Memory access optimisation for reconfigurable systems, May 2001, IEEE, pp. 105-112.
|Patente citante
|Fecha de presentación
|Fecha de publicación
|18 May 2004
|12 Ago 2008
|Oracle International Corporation
|Product packaging and installation mechanism
|4 May 2006
|18 Ago 2009
|Micron Technology, Inc.
|Caching of dynamic arrays
|14 Ene 2009
|15 Jun 2010
|Commvault Systems, Inc.
|Systems and methods for performing storage operations in a computer network
|30 Abr 2008
|3 Ago 2010
|Commvault Systems, Inc.
|Systems and methods for sharing media in a computer network
|7 Nov 2005
|5 Oct 2010
|Commvault Systems, Inc.
|Methods and system of pooling storage devices
|2 Nov 2005
|5 Oct 2010
|Thomas Plum
|Automated safe secure techniques for eliminating undefined behavior in computer software
|23 Jun 2006
|19 Oct 2010
|Thomas Plum
|Automated safe secure techniques for eliminating undefined behavior in computer software
|22 Jul 2008
|2 Nov 2010
|Commvault Systems, Inc.
|Systems and methods for allocating control of storage media in a network environment
|4 May 2004
|16 Nov 2010
|Oracle America, Inc.
|Method and system for analyzing array access to a pointer that is referenced as an array
|25 Feb 2009
|7 Dic 2010
|Commvault Systems, Inc.
|Method and system for grouping storage system components
|6 May 2005
|21 Dic 2010
|Thomas Plum
|Automated safe secure techniques for eliminating undefined behavior in computer software
|24 Abr 2008
|25 Ene 2011
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing data storage operations
|17 Abr 2009
|24 May 2011
|Commvault Systems, Inc.
|Systems and methods for performing virtual storage operations
|3 Dic 2010
|7 Jun 2011
|Commvault Systems, Inc.
|Method and system for grouping storage system components
|15 Dic 2009
|14 Jun 2011
|Commvault Systems, Inc.
|Pathname translation in a data replication system
|26 Jun 2008
|14 Jun 2011
|Commvault Systems, Inc.
|Pipeline systems and method for transferring data in a network environment
|14 Feb 2008
|14 Jun 2011
|Sandisk Corporation
|Overlay management in a flash memory storage device
|18 Dic 2006
|14 Jun 2011
|Commvault Systems, Inc.
|Network redirector systems and methods for performing data replication
|19 Dic 2008
|14 Jun 2011
|Commvault Systems, Inc.
|System and method for performing auxiliary storage operations
|24 Ago 2009
|13 Sep 2011
|Commvault Systems, Inc.
|Systems and methods for transferring data in a block-level storage operation
|20 Sep 2011
|Commvault Systems, Inc.
|Systems and methods for performing replication copy storage operations
|21 Jul 2010
|4 Oct 2011
|Commvault Systems, Inc.
|Systems and methods for sharing media in a computer network
|21 Ene 2011
|18 Oct 2011
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing data storage operations
|28 Oct 2010
|18 Oct 2011
|Commvault Systems, Inc.
|Systems and methods for allocating control of storage media in a network environment
|1 Oct 2010
|6 Dic 2011
|Commvault Systems, Inc.
|Methods and system of pooling storage devices
|18 May 2009
|13 Dic 2011
|Comm Vault Systems, Inc.
|Systems and methods for performing storage operations using network attached storage
|20 Sep 2010
|27 Dic 2011
|Commvault Systems, Inc.
|Interface systems and methods for accessing stored data
|30 Oct 2008
|24 Ene 2012
|Commvault Systems, Inc.
|Systems and methods for retrieving data in a computer network
|22 Jun 2010
|24 Ene 2012
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing storage operations in a computer network
|27 Oct 2009
|21 Feb 2012
|Commvault Systems, Inc.
|Systems and methods for monitoring application data in a data replication system
|15 Dic 2010
|6 Mar 2012
|Commvault Systems, Inc.
|Systems and methods for combining data streams in a storage operation
|22 Jul 2008
|1 May 2012
|Sandisk Technologies Inc.
|Avoidance of self eviction caused by dynamic memory allocation in a flash memory storage device
|10 Jun 2010
|8 May 2012
|Comm Vault Systems, Inc.
|Systems and methods for performing storage operations in a computer network
|22 Nov 2010
|29 May 2012
|Commvault Systems, Inc.
|System and method for performing an image level snapshot and for restoring partial volume data
|20 Mar 2009
|5 Jun 2012
|Commvault Systems, Inc.
|System and method for performing a snapshot and for restoring data
|19 Jun 2012
|Commvault Systems, Inc.
|Systems and methods for managing replicated database data
|29 Nov 2010
|3 Jul 2012
|Commvault Systems, Inc.
|Email attachment management in a computer system
|13 May 2011
|24 Jul 2012
|Commvault Systems, Inc.
|System and method for performing auxiliary storage operations
|18 Ago 2011
|7 Ago 2012
|Commvault Systems, Inc.
|Systems and methods for transferring data in a block-level storage operation
|10 Nov 2011
|11 Sep 2012
|Commvault Systems, Inc.
|Systems and methods for performing storage operations using network attached storage
|16 Dic 2011
|11 Sep 2012
|Commvault Systems, Inc.
|Interface systems and methods for accessing stored data
|18 Dic 2009
|18 Sep 2012
|Commvault Systems, Inc.
|Rolling cache configuration for a data replication system
|22 Ene 2010
|9 Oct 2012
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|7 Mar 2008
|16 Oct 2012
|Commvault Systems, Inc.
|System and method for automating customer-validated statement of work for a data storage environment
|13 Oct 2011
|16 Oct 2012
|Commvault Systems, Inc.
|Systems and methods for allocating control of storage media in a network environment
|11 Sep 2009
|13 Nov 2012
|Oracle International Corporation
|Dynamic atomic arrays
|21 Dic 2007
|13 Nov 2012
|Commvault Systems, Inc.
|Systems and methods for remote monitoring in a computer network and reporting a failed migration operation without accessing the data being moved
|10 Jun 2011
|4 Dic 2012
|Commvault Systems, Inc.
|Pipeline systems and method for transferring data in a network environment
|31 May 2006
|11 Dic 2012
|Micron Technology, Inc.
|Dynamic arrays and overlays with bounds policies
|3 Oct 2011
|25 Dic 2012
|Commvault Systems, Inc.
|Systems and methods for sharing media and path management in a computer network
|30 Mar 2010
|8 Ene 2013
|Commvault Systems, Inc.
|Data restore systems and methods in a replication environment
|9 Feb 2010
|8 Ene 2013
|Commvault Systems, Inc.
|Modular backup and retrieval system used in conjunction with a storage area network
|7 May 2012
|29 Ene 2013
|Commvault Systems, Inc.
|Systems and methods for performing storage operations in a computer network
|5 Feb 2013
|Commvault Systems, Inc.
|Combined stream auxiliary copy system and method
|23 Ene 2012
|19 Mar 2013
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing storage operations in a computer network
|2 Dic 2011
|19 Mar 2013
|Commvault Systems, Inc.
|Methods and system of pooling storage devices
|2 Mar 2012
|9 Abr 2013
|Commvault Systems, Inc.
|Systems and methods for combining data streams in a storage operation
|10 Sep 2012
|23 Abr 2013
|Commvault Systems, Inc.
|System and method for automating customer-validated statement of work for a data storage environment
|9 Jun 2008
|30 Abr 2013
|Commvault Systems, Inc.
|Modular systems and methods for managing data storage operations
|31 May 2011
|14 May 2013
|Commvault Systems, Inc.
|Method and system for grouping storage system components
|11 Jun 2013
|Commvault Systems, Inc.
|Systems and methods for performing replication copy storage operations
|27 May 2011
|16 Jul 2013
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|30 Mar 2010
|6 Ago 2013
|Commvault Systems, Inc.
|Stubbing systems and methods in a data replication environment
|29 Mar 2010
|6 Ago 2013
|Commvault Systems, Inc.
|Systems and methods for selective data replication
|31 May 2012
|6 Ago 2013
|Commvault Systems, Inc.
|Email attachment management in a computer system
|14 Sep 2012
|13 Ago 2013
|Commvault Systems, Inc.
|Systems and methods for sharing media in a computer network
|19 May 2006
|27 Ago 2013
|Oracle International Corporation
|Packaging multiple groups of read-only files of an application's components into multiple shared libraries
|13 Oct 2011
|22 Oct 2013
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing data storage operations
|27 May 2011
|29 Oct 2013
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|7 Sep 2012
|5 Nov 2013
|Commvault Systems, Inc.
|Systems and methods for performing storage operations using network attached storage
|27 May 2011
|19 Nov 2013
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|24 May 2012
|4 Feb 2014
|Commvault Systems, Inc.
|System and method for performing an image level snapshot and for restoring partial volume data
|13 Sep 2012
|11 Feb 2014
|Commvault Systems, Inc.
|Systems and methods for remote monitoring in a computer network
|15 Dic 2006
|18 Feb 2014
|Commvault Systems, Inc.
|Systems and methods for resynchronizing information
|12 Sep 2012
|18 Feb 2014
|Commvault Systems, Inc.
|Memory configuration for data replication system including identification of a subsequent log entry by a destination computer
|14 Jun 2012
|4 Mar 2014
|Commvault Systems, Inc.
|Systems and methods for managing snapshots of replicated databases
|18 Ene 2013
|4 Mar 2014
|Commvault Systems, Inc.
|Combined stream auxiliary copy system and method
|25 Ene 2013
|1 Abr 2014
|Commvault Systems, Inc.
|Systems and methods for performing storage operations in a computer network
|22 Dic 2006
|6 May 2014
|Commvault Systems, Inc.
|Point in time rollback and un-installation of software
|3 May 2013
|13 May 2014
|Commvault Systems, Inc.
|Systems and methods for performing replication copy storage operations
|30 Mar 2010
|13 May 2014
|Commvault Systems, Inc.
|Stub file prioritization in a data replication system
|23 Ene 2012
|13 May 2014
|Commvault Systems, Inc.
|Systems and methods for retrieving data in a computer network
|7 Sep 2012
|13 May 2014
|Commvault Systems, Inc.
|Interface systems and methods for accessing stored data
|21 Dic 2006
|13 May 2014
|Commvault Systems, Inc.
|Systems and methods for continuous data replication
|26 Sep 2013
|3 Jun 2014
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|14 Sep 2012
|15 Jul 2014
|Micron Technology, Inc.
|Dynamic arrays and overlays with bounds policies
|12 Sep 2012
|29 Jul 2014
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|1 Abr 2013
|5 Ago 2014
|Commvault Systems, Inc.
|System and method for automating customer-validated statement of work for a data storage environment
|5 Mar 2013
|5 Ago 2014
|Commvault Systems, Inc.
|Methods and system of pooling storage devices
|16 Oct 2006
|23 Sep 2014
|The Mathworks, Inc.
|Inferring data types from compiler call site
|2 Ago 2013
|21 Oct 2014
|Commvault Systems, Inc.
|Systems and methods for selective data replication
|23 Dic 2013
|11 Nov 2014
|Commvault Systems, Inc.
|System and method for performing an image level snapshot and for restoring partial volume data
|19 Feb 2014
|18 Nov 2014
|Commvault Systems, Inc.
|Systems and methods for performing storage operations in a computer network
|13 Sep 2012
|6 Ene 2015
|Commvault Systems, Inc.
|Modular backup and retrieval system used in conjunction with a storage area network
|25 Abr 2014
|13 Ene 2015
|Commvault Systems, Inc.
|Systems and methods for performing replication copy storage operations
|31 Jul 2013
|7 Abr 2015
|Commvault Systems, Inc.
|Stubbing systems and methods in a data replication environment
|14 Feb 2014
|7 Abr 2015
|Commvault Systems, Inc.
|Systems and methods for resynchronizing information
|6 Mar 2013
|7 Abr 2015
|Commvault Systems, Inc.
|Hierarchical systems and methods for performing storage operations in a computer network
|6 Mar 2014
|7 Abr 2015
|Commvault Systems, Inc.
|Interface systems and methods for accessing stored data
|5 May 2014
|7 Abr 2015
|Commvault Systems, Inc.
|Systems and methods for continuous data replication
|9 Jul 2014
|28 Abr 2015
|Commvault Systems, Inc.
|Systems and methods for performing data replication
|20 Ene 2011
|28 Abr 2015
|Commvault Systems, Inc.
|System and method for sharing SAN storage
|9 Ago 2013
|28 Abr 2015
|Commvault Systems, Inc.
|System and method for sharing media in a computer network
|28 Feb 2014
|2 Jun 2015
|Commvault Systems, Inc.
|Systems and methods for managing replicated database data in dirty and clean shutdown states
|26 Sep 2013
|11 Ago 2015
|Commvault Systems, Inc.
|Systems and methods for performing storage operations using network attached storage
|23 Dic 2013
|1 Sep 2015
|Commvault Systems, Inc.
|Systems and methods for remote monitoring in a computer network
|6 May 2005
|3 Nov 2005
|Plum Thomas S
|Automated safe secure techniques for eliminating undefined behavior in computer software
|18 May 2004
|24 Nov 2005
|Oracle International Corporation
|Product packaging and installation mechanism
|2 Nov 2005
|15 Jun 2006
|Plum Thomas S
|Automated safe secure techniques for eliminating undefined behavior in computer software
|4 May 2006
|31 Ago 2006
|Micron Technology, Inc.
|Caching of dynamic arrays
|31 May 2006
|5 Oct 2006
|Micron Technology, Inc.
|Dynamic arrays and overlays with bounds policies
|7 Nov 2005
|5 Oct 2006
|Rajiv Kottomtharayil
|Methods and system of pooling storage devices
|19 May 2006
|5 Oct 2006
|Oracle International Corporation
|Packaging multiple groups of read-only files of an application's components into multiple shared libraries
|11 Sep 2009
|17 Mar 2011
|Oracle International Corporation
|Dynamic atomic arrays
|Clasificación de EE.UU.
|717/151, 711/111, 711/170, 717/152, 717/150, 717/153, 711/202
|Clasificación internacional
|Clasificación cooperativa
|Clasificación europea
|10 Jul 2001
Owner name: MICRON TECHNOLOGY, INC., IDAHO
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:SLAVIN, KEITH R.;HU, SHANE C.;REEL/FRAME:011994/0561;SIGNING DATES FROM 20010620 TO 20010622
|6 Feb 2007
|Certificate of correction
|12 Nov 2009
|Fee payment
Year of fee payment: 4
|13 Nov 2013
|Fee payment
Year of fee payment: 8


text:
PowerPoint 2010 – Part I Beginning Concepts
PowerPoint 2010 is Microsoft's powerful slideshow creation software that allows you to produce polished presentations. This course provides an introduction to the main components of the PowerPoint 2010 interface.
This is a self-paced, online course presented in four modules with approximately four hours of content. The course includes access to course content and digital book library for one year.
Benefits of taking a self-paced online course:
- Self-paced course allows you to learn at your own speed
- Online access to the course means you can learn from any computer, at work or home
- Ability to instantly search and access a vast collection of books and other content from the world's leading authorities
- Course and materials library serves as a resource when needing information on PowerPoint 2010
- Course content can be accessed for one full year
Who Should Attend
Individual and business users with basic computer literacy who want to learn about creating professional slideshow presentations.
Benefits and Learning Outcomes
- Create professional-looking slideshow presentations
- Incorporate graphics, themes, tables, charts, diagrams and SmartArt into presentations
- Create photo albums and utilize the built-in screen capture tool
- Add audio clips, video clips, animation and slide transitions
Course Outline/Topics
Course Module 1 – Getting Started with PowerPoint 2010
Get an introduction to the main components of the interface: opening and saving a presentation, working with slides, formatting text and text boxes, and using templates and themes to create professional-looking presentations.
Expected Duration (hours): 1.0
Lesson Objectives
- Identify key elements of the PowerPoint 2010 interface
- Change the view of a presentation
- Open, save, and close a presentation
- Open a template
- Add and format text and text boxes
- Manipulate and organize slides and save a presentation
Course Module 2 – Visually Enhancing PowerPoint 2010 Presentations
Adding simple enhancements through the use of graphics, themes, tables, charts and SmartArt allows you to create more engaging and interesting presentations. This course introduces the various themes and SmartArt features that allow you to add flair to your presentations with colors and shapes to emphasize text and data. Also covered, are the various ways of incorporating diagrams, tables and charts to create a professional and effective presentation.
Expected Duration (hours): 1.0
Lesson Objectives
- Apply and modify a theme
- Create and format SmartArt
- Add WordArt to a slide and edit it
- Add and format a table or chart
Course Module 3 – Adding Images to Presentations in PowerPoint 2010
Photographs, clip art and shapes can help to capture and keep the attention of your audience. This course will show you how to insert, format and apply special effects to your images for maximum impact. Learn how to create a photo album and how to use the new built-in screen capture tool that enables you to capture and embed screenshots of other programs into your slides.
Expected Duration (hours): 1.0
Lesson Objectives
- Insert and format a picture
- Find, insert and format clip art
- Insert and edit a graphic image
- Insert and format a shape
- Apply special effects to an image
- Create a photo album
- Add hyperlinks to text and objects
Course Module 4 – Using Multimedia and Animations in PowerPoint 2010
Make presentations more dynamic by adding audio and video clips to any slide. Learn to directly insert, edit and play video in your presentation, and add audio clips to create attention-grabbing sound effects. New animation tools and slide transitions make slideshows more fluid and interesting. All of these features are discussed in this course.
Expected Duration (hours): 1.0
Lesson Objectives
- Insert a video
- Insert an audio clip and set playback options
- Apply slide transitions
- Apply animations and match animation styles with corresponding uses
- Apply animations to multiple objects on a slide
Dates and locations to be announced.

subset: commoncrawl


text:
Country Star Lee Brice ("I Drive Your Truck") in Conversation
* Additional fees apply. No coupon or promo codes necessary to enjoy the displayed discount price.
The last date listed for Country Star Lee Brice was Wednesday August 21, 2013 / 8:00pm.
Most Popular Music Event Nearby
Danny Elfman: Halloween at Hollywood Bowl -- Tim Burton's Nightmare Before Christmas Performed Live
- Full Price:
- $75.00 - $95.00
- Our Price:
- $55.00 - $75.00
Wonder no more about how to spend Halloween 2015. Put on your most creative Tim Burton-inspired… More
Venue Details
Reviews & Ratings
Featured review from Meloww
view more less of this review
Intimate evening with Country music star singer/songwriter Lee Brice. Entertaining inside look at his past, current music, and future album release. His voice was strong and clear in live indoor setting. The Grammy Museum is a wonderful place to visit and see entertainers.
star this review starred report as inappropriate
star this review starred report as inappropriate
so great! quiet small theater where we could see him super close and hear him sing my favorite songs. this was a great time!
About the Ticket Supplier: The GRAMMY Museum
The GRAMMY Museum explores and celebrates the enduring legacies of all forms of music; the creative process; the art and technology of the recording process; and the history of the GRAMMY Awards, the premier recognition of recorded music accomplishment.


text:
This property is no longer supported by Rent.com. Pricing and description information may not be up-to-date. Check out other great properties in the area, we're sure we can find you the perfect home.
Contact for details
Nice end unit all brick townhouse
Nice and convenient three level end unit all brick townhouse. Home has 3 bedrooms and 3.5 bathrooms, hardwood floor in living and dining room, ceramic tile in kitchen and bathrooms, fully finished walkout basement with large recreation room, den that can be used as a 4th bedroom with full bathroom. This house in a very well cared.
One month rent deposit required and a minimum of 1 year lease agreement.
No Pets. Call for service animal policy.
1 unit
Don't have a Rent.com account? Create one.
Creating an account allows you to acccess your saved and contacted properties on any device. Already have an account?
Log In
We are experiencing technical difficulties at the moment. Please try again later.


text:
The Turkey Trot Coupons
The Turkey Trot Coupons
Deals from popular businesses
View Deal
on Groupon
Up to 31% Off "VeggieTales Live!" Kids' Show
Veggie Tales
5 Seymour St, Montclair
View Deal
on Groupon
40% Off Detox Wrap at Naturopathic Spa
Naturopathic Spa
38-05 Broadway, Astoria
20 Yelp reviews
View Deal
on Travelzoo Local Deals
$69 -- 'Member for a Day' at Apple Ridge: Golf Thru Fall
Apple Ridge Country Club
269 E Crescent Ave, Mahwah
View Deal
on Travelzoo Local Deals
Golf at Renault Vineyard w/Cart Rental, over 50% Off
Renault Winery
72 Bremen Ave, Egg Harbor City
40 Yelp reviews
View Deal
on Groupon
Up to 60% Off Custom Wedding Photo Albums from MILK Books
MILK Tailor Made Books
The Turkey Trot Coupons 2014
The Turkey Trot offers coupons and specials for its products and services on a regular basis. Sometimes you can find daily deals for The Turkey Trot or printable coupons or promo codes found online. It is important to check for opportunities to save any time you plan to visit The Turkey Trot. Yipit makes it really easy to stay on top all The Turkey Trot coupons by searching the web everyday and bringing all The Turkey Trot deals into one convenient location. Sign up for Yipit to get notified any time The Turkey Trot or any other local business that you like has a special available. Enjoy all the best for less with Yipit!


text:
In her circles
16 people
Paramita hasn't shared anything with you.
People are more likely to share with you if you add them to your circles.
Share photos - Picasa and Picasa Web Albums Help
Email photos Click the Email button in Picasa to quickly email selected photos to friends and family, using the emai
Temple Run
Run for your life!The addictive mega-hit Temple Run is now out for Android! All your friends are playing it - can you beat their high scores
TETRIS® free
PLAY THE OFFICIAL TETRIS® GAME – FOR FREE!Get the true Tetris® game – for FREE! Loved by hundreds of millions of players worldwide, this all
COL Reminder
I'm sure, with the COL reminder you didn't forget anything anymore.COL Reminder is a remind-application for your Android phone.Now with MyBa


text:
There are many ways to save money on groceries, such as clipping coupons or buying generic brands in lieu of name brands. However, another way to cut costs is to skip the supermarket altogether to purchase locally grown food. (For related reading, see Is Coupon Clipping A Waste Of Time?)
Often, the food you purchase will be high quality, organic and better for your health than processed foods. Plus, you'll support your local economy. While you may believe that buying locally produced food is difficult, the option is available to you at numerous locations.
The Benefits of Buying Local
1. Taste and Nutrition
Locally grown food tastes better and is generally healthier than produce at national grocers. Because local fruits and vegetables are allowed to ripen before they're picked, they are richer in nutrients than the standard grocery store variety. Most grocery store produce is picked before reaching peak ripeness and sits in storage and transit for a week, if not more.
2. Cost Effectiveness
There are fewer packaging costs, and since the food travels less it can be sold at a cheaper price. Plus, there aren't any middlemen involved in the sale process.
3. Energy Conservation
By purchasing food locally, you are doing your part to decrease our nation's reliance on oil. Food purchased at grocery stores travels an average of 1,500 miles - and when the price of oil spikes, you eventually see a price increase at the supermarket.
4. Environmental Impact
In addition to conserving energy, forgoing the purchase of food that has traveled great distances for locally grown produce lowers your carbon footprint. Furthermore, local farmers typically use fewer pesticides. (For additional reading, see Cheap Steps To Reduce Your Carbon Footprint.)
Where to Find Locally Grown Products
1. Farm Stands
Some farms have roadside stands to sell their products, but you can also purchase fruits and vegetables from a pick-your-own (PYO) farm. You'll get the benefits of locally grown food, and enjoy being outdoors and picking the items yourself or with your family. Another option is to buy homegrown fruits and vegetables from a food cooperative, a grocery store owned and operated by its members. Co-ops typically have high standards of social responsibility, and supply local produce, as well as organic and fair-trade items.
2. Community Supported Agriculture (CSA) Farms
CSA farms are food networks made up of individuals who commit to support a local farming operation. By purchasing a subscription or share in a CSA farm, you will typically receive one box of seasonal fruits and vegetables per week during the farming season. At times, CSAs may also offer dairy and meat products.
3. Farmers' Markets
If you're lucky enough to have one close to you, this is probably the best option for acquiring locally grown food, especially if you're constantly on the go. Farmers' markets feature a wide variety of fruits and vegetables, and typically offer much more than your average grocer. The prices are competitive and the level of quality is equal to, if not better, than foods at the grocery store.
The Effect on the Local Economy
Purchasing locally grown food supports the farmers in your area. The Department of Labor reported 24 million jobs in the U.S. rely on food and fiber industry, so keeping farms in business is important.
Furthermore, when buying from a national grocer, only 18 cents of every dollar goes to the farmer, with 82 cents going to the middlemen. Spending your money locally pumps revenue into your state's economy, keeps dollars circulating in your community, maintains employment for local residents and can help to create more jobs.
The Bottom Line
In some instances, you will find that buying locally grown food is a little more expensive than food purchased at a national grocer. However, the extra costs are negligible when you consider that the benefits far outweigh slightly increased cost. Buying local benefits your health, your community, and the planet, and will make your taste buds happy. Plus, you can also develop a personal relationship with the farmer who grows the food that you and your family eat, and learn more about the process of food production. (For more information, see 22 Ways To Fight Rising Food Prices.)
How Recipe Delivery Services Stack UpRecipe delivery services such as Plated, Blue Apron and Hello Fresh have found a niche market to tap. Does this business model offer investors food for thought?
Home & Auto
Luxury Cars with the Best Resale ValueAutos rarely appreciate in value. But if you want a set of wheels that'll least hold its value over time, these cars can go the distance.
Stock Analysis
How Expensive Is Whole Foods, Really?Learn about Whole Foods Market, Inc., and discover how Whole Foods pricing actually compares to that of other grocery store operations.
Stock Analysis
4 Quick Service Restaurants for Your PortfolioLearn about the four quick service restaurants with attractive investment theses and growth prospects that can be valuable additions to your portfolio.
Stock Analysis
What Makes the 'Share a Coke' Campaign So Successful?Understand how Coca-Cola implemented the successful "Share a Coke" campaign. Learn about the top three reasons why the campaign was successful.
Stock Analysis
The 6 Best Dividend Stocks in the Consumer Staples SectorLearn about the top six companies that make an attractive investment for investors looking for stocks for dividend income investing.
Mutual Funds & ETFs
Top 3 Consumer Cyclical Mutual FundsObtain information on, and analysis of, some of the best performing mutual funds that offer exposure to the consumer cyclicals sector.
Procter & Gamble Restructures, Sheds 100 BrandsAll businesses face adversity, and Procter & Gamble is no exception. We take a look at recent developments affecting this global giant.
Explaining Manufacturer's Suggested Retail PriceThe manufacturer's suggested retail price (MSRP) is just what it describes – the price manufacturers recommend that retailers charge for their goods.
Calculating Cross Elasticity of DemandCross elasticity of demand measures the quantity demanded of one good in response to a change in price of another.
What does marginal utility tell us about consumer choice?In microeconomics, utility represents a way to relate the amount of goods consumed to the amount of happiness or satisfaction ... Read Full Answer >>
What are some common ways product differentiation is achieved?There are many ways to achieve product differentiation, some more common than others. Horizontal Differentiation Horizontal ... Read Full Answer >>
What is the difference between an OEM (original equipment manufacturer) and a VAR ...An original equipment manufacturer (OEM) is a company that manufactures a basic product or a component product, such as a ... Read Full Answer >>
Is the retail sector also affected by seasonal factors?Generally speaking, the retail sector is highly seasonal. Almost invariably, sales in the retail sector are highest in the ... Read Full Answer >>
What has the retail sector evolved to its current structure?Retail is the catch-all phrase for the sale of final goods to consumers; a retail transaction is considered an "end" and ... Read Full Answer >>
Why is product differentiation important in today's financial climate?Product differentiation is essential in today's financial climate. It allows the seller to contrast its own product with ... Read Full Answer >>


text:
Is anyone prepared to solve the NHS funding crisis?
As long as the political taboo on raising taxes endures, the service will be in financial peril.17:05
The Conservatives have failed on home ownership. Here's how Labour can do better
Far from helping first-time buyers, the government is robbing Peter to pay Paul15:38
It's time for the government to think again about Hinkley Point
The government's new nuclear power station is a white elephant that we simply don't need.15:12
Here's how Jeremy Corbyn can win back the Midlands
The Midlands is where elections are decided - and where Jeremy Corbyn can win.14:44
The strange death of boozy Britain: why are young people drinking less?
Ditching alcohol for work.11:44
Apprenticeships remain a university alternative in name only for too many young people
New research shows that those who do the best apprenticeships will earn higher salaries than graduates, but government targets undermine the quality of such schemes.11:41
No, IDS, welfare isn't a path to wealth. Quite the opposite, in fact
Far from being a lifestyle choice, welfare is all too often a struggle for survival.09:41
What Jeremy Corbyn can learn from Orwell
Corbyn's ideas may echo George Orwell's – but they'd need Orwell's Britain to work. It's time Corbyn accepted the British as they are today.09:00
Studying in the UK
The University of Gibraltar opened its doors for the first time last month but not all students from the Rock will want to go there. Mark Montegriffo started his studies in the UK last week and offers his impressions.06 October
"I was killed when I was 27": the curious afterlife of Terence Trent D'Arby
Terence Trent D'Arby's 1987 debut album sold a million copies in three days. The music press went mad for him. Where was there to go but down?09:00
What's to be done about racial inequality?
David Cameron's words on equal opportunities are to be welcomed - now for some action, says Sunder Katwala.08 October


text:
Kevlar Hole-Free Socks
Socrates socks don't need to be replaced because of wear and tear due to their super strong material.
These Socrates Socks are made from a material that you often find in bullet-proof vests, rather than in an everyday clothing item. Spun with military-grade Kevlar Carbon Matrix, the company guarantees that you will never get a hole or worn out bottoms in a pair of Socrates.
Socrates Sock is one of the first to use Kevlar in a business-casual application. The sock is made primarily made from LYCRA freshFX fabric to offer anti-droop while remaining comfortable. The Kevlar sections are carbon threaded around the toe and heel areas where it's usually the first place to see wear and tear.
The idea was conceptualized in Milan, Italy by a former American military member. The project has already received over $20,000 in funding on Kickstarter with 17 days to go. Watch the video below to learn more about the hole-proof socks:
- Share
- | Today
PSFK Labs Presents
The Future of Connected Life
The New Consumer and Their Journey to Effectiveness, Balance & Personal Growth