Reallocation of reclaimable memory region

Abstract

Aspects of the disclosure are directed to reallocation of a reclaimable memory region of a memory between phases. In accordance with one aspect, an apparatus including: a main memory configured for bulk storage requirements; a cache memory coupled to the main memory, the cache memory configured for local storage requirements; and a central processing unit (CPU) coupled to the main memory and the cache memory, the CPU configured to allocate the main memory and the cache memory for at least two phases. And, in one aspect, a method including deallocating a reclaimable memory region within a memory from an overhead code; allocating a first contiguous memory block in the memory for an operational phase; and allocating a second contiguous memory block in the memory for the operational phase.

Description

REALLOCATION OF RECLAIMABLE MEMORY REGIONTECHNICAL FIELD

[0001] This disclosure relates generally to the field of information processing systems, and, in particular, to reallocation of a reclaimable memory region of a memory between phases.

[0002] INTRODUCTION

[0003] Information processing systems may include multiple processing engines, processors or processing cores for a variety of user applications. An information processing system may include a central processing unit (CPU) , a graphics processing unit (GPU) , a digital signal processor (DSP) , an image signal processor (ISP) , a neural processing unit (NPU) , etc., along with input / output interfaces, a hierarchy of memory units and associated interconnection databuses. In addition, the information processing system may include a plurality of peripheral devices which communicate with a processing engine using a plurality of high-speed interfaces. The information processing system may have one or more processing engines with a safety island (i.e., a robust processing engine subsystem for critical functions) which execute certain critical software applications. These critical software applications require an appropriate memory allocation for their proper functioning.

[0004] SUMMARY OF EXAMPLES

[0005] The following presents a simplified summary of one or more aspects of the present disclosure, in order to provide a basic understanding of such aspects. This summary is not an extensive overview of all contemplated features of the disclosure, and is intended neither to identify key or critical elements of all aspects of the disclosure nor to delineate the scope of any or all aspects of the disclosure. Its sole purpose is to present some concepts of one or more aspects of the disclosure in a simplified form as a prelude to the more detailed description that is presented later.

[0006] In one aspect, the disclosure provides reallocation of a reclaimable memory region of a memory between phases. Accordingly, an apparatus including: a main memory configured for bulk storage requirements; a cache memory coupled to the main memory, the cache  memory configured for local storage requirements; and a central processing unit (CPU) coupled to the main memory and the cache memory, the CPU configured to allocate the main memory and the cache memory for at least two phases.

[0007] In one example, the main memory is a dynamic random access memory (DRAM) . In one example, the cache memory is a static random access memory (SRAM) . In one example, the at least two phases include an initial startup phase and an operational phase. In one example, the cache memory includes a reclaimable memory region.

[0008] In one example, the CPU is further configured to allocate a first contiguous memory block of the cache memory for the operational phase. In one example, the CPU is further configured to allocate a second contiguous memory block of the cache memory for the operational phase. In one example, the CPU is further configured to allocate a third contiguous memory block of the cache memory for the initial startup phase.

[0009] In one example, the second contiguous memory block is larger in memory size than the third contiguous memory block. In one example, the second contiguous memory block is allocated to a software code with a lower privilege level than a hypervisor code which is allocated for the first contiguous memory block.

[0010] Another aspect of the disclosure provides a method including deallocating a reclaimable memory region within a memory from an overhead code; allocating a first contiguous memory block in the memory for an operational phase; and allocating a second contiguous memory block in the memory for the operational phase.

[0011] In one example, the method further includes allocating a third contiguous memory block in the memory for an initial startup phase; and allocating a fourth contiguous memory block in the memory for the initial startup phase. In one example, the method further includes executing a hypervisor code and a software code during the operational phase. In one example, the method further includes executing the hypervisor code and overhead code during the initial startup phase. In one example, the method further includes performing memory allocation for the overhead code during the initial startup phase.

[0012] In one example, the overhead code includes removable software which may be removed from the memory when not active. In one example, the overhead code is placed in the reclaimable memory region. In one example, the memory is a static random access memory (SRAM) .

[0013] In one example, the method further includes using the hypervisor code to perform a cleanup operation in the reclaimable memory region after a bootup of the operational phase. In one example, the method further includes using the hypervisor code to load the software code into the reclaimable memory region during the operational phase.

