A Mathematical Model in Support of Efficient offloading for Active Storage Architectures

Transcription

1 A Mathematical Model in Support of Efficient offloading for Active Storage Architectures Dr.Naveenkumar Jayakumar and Mr.Sairam Iyer Department of Computer Engineering, Bharati Vidyapeeth Deemed University, Pune EMC Corporation, Bengaluru. Dr.S.D.Joshi and Dr.S.H.Patil Department of Computer Engineering, Bharati Vidyapeeth Deemed University, Pune Abstract With the advent of big data and 3rd platform application technologies, enterprise class applications are going through rapid transformation. These enterprise class applications are expected to deliver actionable business intelligence as against presenting volume of information drawn from raw data. As these enterprise applications move up in the value chain, they are becoming more and more data intensive thereby increasing the volume of data to be moved between the hosts and the data storage sub-systems. However, the storage IO sub systems dawdled in advancement in consistency with enhancement of processors and memory coerces the system to deliver huge amount of data for execution of the data powered applications due to bandwidth limitation, excessive power consumption, network congestions, and redundant copies of data in the end to end application stack. This bottleneck in the IO path negatively impacts end to end application performance. One good solution proposed by earlier researches is to move the compute intensive tasks of the applications closer to data so as to minimize the amount of raw data transferred between server and the storage. This research paper explores the offload architecture options and analyses the application offload architecture factors influencing the end to end application performance. Keywords Active Storage;Storage Architecture; storage arrays; Performance mode;, Modelling of computer architecture;, Emerging technologies; Parallel I/O; Processors Architecture; Distributed Systems; multiple-processor systems;performance measures; Parallel systems. I. INTRODUCTION Applications in High performance computing are I/O intensive because of their requirement of vast data to be accessed and processed. There is an ever growing gap between the performance of compute and I/O access rates with the current technology of disk drives. Even though if raw capacity hardware like processors and storage are available, it becomes more vital to understand the complexity of scaling and parallelism in order to provide software which increases the performance of the applications in high performance computing. Now days a large class of applications has been developed and deployed in almost all the domains. These applications generate enormous amount of data and process it. These kinds of applications generating, storing, retrieving and processing huge data are called data intensive applications. Since these applications have to interact with the I/O subsystems frequently they are sometimes also regarded as I/O intensive applications. There are many emerging technologies in the storage field like software defined storage, storage virtualization etc., but the question which is been raised is the technologies which is being developed and deployed will able to fulfil the required end to end performance to serve the I/O intensive applications? The answer to the above question relates to the process of improving storage performance and bottleneck identification of the infrastructure and application execution. In a cluster system, the compute node is responsible for executing the I/O intensive functions. These functions fetch huge amount of data from storage array thereby increasing the bottleneck at network and also result in the underutilization of the hardware resources by wasting the compute, memory and power usage by the network/fabrics at storage array end. The network traffic increases the response time of the applications. The end-to-end application performance also gets influenced in the tradition cluster infrastructure. One of the options is to deploy the conceptual technology Active storage which is still in research. The active storage reduces the consumption of the bandwidth between the compute node and storage array by leveraging the computing power of the storage array. In the active storage the user end IO intensive functions or the tasks are offloaded from compute node to storage node for their execution in storage node. This paper discusses on an efficient offloading for active storage architectures considering the various hardware resources like core, processor utilization, port utilization and based upon these metric values it is decided when to offload I/O intensive functions from compute node to storage node which makes feasible for storage node to accept the off loadable tasks or functions to be executed at storage array end. The primal idea is to ascertain the efficiency, performance of the storage array and also effective performance of the application by offloading or not offloading the tasks to the storage array. The remaining paper discusses the points in a systematized way as trails: Section II explores the various

