International Journal of Computer Trends and Technology (IJCTT) – volume 17 number 3 – Nov 2014 ISSN: 2231-5381 http://www.ijcttjournal.org Page 152 Tiling based Compression for Reducing Memory Occupancy of Embedded Applications Dhanashree Kulkarni Abstract— This paper aims to increase the memory system utilization of embedded applications. An approach is presented that inserts compression and decompression calls in the application code to reduce maximum and average memory space consumption. Memory space occupancy indicates the memory space occupied by application data at each point during the course of execution. There are two metrics associated with memory space occupancy namely Maximum memory occupancy (MMO) and Average memory occupancy (AMO). The goal behind the approach presented in this paper is to reduce both MMO and AMO for array/loop intensive embedded applications. Keywords— tiling,data compression, Maximum memory occupancy,average memory occupancy I. INTRODUCTION Many parallel embedded systems execute multiple applications simultaneously, which puts additional pressure on the on-chip memory capacity. For example, much commercial architecture today employ scratch-pad memories (SPMs). However, since an SPM is very small in size when compared to main memory and is shared by multiple data sets (e.g., different arrays) simultaneously, in many cases, some important (critical) data blocks are still left in the off-chip memory. Therefore, for many large data-intensive embedded applications, taking full advantage of the SPM is not possible. As a result, memory space utilization remains one of the most pressing challenges for many embedded execution environments, and there is a growing need for techniques that make best use of the available memory space without hurting application performance significantly. Prior research on memory systems proposed and evaluated several techniques, which can potentially improve the memory performance of embedded software. Power and memory-space efficiency, on the other hand, have received relatively less attention so far. One of the techniques that can be used to reduce the memory space consumption (occupancy) of embedded applications is data compression. The goal of data compression is to represent an information source (e.g., a data file, a speech signal, an image, or a video signal) as accurately as possible using the fewest number of bits. Previous research considered efficient hardware- and software-based data- compression techniques and applied compression to different domains. While data compression can be an effective way of reducing the memory space consumption of embedded applications, it needs to be exercised with care since performance and power costs of decompression (when we need to access data stored currently in the compressed form) can be overwhelming. Therefore, compression/decompression decisions must be made based on a careful analysis of the data access patterns of the application. The experimental results show that the proposed approach reduces both maximum and average memory occupancies significantly. In addition, it shows that it can save more memory space than different alternative techniques present today.. II. RELATED WORK To reduce the size of a program’s code segment, Cooper and Harvey [3] use pattern-matching-based techniques. A reduced instruction set computer system that can directly execute compressed programs is presented in [4]. Very long instruction word processors are also considered in compression-related work [5]–[9]. Data compression is used to reduce storage requirements, bus bandwidth, and energy consumption [10]–[19]. Using a hardware compressor enables faster compression/ decompression, and this has been achieved by various techniques [10], [20]–[22]. . III. DATA COMPRESSION ALGORITHM Employing data compression in managing the memory space of an embedded system requires a careful analysis of the data access pattern of the application under consideration. This is because exercising data compression in an untimely manner can cause significant performance and power penalties. For example, compressing data blocks with short reuse distances can increase the number of decompressions dramatically. Furthermore, decompressing data blocks with long reuse distances prematurely can increase memory-space consumption unnecessarily. Therefore, one needs to be very careful in deciding both the set of data blocks to compress/decompress and the points in execution to compress/decompress them. 1) Data Tiling and Memory Compression: This scheme compresses only arrays that can benefit from data compression. These arrays are referred to as compressible arrays. An array tile can be either compressed or uncompressed. Uncompressed tiles are stored in the decompression buffer,