[0014] These and other aspects of the present disclosure will become more fully understood upon a review of the detailed description, which follows. Other aspects, features, and implementations of the present disclosure will become apparent to those of ordinary skill in the art, upon reviewing the following description of specific, exemplary implementations of the present invention in conjunction with the accompanying figures. While features of the present invention may be discussed relative to certain implementations and figures below, all implementations of the present invention can include one or more of the advantageous features discussed herein. In other words, while one or more implementations may be discussed as having certain advantageous features, one or more of such features may also be used in accordance with the various implementations of the invention discussed herein. In similar fashion, while exemplary implementations may be discussed below as device, system, or method implementations it should be understood that such exemplary implementations can be implemented in various devices, systems, and methods.BRIEF DESCRIPTION OF THE DRAWINGS

[0015] FIG. 1 illustrates an example information processing system.

[0016] FIG. 2 illustrates an example of an exception level architecture for a processing engine in an information processing system.

[0017] FIG. 3 illustrates an example of a first memory allocation for two system modules (or images) with different exception levels.

[0018] FIG. 4 illustrates an example of a second memory allocation for two system modules (or images) with different exception levels.

[0019] FIG. 5 illustrates an example flow diagram for reallocation of a reclaimable memory region of a memory between phases.DETAILED DESCRIPTION

[0020] The detailed description set forth below in connection with the appended drawings is intended as a description of various configurations and is not intended to represent the only configurations in which the concepts described herein may be practiced. The detailed description includes specific details for the purpose of providing a thorough understanding of various concepts. However, it will be apparent to those skilled in the art that these concepts may be practiced without these specific details. In some instances, well known structures and components are shown in block diagram form in order to avoid obscuring such concepts.

[0021] While for purposes of simplicity of explanation, the methodologies are shown and described as a series of acts, it is to be understood and appreciated that the methodologies are not limited by the order of acts, as some acts may, in accordance with one or more aspects, occur in different orders and / or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all illustrated acts may be required to implement a methodology in accordance with one or more aspects.

[0022] An information processing system, for example, a computing system with multiple slices (e.g., processing engines) or a system on a chip (SoC) , may require multiple levels of coordination or synchronization. In one example, a slice may include a processing engine (i.e., a subset of the computing system) as well as associated memory units and other peripheral devices. In one example, execution of an application may be decomposed into a plurality of work tasks which are executed by multiple slices or multiple processing engines.

[0023] FIG. 1 illustrates an example information processing system 100. In one example, the information processing system 100 includes a plurality of processing engines such as a central processing unit (CPU) 120, a digital signal processor (DSP) 130, a graphics processing unit (GPU) 140, a display processing unit (DPU) 180, etc. In one example, various other functions in the information processing system 100 may be included such as a support  system 110, a modem 150, a memory 160, a cache memory 170 and a video display 190. For example, the plurality of processing engines and various other functions may be interconnected by an interconnection databus 105 to transport data and control information.

[0024] In one example, the memory 160 and / or the cache memory 170 may be shared among the CPU 120, the GPU 140 and the other processing engines. In one example, the CPU 120 may include a first internal memory which is not shared with the other processing engines. In one example, the GPU 140 may include a second internal memory which is not shared with the other processing engines. In one example, any processing engine of the plurality of processing engines may have an internal memory (i.e., a dedicated memory) which is not shared with the other processing engines. Although several components of the information processing system 100 are included herein, one skilled in the art would understand that the components listed herein are examples and are not exclusive. Thus, other components may be included as part of the information processing system 100 within the spirit and scope of the present disclosure.

[0025] In one example, one or more processing engines in the information processing system 100 may be aggregated into a single integrated circuit known as a system on a chip (SOC) . In one example, the SOC may include the central processing unit (CPU) 120 and other processing engines such as the DSP 130 or the GPU 140. The SOC may also include the memory 160 and the cache memory 170.

[0026] In one example, the information processing system 100 may be part of a wireless device in a wireless communication system. For example, the wireless communication system may conform to a wireless network protocol such as 4G LTE (long term evolution) , 5G NR (new radio) , etc.

[0027] In one example, the memory 160 and the cache memory 170 of the information processing system 100 may be implemented by a variety of memory technologies. In one example, a first memory technology is dynamic random access memory (DRAM) which is a fast, high density volatile memory. In one example a second memory technology is a static random access memory (SRAM) which is a faster speed, lower density volatile memory. In one example, a DRAM may be utilized for bulk storage requirements and a SRAM may be utilized for local storage requirements.