2 technologies and terminologies associated to active storage following is the mathematical model that s supports the active storage offloading part based on the various parameters that decides to when to offload the function or process that is explained in section III. Section IV evaluates the parameters that supports the offloading using two applications and at last the conclusion of this research. II. LITERATURE SURVEY Extensive research work has taken place in improving the performance of the applications in high performance computing environment. Research scientists have proposed new prototypes of active storage that helps in improving the end-to-end application performance. Many of the works done by various researchers/scientist in the active storage domain state only the offload framework and it performance benefits. The notion of modelling hardware resource consumption of the host as well as the storage array is new and has not been widely explored. [1][2][3] Proposed the concept of active disk architecture in which the processing power and the memory are embedded singly on each hard disk. The offloading of tasks is done through the stream based programming model to the hard disk from host and the tasks gets executed by consuming the compute power and memory embedded on the storage disks. Active disk based file system was proposed by [1][4][5]. This file system offloads its part of file system functionality to active disks. Application specific tasks can also be migrated to active disks for getting executed and only the results are returned back to the application. [1][16][17][19] Proposed an analytical model for evaluating the various applications with different patterns and wide applicability, which may benefit out of active storage. [6][7][8] Suggested that the distributed architecture performs well than partially and centralized systems through the experimented results on smart disks. Smart disks consisted the processor, on disk memory and memory interfaces. [1][3][8][9] Proposed his research view in the context of parallel file system. The approach provides the server-server communication for reduction and aggregation. Designed the enhanced programming interface that enables application codes to embed in the parallel file system. A combination of active disks and object storage model was proposed. The various research ideas in the field of OSD based active storage and focused on changing the architecture of the storage systems. [14] [15][16] Demonstrated the active storage implemented in lustre file system. [17][18][19] Proposed the active storage in Lustre deployed in user space and compared it with the active storage in the kernel space. The data movement is reduced drastically in both the proposed prototypes. The user space is better than the kernel space implementation because, in kernel space implementation Operating system codes needs to be altered and new API s needs to be developed for implementing the active storage. On the other hand, user space is readily deployable, more flexible and faster. III. WHEN TO OFFLOAD MODEL A. Active storage Exadata is an intelligent storage appliance, which comprises the offloading of tasks near to the data. But these offloading are not full-fledged and are ad-hoc in manner. Exadata components can be partitioned into three compartments like Database servers, Network fabrics and Storage servers also called storage cells. The more storage cells more will be the capacity and high bandwidth. The offloading process in Exadata happens between the database servers and storage cell through idb (intelligent database protocol). The idb works as function conveyance to transparently represent the database operations to Exadata operations. It is also used for transferring data between database node and storage cell. idb is implemented using LIBCELL and in turn Exadata binaries are linked up with the LIBCELL to facilitate cell communication. The heart of the Exadata storage cell for providing the unique features and services is CELLSRV. The CELLSRV provides majority of services. Cell Offload significantly reduces the IO transfer over storage network, memory and CPU utilization database tier nodes. Since direct path read mechanism is implemented the buffer cache will not get saturated for large IO requests. DDN also emerged with its own storage fusion architecture (SFA), which was designed for multiprocessor and multi core systems. The processors inside the storage were divided into application processor and RAID processors. The Application processors were dedicated to execute tightly coupled applications within the storage subsystem. [30] With the help of virtualization tool the applications were brought into storage subsystem and the application processor were used to execute them. Operating system with the SFA acts as hypervisor to control processors/cores, memory, IO and virtual disk allocations. This also takes care of applications running in embedded space cannot hinder block operations memory space and that the applications only utilize the processing and IO resources they have been coupled with. It has been observed that, the cost involved in bandwidth consumption while transacting data amid the processing nodes and the data storage node has not shown a significant enhancement while in the same period the capacity of the disk has been significantly improved. Many applications require high end computing and are shifting towards the data centric computation. Thus Data centric applications request storage nodes to transfer huge amount of data to compute nodes where these applications are getting processed. This data transfer often dominates application execution or processing. High data intensive applications have stringent performance requirements. The advent of low latency, high bandwidth networks architectures and embedded processing having enabled hard disks to function as active storage devices. In order to meet these performance demands, it is essential to optimize the processing and I/O subsystems. One promising approach to optimize performance is to use active storage. Storage infrastructure heavily impacts the Application performance