[0028] In one example, the information processing system 100 may have one or more processing engines with a safety island. In one example, the safety island is a robust processing engine subsystem for critical functions which execute certain critical software applications. For example, the safety island may have increased hardware design margins and functional redundancy to attain a higher reliability and availability than other processing engine subsystems. In one example, the safety island may be used to monitor and manage other processing engine subsystems.

[0029] In one example, one critical software application may be an automotive safety application (e.g., advanced driver assistance system (ADAS) ) . In one example, a critical software application requires an appropriate memory allocation for their proper functioning. That is, the memory 160 and the cache memory 170 of the information processing system 100 may need memory management using a memory allocation policy to partition a memory space of a memory technology for the memory 160 and the cache memory 170. In one example, the memory space is a plurality of memory cells where a memory cell is an elemental memory storage area. In one example, the memory space is specified in terms of its storage capacity measured in bits or bytes (i.e., 8 bits) . For example, a 1 Megabyte (MB) memory space stores 1 million bytes (i.e., 8 million bits) of data.

[0030] In one example, the memory space is partitioned (i.e., segregated) for a plurality of software applications, including critical software applications. In one example, the memory allocation policy partitions memory space of a SRAM for the memory 160 or the cache memory 170. In one example, the memory allocation policy may provide a different memory space partitioning for different phases of the processing engine. In one example, the memory allocation policy may provide a different memory space partitioning for an initial startup phase or for a test phase than for an operational phase.

[0031] FIG. 2 illustrates an example of an exception level architecture 200 for a processing engine in an information processing system. In one example, the information processing system is the information processing system 100 shown in FIG. 1. In one example, an exception level is a grouping of processing engine resources which have a common privilege level. In one example, a privilege level is a designation of memory or resource access rights and system management capabilities. For example, a higher privilege level may designate more extensive  memory or resource access rights and greater system management capabilities than a lower privilege level.

[0032] In FIG. 2, an exception level 0 (E0) 210 has a lowest privilege level, an exception level 1 (E1) 220 has a second lowest privilege level, an exception level 2 (E2) 230 has a third lowest privilege level and an exception level 3 (E3) 240 has a fourth lowest privilege level. For example, application software may be designated at E0, an operating system may be designated at E1, a hypervisor (e.g., virtualization manager) may be designated at E2 and a security manager may be designated at E3.

[0033] In one example, a processing engine resource at one exception level may be allocated a first memory space for an initial startup phase and a second memory space for an operational phase. For example, a critical software application (e.g., ADAS) may be executed within the safety island with an exception level 1 (E1) .

[0034] In one example, the critical software application may require J Mbytes of memory space during an operational phase. In one example, there may be K Mbytes of memory space available for the critical software application during an initial startup phase. If K < J, then there is not enough memory storage capacity available for the critical software application during the initial startup phase. In one example, the memory allocation policy needs to reallocate memory resources between the initial startup phase and the operational phase. For example, the critical software application may require 2.2 Mbytes (i.e., J = 2.2) of SRAM memory space for the operational phase, but the memory allocation policy may allow only 2 Mbytes (i.e., K = 2.0) of SRAM memory space for the initial startup phase.

[0035] In one example, the memory allocation policy may provide a different memory space partitioning for an initial startup phase of the processing engine than for an operational phase of the processing engine. That is, for example, the memory allocation policy may partition the memory space of a SRAM in a first partition for the initial startup phase and in a second partition for the operational phase, where the first partition and the second partition are different partitions.

[0036] In one example, the memory allocation policy may specify a reclaimable memory region within the memory space of the memory (e.g., SRAM) . In one example, the reclaimable memory region is a portion of the memory space which may be reallocated between phases.

[0037] In one example, phases may include the initial startup phase, the test phase, the operational phase, etc. In one example, a typical operational scenario starts with the initial startup phase (e.g., a system bootup phase) and then transitions to the operational phase (e.g., executing user applications and performing various background tasks) . In one example, a typical testing scenario starts with the initial startup phase and then transitions to the test phase (e.g., executing various test scripts and gathering test data and performance metrics) . In one example, some system resources are not used or needed for all phases. For example, a test script which is used to exercise certain processing engine functions for performance evaluation or verification may be needed only during the test phase and not in the operational phase. For example, bootup modules, such as built in self test (BIST) , BIST firmware, core power reduction, etc. may be needed only during the initial startup phase and not during the operational phase.