3 whether it is in Virtualized environment or non- Virtualized environment. [30] Storage configurations are directly influenced or changed based on the demands of various applications. The factors for storage configurations can range from array cache sizes, number of disks per LUN, fan in/out and other variables. In turn these factors may influence how I/O Performance is handled & tempt how applications respond. The situation is no different with virtualized environment. There are many proprietary parallel/distributed files systems (Google s GFS, IBM s GPFS, Panasas Active file scale system, SGI s CXFS) and open source like (Lustre, PVFS, Redhat s GFS) have been developed to manage the increasing volumes of data in terms of High performance computing environment. [2] Active storage is the system, which takes advantages of underutilized processing power of computing units in storage nodes instead of simply storing data. Employing the storage nodes to process the data along with storing will result in drastic reduction in redundant data transfers over the network, which spectacularly boosts the performance. Offloading some computing operations and tasks from application server (computing nodes) to computing units of storage nodes is core concept of active storage. Here, the computation is moved closer to the data instead of moving data closer to computation. That means, instead of moving out data from storage node, the computation is brought in to the storage, which will significantly scale down the data movement across the network and hence the overall network traffic. [9] Active storage is targeted at IO intensive applications. B. Offload Model The section begins with emphasizing on the main idea of this paper for data intensive applications in high performance computing environment. The figure 1 below shows the generic idea of offloading taking place between the host and the storage array. The core idea for this paper is to find if the storage array will perform well or the performance of the array will degrade if the tasks are offloaded to the array from application server as well as also covers the assessment on whether the end-to-end application performance enhances or improves. The figure 1 states a simple generic offload framework, which consist of components, which makes the offloading feasible. The dotted line components are the hardware and the others are logical components. This paper derives the question when to offload from the research work proposed by the [9] where they state the offloading should be only done when the bandwidth requirement analysis is completed which is inbuilt into the dynamic active storage. At the host end Applications interact with the distributed file systems API for carrying out I/O operations with the storage array. A new API is developed at the host end as well as at the storage array side that are further embedded into file systems and kernels. These newly created API will interact with each other in order to perform simple I/O operations or offloading tasks to the active storage array. Active Storage API responds to offloading requests. As per the earlier studies, the distributed file systems are used to create the local I/O API. The local I/O API is responsible for carrying out the local strips to be viewed as a file and helps in reading the data locally for kernels. [30]. The I/O requests are received by API at active storage end and it starts accumulating the scattered information of data required by the request. Once the evaluation of the requested data is over, the I/O requests and the set of tasks are offloaded to this active storage node from the host. [4] Then these tasks are executed by the storage array and the results are returned to the host. C. When to Offload In a storage array, there are various components like Front end ports connecting the host HBA s and storage array. Cache serving the requests from hosts there by increasing the performance of the storage array [J 2015]. The Back end ports, which connects the front end and cache to the disks. The disks, which store the data, the processors which execute I/O requests and send the data to host. The front-end ports are the important component, which receives the requests from one or more hosts via HBA. Figure 1: Offloading model

4 The utilization of ports and processors play an important role in determining whether to offload functions from host to array. In current trends of storage technology, there are many functions, which are being embedded with the storage array. These arrays perform functions like compression, snapshots etc. other than just servicing the I/O requests from the hosts. While performing the regular I/O operations, the components gets utilized and the data transferred from disks to host consume the network bandwidth depending on the data size required by the applications. In addition to these I/O requests being served, if the functions are offloaded from host to storage array there may be chance of high utilization of resources, which will lead to low response times and reduce the number of IOPS. This in turn degrades the performance of the storage array executing it near the data. The factors, which impact the performance of storage array, are storage array port utilization, storage core utilization, bandwidth consumed for offloading. [Jayakumar et al. 2015; Bhardwaj 2015; Naveenkumar et al. 2015] When any function is offloaded to the storage array the dotted representation in figure 1 gets impacted. Each component has a threshold value, which is monitored every time when the array is in action. The threshold values are set in order to keep the performance high, once the threshold value is crossed by any one of the components in the array, the performance is checked if it is dropping. The overall performance of the storage depends both on the software and the hardware resource utilizations. The research paper centers to find whether offloading to array will increase the performance or at when the offload request will be accepted and serviced by the storage array. Considering the total cost of execution time of the functions or tasks viewing end to end from applications to storage array is given by: Keeping the performance of the end to end application storage array deployment in mind, it should be important to monitor the resource utilization and bandwidth consumed when the functions/tasks are offloaded to the storage for execution. If the bandwidth consumption is high for offloading the I/O requests and tasks to the active storage system and the processing cost is also more than the native I/O execution, then the host takes up the task and I/O requests and executes it in native style rather than offloading it to the active storage node. If the bandwidth cost is less, then the host will offload the tasks and I/O request to the active storage node for execution using the Parallel I/O API s. [4]. As discussed earlier, the component utilization also plays a very important role in determining whether the tasks can be offloaded to storage array. The first component which receives the requests from the host HBA s are the front-end ports. If the demand of the front-end ports is exceeded by the utilization of the ports, then it is not recommending offloading the functions to the storage array. In order to understand the scenario, it is needed to monitor how much is being demanded for how much time? What is the amount of the request size being transferred to and from front-end ports and for how long? The demand for the front-end ports will be given by this equation: The utilization of the port is defined by the below equation: (3) (4) Where, (1) Thus from equation (4) and (5) we can check upon the feasibility and viability of the offloading to storage array. It s only effective to offload and to expect high performance out of the storage array when the port demand is less than port utilization shown in equation 6. (5) Where, Task execution host is the task execution time at host. Task execution array fraction is the fraction of local execution time that remote execution takes. From the equation (1) we can draw that the offloading is only beneficial when the host execution time is more than the array execution time. (2) At the same time if the cost involved in executing the function at array side is minimum to that of the total capacity available and also less than the host requires that, then as per equation (2), the functions or tasks are eligible for offloading to storage array. When we see with respect to network, the cost of bandwidth should also be greater than the cost of the offloading functions to storage array, which is shown in the equation (3). The CPU s in storage array that is responsible for supervising the disks and array components. The CPU s receive the I/O transfer request from the host. These host requests are translated into individual I/O operations on the physical drives in the array. The disk array CPU s is essentially a compute engine that routes data from host to disk and vice versa. Before coming up with new storage architecture or making/enhancing improvements to the storage systems and storage network to make sure the performance is as expected. Since, in active storage approach, the functions are offloaded, the CPU s also needs to perform computation along with responding to the I/O requests. In order to find whether the function can be offloaded from host, it is important to consider (6)

5 the utilization of processors inside the array at the time of the offloading is taking place. applicable to the active storage architectures and these performance of the storage are given by the equations (9) and (10). (7) IV. EVALUATION The CPU clock frequency will be constant, thus capacity is the product of number of cores and time interval for they are used. The required capacity is calculated by the product of interval of time CPU s are required and Number of CPU s consumed. The total capacity is the product of total number of CPU s and the total interval time. If the potentially available CPU is less and the Utilization of the CPU is at its max and more the demanding utilization is increasing through offloading, then the performance of the array will degrade hence, to keep a check on the utilization of CPU s in storage array it is necessary to consider the environment parameters while offloading tasks and requests from host. Meanwhile, the migration of data between both the nodes can be drastically reduced by deploying intelligent data distribution methods that considers the dependency among the distributed data. [4] The offloaded computations are carried out by the kernel at the array end. The processing kernels are invoked by helper daemon process for executing the offloaded computations and I/O requests. The performance of the storage array is realized by the response time and IOPS metrics. The utilization of array is proportional to the number of request jobs given by (8): Where, N = No. of request Jobs The Response time and IOPS are measure through these equations: Where, tr = Response Time Ats = Array service time (8) (9) (10) Considering the above described set of equations, it is required that if operation needs to be offloaded to storage array, it is only efficient when the cost of execution of array is less than the cost of execution at host and current port utilization in array is less than what is being demanded at that time and thirdly, the CPU utilization of array should not exceed the threshold and current demand should not exceed the current utilization of CPU s in the array. If these three equations (2), (3) and (7) are satisfied then offloading will yield the performance of storage array. The above equations are only A. Testbed A test bed has been prepared here in order to check whether offloading of functions yields performance improvements at the application level as well as utilizes the hardware resources of the IO subsystem. The test bed constitutes two systems connected through Ethernet of speed 1Gbps. The first system assumed to be the storage node which had i7 Processor 3.1 GHz, 8GB RAM and 4 250GB hard disks. This first system was running on Centos 6.5. The second system considered to be application hosting system constituting i7 Processor 3.1 GHz, 4GB RAM and 1 250GB hard disks and the system was running centos 6.5. B. Application for Testing The application chosen for testing are Hadoop example word count and a RDBMS i.e. PostgreSQL C. Preparing Data The database, which is created, is of size 10GB having nearly 800 tables and 200 varchar and integer attributes across the database. The metadata was not created so any query fired needs to be accessing all the tables directly and with referring to identifying the indexes and its values. There were multiple queries generated, which access all the tables, and scans the individual table one by one. There were total 10 text files consisting stories and each file size was nearly 1.2GB. The total size of data, which was prepared for the word count program, was nearly 12 GB. D. Test Execution The performance measurement was done on the machine, which is assumed to be a storage system. The data is stored in the storage system and the application is executing at other node. The above-explained offloading model is used to offload the application from hosting system to storage system. The performance of the storage system is measured w.r.t CPU utilization, impact on performance of application and network data transfer. These metrics are measured in both the scenarios when the application is running at the host end i.e. without offloading and also the values are measured when the application is offloaded to the storage system. The graphs and table are shown below for both the applications viz. word count Programme and PostgreSQL.