[0038] In one example, test scripts and bootup modules, which are not needed during the operation phase, may be allocated a portion of the memory space which is designated as a reclaimable memory region. In one example, the reclaimable memory region may be reallocated from a first phase to a second phase. In one example, the reclaimable memory region may be reallocated from the initial startup phase to the operational phase. In one example, the memory allocation policy may be executed by a memory protection unit (MPU) or a memory management unit (MMU) .

[0039] In one example, the memory space of the memory (e.g., SRAM) is organized as a plurality of memory words, where a memory word is a group of N consecutive bits. For example, if the memory word is a group of 8 consecutive bits, then the memory word is a group of one byte. For example, if the memory word is a group of 16 consecutive bits, then the memory word is a group of two bytes. For example, if the memory word is a group of 32 consecutive bits, then the memory word is a group of four bytes.

[0040] In one example, the memory words of the memory (e.g., SRAM) may be accessed for reading data or for writing data by specifying a memory address. In one example, the memory space of the memory may be addressed by assigning a unique memory address to each memory word of the memory. For example, the memory address may be specified in hexadecimal notation. For example, the hexadecimal notation may conform to a specific numerical format:  0xZZZZ, where 0x is a prefix used to denote a hexadecimal base and ZZZZ specifies the memory address using a plurality of (e.g., four) hexadecimal numerals (i.e., each numeral being 0, 1, 2, …9, A, B, C, D, E) . For example, 0x0000 specifies memory address 0, 0x0001 specifies memory address 1, etc.

[0041] In one example, a first memory word of the memory may be assigned a first memory address, a second memory word of the memory may be assigned a second memory address, a third memory word of the memory may be assigned a third memory address, etc. For example, the first memory address may be the lowest address value (e.g., 0x0000) , the second memory address may be the second lowest address value (e.g., 0x0001) , the third memory address may be the third lowest address value (e.g., 0x0002) , etc.

[0042] In one example, the memory allocation policy may allocate the memory space among system modules (or images) which have different exception levels. In one example, software system modules with exception level 2 may be allocated a first contiguous memory block with lower memory address values and system modules with exception level 1 may be allocated a second contiguous memory block with higher memory address values.

[0043] FIG. 3 illustrates an example of a first memory allocation 300 for two system modules (or images) with different exception levels. In one example, a first system module 310 (e.g., hypervisor image) is allocated a first contiguous memory block in the memory with memory addresses ranging from a first memory address to a second memory address. In one example, a second system module 320 (e.g., software image) is allocated a second contiguous memory block in the memory with memory addresses ranging from a third memory address to a fourth memory address. In one example, the second memory address value is higher than the first memory address value. In one example, the fourth memory address value is higher than the third memory address value. In one example, the third memory address value is one increment higher than the second memory address value (i.e., the second memory address value and the third memory address value are consecutive integer values) . In one example, the first memory address value is zero (e.g., 0x0000 in hexadecimal notation) . In one example, the fourth memory address value is equal to a maximum memory address value.

[0044] In one example, the first system module 310 (e.g., hypervisor image) with exception level 2 includes hypervisor (HYP) code 311 along with test code 312, core power reduction code  313, BIST firmware 314, BIST code 315, etc. In one example, the exception level 2 for the first system module 310 is assigned by a memory protection unit (MPU) or a memory management unit (MMU) .

[0045] In one example, the second system module 320 (e.g., software image) with exception level 1 includes software (SW) code 321. In one example, the exception level 1 for the second system module 320 is assigned by the MPU or the MMU.

[0046] FIG. 4 illustrates an example of a second memory allocation 400 for two system modules (or images) with different exception levels. In one example, during an initial startup phase, a first system module 410 (e.g., hypervisor image) is allocated a first contiguous memory block in the memory with memory addresses ranging from a first memory address to a second memory address.

[0047] In one example, during the initial startup phase, a second system module 420 (e.g., software image) is allocated a second contiguous memory block in the memory with memory addresses ranging from a third memory address to a fourth memory address.

[0048] In one example, the first system module 410 (e.g., hypervisor image) with exception level 2 includes hypervisor (HYP) code 411 along with overhead code 431 which includes test code, core power reduction code, BIST firmware, BIST code etc. In one example, the overhead code 430 are removable software modules; that is, software modules which are active in one phase and which may be removed from the memory if they are inactive in a subsequent phase.

[0049] In one example, the overhead code 431 is placed into an overlap region 430. In one example, the overlap region 430 is shared between first system module 410 and the second system module 420 at different phases, but not during the same phase. That is, the overlap region 430 is reallocated from the first system module 410 to the second system module 420 when transitioning from the initial startup phase to the operational phase. In one example, the overlap region is part of the first contiguous memory block during the initial startup phase. In one example, the second system module 420 (e.g., software image) with exception level 1 includes software (SW) code 421.

[0050] In one example, a memory allocation policy may specify a reclaimable memory region within the memory space of the memory (e.g., SRAM) . In one example, the reclaimable memory region is a portion of the memory space which may be reallocated between phases. In one  example, the reclaimable memory region may be a portion of the memory space which is allocated to removable software modules (e.g., overhead code 430 in FIG. 4) . In one example, the reallocation occurs between an initial startup phase and an operational phase.

[0051] In one example, during an operational phase, the hypervisor (HYP) code 411 is allocated a third contiguous memory block in the memory with memory addresses ranging from the first memory address to a fifth memory address. In one example, the fifth memory address is less than the second memory address. That is, the third contiguous memory block is smaller than the first contiguous memory block.

[0052] In one example, during the operational phase, the overhead code 431 is not used. In one example, during the operational phase, the overhead code 431 is deallocated memory space in the memory. That is, the overlap region 430 is reallocated from the overhead code 431 in the first system module 410 to the second system module 420 for the operational phase.

[0053] In one example, during the operational phase, the second system module 420 (e.g., software image) is allocated a fourth contiguous memory block in the memory with memory addresses ranging from a sixth memory address to the fourth memory address. In one example, the sixth memory address is lesser than the third memory address. That is, the fourth contiguous memory block is larger than the second contiguous memory block.

[0054] In one example, after reallocation of the reclaimable memory region between phases, the software (SW) code 421 has additional memory space available in the operational phase. In one example, a start address of the SW code 421 is modified to begin at a lowest address of the reclaimable memory region. In one example, the start address modification is performed by a linker script. In one example, the HYP code 411 performs a cleanup operation in the reclaimable memory region after its bootup and subsequently loads the SW code 421 into the reclaimable memory region. In one example, the memory protection unit (MPU) access permission is reconfigured from exception level 2 to exception level 1 for the reclaimable memory region. In one example, the HYP code 411 at exception level 2 and the SW code 421 at exception level 1 access the reclaimable memory region at different phases.

[0055] FIG. 5 illustrates an example flow diagram 500 for reallocation of a reclaimable memory region of a memory between phases. In block 510, commence an initial startup phase. In one example, the initial startup phase includes memory allocation for overhead code. In one  example, the overhead code includes removable software modules, that is software modules which are active in one phase and which may be removed from the memory if they are inactive in a subsequent phase.

[0056] In block 520, allocate a first contiguous memory block in a memory for the initial startup phase. In one example, the memory is a static random access memory (SRAM) . In one example, the first contiguous memory block has memory addresses ranging from a first memory address to a second memory address. In one example, the first contiguous memory block is allocated to hypervisor code. In one example, the first contiguous memory block is allocated to overhead code in a reclaimable memory region. In one example, the first contiguous memory block is allocated to software at a first privilege level (e.g., first exception level) . In one example, the first privilege level is exception level 2. In one example, the first contiguous memory block contains the reclaimable memory region.

[0057] In block 530, allocate a second contiguous memory block in the memory for the initial startup phase. In one example, the second contiguous memory block has memory addresses ranging from a third memory address to a fourth memory address. In one example, the second contiguous memory block is allocated to software code. In one example, the second contiguous memory block is allocated to software at a second privilege level (e.g., second exception level) . In one example, the second privilege level has less privileges than the first privilege level. In one example, the second privilege level is exception level 1.

[0058] In block 540, execute a hypervisor code and an overhead code during the initial startup phase. For example, overhead code includes test code, core power reduction code, BIST firmware, BIST code etc. In one example, the overhead code is placed in the reclaimable memory region.

[0059] In block 550, commence an operational phase. In one example, the operational phase includes memory deallocation for overhead code. In one example, the hypervisor code performs a cleanup operation in the reclaimable memory region after its bootup and subsequently loads the software code into the reclaimable memory region. In one example, a memory protection unit (MPU) access permission is reconfigured from the first privilege level (e.g., exception level 2) to a second privilege level (e.g., exception level 1) for the reclaimable memory region.