6 Table 1: shows the results of Latency measured while executing the query with offloading and without Offloading Logic for word Count Application Table 2: shows the results of network bandwidth measured while executing the query with offloading and without offloading Logic for word Count Application Figure 2: Above graph depicts the results of Latency measured while executing the query with offloading and without offloading Logic for word Count Application Figure 3: shows the graph for network bandwidth measured while executing the query with offloading and without offloading Logic for word Count Application

7 Table 3: shows the results of CPU Utilization measured while executing the query with offloading and without offloading Logic for word Count Application E. Execution Mechanics The database PostgreSQL processes are executed in the clientserver fashion. The communication happens through client interface library. The mechanism of inter process communication is shown below in the diagram. The test bed, which is evaluated and explained in this paper, consists both configurations for with and without offloading logic. Through the offloading logic explained above in offload model section of the paper, the PostgreSQL server (Backend) process component of the PostgreSQL is pushed into the storage system and the remaining processes of database is executed at database/application hosting node. Figure 5 : PostgreSQL without offloading Logic Figure 4: shows the graph for CPU Utilization measured while executing the query with offloading and without offloading Logic for word Count Application The above figure shows the process components of the PostgreSQL. The backend process consists of components like parser, rewriter, planner and executor. The executor component is the most IO intensive component, which executes functions like fetching of data, storing data and scanning. The logic behind executor is execution of plan tree, which is a pipelined demand pull of processing nodes. The execution of query and processes in PostgreSQL without using offloading logic is depicted in the figure above. In this case, the data is fetched from the storage system and get it stored in shared disk buffers or shared memory. Then the executor fetches the data and executes query over it. In regard to style of this execution the data needs to be moved via network to application hosting which increases the transfer time because of the size of data to