[0060] In block 560, deallocate the reclaimable memory region from the overhead code. In one example, the reclaimable memory region may be a portion of the memory space which is allocated to removable software modules.

[0061] In block 570, allocate a third contiguous memory block in the memory for the operational phase. In one example, the third contiguous memory block is allocated to the first system module (e.g., hypervisor code) . In one example, the third contiguous memory block has memory addresses ranging from the first memory address to a fifth memory address. In one example, the fifth memory address is less than the second memory address. That is, the third contiguous memory block is smaller than the first contiguous memory block.

[0062] In block 580, allocate a fourth contiguous memory block in the memory for the operational phase. In one example, the fourth contiguous memory block is allocated to the second system module (e.g., software code) . In one example, the fourth contiguous memory block has memory addresses ranging from a sixth memory address to the fourth memory address. In one example, the sixth memory address is lesser than the third memory address. That is, for example, the fourth contiguous memory block is larger than the second contiguous memory block. In one example, the fourth contiguous memory block contains the reclaimable memory region. In one example, a start address of the software code is modified to begin at a lowest address of the reclaimable memory region. In one example, the start address modification is performed by a linker script.

[0063] In block 590, execute the hypervisor code and a software code during the operational phase. In one example, the software code executes at the second privilege level. In one example, the software code has additional memory space available in the operational phase than in the initial startup phase.

[0064] In one aspect, one or more of the steps for providing reallocation of a reclaimable memory region of a memory between phases in FIG. 5 may be executed by one or more processors which may include hardware, software, firmware, etc. The one or more processors, for example, may be used to execute software or firmware needed to perform the steps in the flow diagram of FIG. 5. Software shall be construed broadly to mean instructions, instruction sets, code, code segments, program code, programs, subprograms, software modules, applications, software applications, software packages, routines, subroutines, objects,  executables, threads of execution, procedures, functions, etc., whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise.

[0065] The software may reside on a computer-readable medium. The computer-readable medium may be a non-transitory computer-readable medium. A non-transitory computer-readable medium includes, by way of example, a magnetic storage device (e.g., hard disk, floppy disk, magnetic strip) , an optical disk (e.g., a compact disc (CD) or a digital versatile disc (DVD) ) , a smart card, a flash memory device (e.g., a card, a stick, or a key drive) , a random access memory (RAM) , a read only memory (ROM) , a programmable ROM (PROM) , an erasable PROM (EPROM) , an electrically erasable PROM (EEPROM) , a register, a removable disk, and any other suitable medium for storing software and / or instructions that may be accessed and read by a computer. The computer-readable medium may also include, by way of example, a carrier wave, a transmission line, and any other suitable medium for transmitting software and / or instructions that may be accessed and read by a computer. The computer-readable medium may reside in a processing system, external to the processing system, or distributed across multiple entities including the processing system. The computer-readable medium may be embodied in a computer program product. By way of example, a computer program product may include a computer-readable medium in packaging materials. The computer-readable medium may include software or firmware. Those skilled in the art will recognize how best to implement the described functionality presented throughout this disclosure depending on the particular application and the overall design constraints imposed on the overall system.

[0066] Any circuitry included in the processor (s) is merely provided as an example, and other means for carrying out the described functions may be included within various aspects of the present disclosure, including but not limited to the instructions stored in the computer-readable medium, or any other suitable apparatus or means described herein, and utilizing, for example, the processes and / or algorithms described herein in relation to the example flow diagram.

[0067] Within the present disclosure, the word “exemplary” is used to mean “serving as an example, instance, or illustration. ” Any implementation or aspect described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other aspects of the  disclosure. Likewise, the term “aspects” does not require that all aspects of the disclosure include the discussed feature, advantage or mode of operation. The term “coupled” is used herein to refer to the direct or indirect coupling between two objects. For example, if object A physically touches object B, and object B touches object C, then objects A and C may still be considered coupled to one another-even if they do not directly physically touch each other. The terms “circuit” and “circuitry” are used broadly, and intended to include both hardware implementations of electrical devices and conductors that, when connected and configured, enable the performance of the functions described in the present disclosure, without limitation as to the type of electronic circuits, as well as software implementations of information and instructions that, when executed by a processor, enable the performance of the functions described in the present disclosure.