8 be migrated, in turn this process impacts the application response time. In order to improve the performance of application and utilization of various resources at storage end, the offloading logic is proposed and deployed. The offloading logic works using the concept of process migration and RPC. When applied to the existing configuration as show in Figure 2. The Executor i.e. server process (backend) is migrated or offloaded to the storage system thereby moving the processing/executing component which is IO intensive closer to the data residence component. The offloading works on the concept of RPC/RMI packages. It is being developed to offload the IO intensive components of the Application and migrate the component near data. Since, the paper is focusing on the issue of whether it is viable to offload the compute logic to storage systems every time and what resources get hindered because of offloading? We limit the discussion on offloading logic to conceptual view. The below figure explains the configuration of second system in test bed where the offloading logic is deployed at application hosting node. Since, Linux flavor is been installed at storage node, the migration becomes possible with set of existing libraries at storage end. Figure 6: PostgreSQL with offloading Logic The offloading logic identifies the IO bound tasks and migrates it to the other node where the data resides. The postmaster daemon receives the offloaded tasks from kernel libraries at storage end and spawns the tasks to multi cores for effective execution of the queries. Once these cores are assigned with computes component then these cores schedule themselves to IO services as well as the offloaded tasks with the help of operating system. This paper focus on how well these cores can manage both the components execution in parallel. In some cases, the high utilization of resources at storage end may hinder the normal functioning of the system. In order to understand the viability of offloading, these tests were performed to measure and compare how well CPU utilization and application performance reacts to both the configuration of test beds. F. Test Observations The evaluations are made with an objective to understand the impact on utilization of storage resources and application performance when the offloading of IO intensive tasks are made from application hosting system to storage system. Two applications viz. Hadoop s word count and PostgreSQL are considered for testing their performance with both the system model. Application performance and CPU utilization metrics are noticed and graphs were generated for the same. This paper considers two models, the first model has traditional server storage configuration and communication channel where the application running at application server will request data from the storage server and migrate the required data from storage to the memory in server system and then the application executes on the data at server end. The second model is the offloaded model in which the hardware resource structure remains intact only variations comes in the way of interaction between server and storage system. In this system model prototype, the application s IO intensive functions like the executor process of PostgreSQL or the count function including scan and comparator of the word count is partitioned from the whole application and is migrated to storage node where the data resides. It is observed from the graph Figure 1 application Latency for word count application, there is a drastic drop down in execution time when application is executed in second model with offloading. When the application is executed in traditional system model, the application copies the data from the storage to buffer memory in the server where application is getting executed. In this case the response time increases because the data is transferred between nodes while in the later model, the IO intensive function is moved near to data which takes less time because compared to the size of data IO intensive task of the application size is less and it can be quickly transferred to storage node and is executed on the storage node itself and only results are transferred back to Application server. The graph depicts nearly for 6GB data to be transferred from the storage to server node and then the scan and count function executes on bits of transferred data, which nearly takes seconds to complete and respond with results. The same application when executed on the second model with offloading in which the count function and comparator function of the application word count are transferred to storage system and executed there. The response time to be noticed is 2.3 seconds, which is a drastic drop down to earlier measured value. The reason behind this effective response time of application is due to cutting down the transfer of huge amount of data and instead transferring the data

9 intensive functions. In continuation to above evaluation of application response time, there are two more performance components, which are also covered. The throughput also comes down since the data is stopped from transferring and tasks are transferred between server and storage. In case of word count as well as database application it is observed data transfer rate in MBPS is reduced when the application is executed with offloading of data intensive tasks. Table 4: The results of Throughput measured while executing the query with offloading and without offloading Logic for PostgreSQL Application Table 5: The results of Throughput measured while executing the query with offloading and without offloading Logic for PostgreSQL Application Figure 7: The graph of Latency measured while executing the query with offloading and without offloading Logic for PostgreSQL Application Figure 8:The graph of Throughput measured while executing the query with offloading and without offloading Logic for PostgreSQL Application.

10 Table 6: The results of CPU utilization measured while executing the query with offloading and without offloading Logic for PostgreSQL Application. In the storage system the cores are utilized by the operating system and IO services. The utilization varies from nearly 0 % to 33% in the traditional storage system. As per some standards storage array, CPU utilization can be up to 80% and the remaining 20% is kept as buffer if something goes wrong then the CPU utilization can be extended more 20%. But since in majority cases, the CPU utilization reaches nearly 50% to 70% this resource is underutilized at storage end. The offloading becomes effective to have increased utilization of CPU. When the application is offloaded to the storage system the CPU utilization increased to 51% at the cost of gain in the application performance. Still there is space for offloading to the storage. Thus it can be concluded when the offloading happens the CPU utilization can increase drastically depending upon the size of application and native IO services provided by the storage system. So to keep a track of resource utilization at storage end, this paper has proposed in above section when to offload the IO intensive tasks. CONCLUSION This research paper discusses about the key factors, which influences the performance of the storage array if and when the tasks are offloaded to the storage array. Using these factors or performance metrics, it can be decided that the functions or tasks if offloaded will improve efficiency and performance of the storage array or not. The metrics include % CPU utilization and the cost of bandwidth for task execution. These metrics elaborated in the above section will guide us in designing and developing the offloading logics that can be deployed in the active storage architectures or frameworks whereby, the resources can be utilized to their efficiency by offloading being permissible or not. Figure 9: The graph of CPU utilization measured while executing the query with offloading and without offloading Logic for PostgreSQL Application REFERENCES [1] Riedel, E., Gibson, G. and Faloutsos, C., 1998, August. Active storage for large-scale data mining and multimedia applications. In Proceedings of 24th Conference on Very Large Databases (pp ). [2] Piernas, J., Nieplocha, J. and Felix, E.J., 2007, November. Evaluation of active storage strategies for the lustre parallel file system. In Proceedings of the 2007 ACM/IEEE conference on Supercomputing (p. 28). ACM. [3] Henley, M.R., International Business Machines Corporation, Method and system for managing movement of large multi-media data files from an archival storage to an active storage within a multi-media server computer system. U.S. Patent 5,745,756. [4] Shimada, A., Nozawa, M. and Nakano, T., Hitachi, Ltd., External storage unit comprising active and inactive storage wherein data is stored in an active storage if in use and archived to an inactive storage when not accessed in predetermined time by the host processor. U.S. Patent 5,584,008. [5] Chockler, G. and Malkhi, D., Active disk paxos with infinitely many processes. Distributed Computing, 18(1), pp