[0068] One or more of the components, steps, features and / or functions illustrated in the figures may be rearranged and / or combined into a single component, step, feature or function or embodied in several components, steps, or functions. Additional elements, components, steps, and / or functions may also be added without departing from novel features disclosed herein. The apparatus, devices, and / or components illustrated in the figures may be configured to perform one or more of the methods, features, or steps described herein. The novel algorithms described herein may also be efficiently implemented in software and / or embedded in hardware.

[0069] It is to be understood that the specific order or hierarchy of steps in the methods disclosed is an illustration of exemplary processes. Based upon design preferences, it is understood that the specific order or hierarchy of steps in the methods may be rearranged. The accompanying method claims present elements of the various steps in a sample order, and are not meant to be limited to the specific order or hierarchy presented unless specifically recited therein.

[0070] The previous description is provided to enable any person skilled in the art to practice the various aspects described herein. Various modifications to these aspects will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other aspects. Thus, the claims are not intended to be limited to the aspects shown herein, but are to be accorded the full scope consistent with the language of the claims, wherein reference to an element in the singular is not intended to mean “one and only one” unless  specifically so stated, but rather “one or more. ” Unless specifically stated otherwise, the term “some” refers to one or more. A phrase referring to “at least one of” a list of items refers to any combination of those items, including single members. As an example, “at least one of: a, b, or c” is intended to cover: a; b; c; a and b; a and c; b and c; and a, b and c. All structural and functional equivalents to the elements of the various aspects described throughout this disclosure that are known or later come to be known to those of ordinary skill in the art are expressly incorporated herein by reference and are intended to be encompassed by the claims. Moreover, nothing disclosed herein is intended to be dedicated to the public regardless of whether such disclosure is explicitly recited in the claims. No claim element is to be construed under the provisions of 35 U.S.C. §112, sixth paragraph, unless the element is expressly recited using the phrase “means for” or, in the case of a method claim, the element is recited using the phrase “step for. ”

[0071] One skilled in the art would understand that various features of different embodiments may be combined or modified and still be within the spirit and scope of the present disclosure.

Claims

1.An apparatus comprising:a main memory configured for bulk storage requirements;a cache memory coupled to the main memory, the cache memory configured for local storage requirements; anda central processing unit (CPU) coupled to the main memory and the cache memory, the CPU configured to allocate the main memory and the cache memory for at least two phases.2.The apparatus of claim 1, wherein the main memory is a dynamic random access memory (DRAM) .3.The apparatus of claim 1, wherein the cache memory is a static random access memory (SRAM) .4.The apparatus of claim 1, wherein the at least two phases include an initial startup phase and an operational phase.5.The apparatus of claim 4, wherein the cache memory includes a reclaimable memory region.6.The apparatus of claim 5, wherein the CPU is further configured to allocate a first contiguous memory block of the cache memory for the operational phase.7.The apparatus of claim 6, wherein the CPU is further configured to allocate a second contiguous memory block of the cache memory for the operational phase.8.The apparatus of claim 7, wherein the CPU is further configured to allocate a third contiguous memory block of the cache memory for the initial startup phase.9.The apparatus of claim 8, wherein the second contiguous memory block is larger in memory size than the third contiguous memory block.10.The apparatus of claim 7, wherein the second contiguous memory block is allocated to a software code with a lower privilege level than a hypervisor code which is allocated for the first contiguous memory block.11.A method comprising:deallocating a reclaimable memory region within a memory from an overhead code;allocating a first contiguous memory block in the memory for an operational phase; andallocating a second contiguous memory block in the memory for the operational phase.12.The method of claim 11, further comprising:allocating a third contiguous memory block in the memory for an initial startup phase; andallocating a fourth contiguous memory block in the memory for the initial startup phase.13.The method of claim 12, further comprising executing a hypervisor code and a software code during the operational phase.14.The method of claim 13, further comprising executing the hypervisor code and overhead code during the initial startup phase.15.The method of claim 14, further comprising performing memory allocation for the overhead code during the initial startup phase.16.The method of claim 15, wherein the overhead code includes removable software which may be removed from the memory when not active.17.The method of claim 16, wherein the overhead code is placed in the reclaimable memory region.18.The method of claim 17, further comprising using the hypervisor code to perform a cleanup operation in the reclaimable memory region after a bootup of the operational phase.19.The method of claim 18, further comprising using the hypervisor code to load the software code into the reclaimable memory region during the operational phase.20.The method of claim 11, wherein the memory is a static random access memory (SRAM) .

Images