11 [6] Chen, C. and Chen, Y., 2012, September. Dynamic active storage for high performance I/O. In st International Conference on Parallel Processing (pp ). IEEE. [7] Son, S.W., Lang, S., Carns, P., Ross, R., Thakur, R., Ozisikyilmaz, B., Kumar, P., Liao, W.K. and Choudhary, A., 2010, May. Enabling active storage on parallel I/O software stacks. In 2010 IEEE 26th Symposium on Mass Storage Systems and Technologies (MSST) (pp. 1-12). IEEE. [8] Wickremesinghe, R., Chase, J.S. and Vitter, J.S., Distributed computing with load-managed active storage. In High Performance Distributed Computing, HPDC Proceedings. 11th IEEE International Symposium on (pp ). IEEE. [9] Felix, E.J., Fox, K., Regimbal, K. and Nieplocha, J., 2006, April. Active storage processing in a parallel file system. In In Proc. of the 6th LCI International Conference on Linux Clusters: The HPC Revolution (p. 85). [10] Qin, L. and Feng, D., 2006, April. Active storage framework for object-based storage device. In 20th International Conference on Advanced Information Networking and Applications-Volume 1 (AINA'06) (Vol. 2, pp ). IEEE. [11] Ma, X. and Reddy, A.N., MVSS: an active storage architecture. IEEE Transactions on Parallel and Distributed Systems, 14(10), pp [12] Xie, Y., Muniswamy-Reddy, K.K., Feng, D., Long, D.D., Kang, Y., Niu, Z. and Tan, Z., 2011, May. Design and evaluation of oasis: An active storage framework based on t10 osd standard. In 2011 IEEE 27th Symposium on Mass Storage Systems and Technologies (MSST) (pp. 1-12). IEEE. [13] Amiri, K., Petrou, D., Ganger, G. and Gibson, G., Dynamic function placement in active storage clusters (No. CMU-CS ). CARNEGIE-MELLON UNIV PITTSBURGH PA SCHOOL OF COMPUTER SCIENCE. [14] Zhang, Y. and Feng, D., 2008, March. An active storage system for high performance computing. In 22nd International Conference on Advanced Information Networking and Applications (aina 2008) (pp ). IEEE. [15] John, T.M., Ramani, A.T. and Chandy, J.A., 2008, September. Active storage using object-based devices. In 2008 IEEE International Conference on Cluster Computing (pp ). IEEE. [16] Fitch, B.G., Rayshubskiy, A., Pitman, M.C., Ward, T.J. and Germain, R.S., 2009, November. Using the active storage fabrics model to address petascale storage challenges. In Proceedings of the 4th Annual Workshop on Petascale Data Storage (pp ). ACM. [17] Acharya, A., Uysal, M. and Saltz, J., Active disks: Programming model, algorithms and evaluation. ACM SIGPLAN Notices, 33(11), pp [18] Riedel, E., Faloutsos, C., Gibson, G.A. and Nagle, D., Active disks for large-scale data processing. Computer, 34(6), pp [19] Riedel, E. and Gibson, G., Active disks-remote execution for network-attached storage (No. CMU-CS ). CARNEGIE-MELLON UNIV PITTSBURGH PA SCHOOL OF COMPUTER SCIENCE. [20] Uysal, M., Acharya, A. and Saltz, J., Evaluation of active disks for decision support databases. In High-Performance Computer Architecture, HPCA-6. Proceedings. Sixth International Symposium on (pp ). IEEE. [21] Riedel, E., Gibson, G. and Faloutsos, C., 1998, August. Active storage for large-scale data mining and multimedia applications. In Proceedings of 24th Conference on Very Large Databases (pp ). [22] Delmerico, J.A., Byrnes, N.A., Bruno, A.E., Jones, M.D., Gallo, S.M. and Chaudhary, V., 2009, December. Comparing the performance of clusters, Hadoop, and Active Disks on microarray correlation computations. In HiPC(pp ). [23] Keeton, K., Patterson, D.A. and Hellerstein, J.M., A case for intelligent disks (IDISKs). ACM SIGMOD Record, 27(3), pp [24] D. T. Jayakumar and R. Naveenkumar, Active Storage, Int. J. Adv. Res. Comput. Sci. Softw. Eng. Int. J, vol. 2, no. 9, pp , [25] M. N. Jayakumar, M. F. Zaeimfar, M. M. Joshi, and S. D. Joshi, A GENERIC PERFORMANCE EVALUATION MODEL FOR THE FILE SYSTEMS, Int. J. Comput. Eng. Technol., vol. 5, no. 1, pp , [26] M. N. Jayakumar, M. F. Zaeimfar, M. M. Joshi, and S. D. Joshi, INTERNATIONAL JOURNAL OF COMPUTER ENGINEERING & TECHNOLOGY (IJCET), J. Impact Factor, vol. 5, no. 1, pp , [27] N. Jayakumar, T. Bhardwaj, K. Pant, S. D. Joshi, and S. H. Patil, A Holistic Approach for Performance Analysis of Embedded Storage Array, Int. J. Sci. Technol. Eng., vol. 1, no. 12, pp , [28] N. Jayakumar, S. Singh, S. H. Patil, and S. D. Joshi, Evaluation Parameters of Infrastructure Resources Required for Integrating Parallel Computing Algorithm and Distributed File System, IJSTE, vol. 1, no. 12, pp , [29] S. D. J. M. J. Naveenkumar Farid, A GENERIC PERFORMANCE EVALUATION MODEL FOR THE FILE SYSTEMS, Int. J. Comput. Eng. Technol., vol. 5, no. 1, p. 6, [30] P. D. S. D. J. Naveenkumar J, Evaluation of Active Storage System Realized through MobilityRPC, Int. J. Innov. Res. Comput. Commun. Eng., vol. 3, no. 11, pp , [31] S. D. J. Naveenkumar Jayakumar Farid Zaeimfar, Workload Characteristics Impacts on file System Benchmarking, Int. J. Adv. Res. Comput. Sci. Softw. Eng., vol. 4, no. 2, pp , [32] J. Naveenkumar, R. Makwana, S. D. Joshi, and D. M. Thakore, Performance Impact Analysis of Application Implemented on Active Storage Framework, Int. J., vol. 5, no. 2, [33] J. Naveenkumar, R. Makwana, S. D. Joshi, and D. M. Thakore, OFFLOADING COMPRESSION AND DECOMPRESSION LOGIC CLOSER TO VIDEO FILES USING REMOTE PROCEDURE CALL, J. Impact Factor, vol. 6, no. 3, pp , [34] R. Salunkhe, A. D. Kadam, N. Jayakumar, and S. Joshi, Luster A Scalable Architecture File System: A Research Implementation on Active Storage Array Framework with Luster file System., in ICEEOT, [35] R. Salunkhe, A. D. Kadam, N. Jayakumar, and D. Thakore, In Search of a Scalable File System State-of-the-art File Systems Review and Map view of new Scalable File system., in nternational Conference on El ectrical, Electronics, and Optimization Techni ques (ICEEOT) , 2015, pp [36] Acharya, A., Uysal, M. and Saltz, J., Active disks: Programming model, algorithms and evaluation. ACM SIGPLAN Notices, 33(11), pp