1

The Promise and Challenges of ComputationDeduplication and Reuse at the Network Edge

Md Washik Al Azad and Spyridon Mastorakis

Abstract—In edge computing environments, where devices maybe in close proximity to each other, these devices may offloadsimilar computational tasks (i.e., tasks with similar input datafor the same edge computing service or for services of the samenature). This results in the execution of duplicate (redundant)computation, which may become a pressing issue for future edgecomputing deployments, since such deployments are envisionedto consist of small-scale data-centers at the edge. To tackle thisissue, in this paper, we highlight the importance of paradigmsfor the deduplication and reuse of computation at the networkedge. Such paradigms have the potential to significantly reducethe completion times for offloaded tasks, accommodating moreusers, devices, and tasks with the same volume of deployed edgecomputing resources, however, they come with their own technicalchallenges. Finally, we present a multi-layer architecture toenable computation deduplication and reuse at the network edgeand discuss open challenges and future research directions.

I. INTRODUCTION

Edge computing has emerged as a paradigm to bring com-puting resources physically close to end-users in an effort toaddress the increasing needs of applications for low-latencyprocessing of data generated by user devices, such as mobilephones, Augmented Reality (AR) headsets, Internet of Things(IoT) [1]. Edge computing deployments are envisioned toconsist of small-scale data-centers at the edge of the net-work [2], while such deployments may target large-scale use-cases (e.g., smart cities with hundreds of thousands or millionsof residents). In such use-cases, several devices may be inclose proximity to each other, offloading tasks for “similar”computation (i.e., tasks with similar input data for the sameedge computing service or services of the same nature) to theedge [3]. This can result in the execution of massive amountsof duplicate (redundant) computation, limiting the numberof devices that can be accommodated by edge computingdeployments. Overall, we expect the execution of duplicatecomputation to become a pressing issue for future edgecomputing deployments given the small scale of edge data-centers and the need to accommodate large-scale use-cases.

In this paper, we highlight the promise of paradigms for thededuplication and reuse of computation at the network edge.In such paradigms, the results of previously executed tasks arestored with the goal to be reused in order to satisfy similaroffloaded tasks, instead of executing such similar tasks fromscratch. The process of deduplication provides the means toinfer whether reuse is possible by determining whether taskssimilar to the offloaded ones have been previously executed

Md Washik Al Azad and Spyridon Mastorakis (corresponding author) arewith the University of Nebraska at Omaha, USA.

and stored at the edge. As a result, such paradigms essentially“trade” storage for computing resources, having the potentialto: (i) significantly reduce the completion time of offloadedtasks; and (ii) accommodate more users, devices, and taskswith the same amount of deployed edge computing resources.However, such paradigms come with their own technicalchallenges, which need to be addressed for their realization.

Our contribution in this paper is two-fold: (i) we highlightthe promise that computation deduplication and reuse holds foredge computing deployments and the need for paradigms fordeduplication and reuse that consider the distributed natureof such deployments, a key observation that prior researchhas overlooked; and (ii) we present a multi-layer architectureto enable the pervasive computation deduplication and reuseat the network edge along with promising proof-of-conceptevaluation results.

The rest of this paper is organized as follows: in Section II,we discuss the importance of computation deduplication andreuse for edge computing deployments. In Section III, wepresent the design of a multi-layer architecture for computationdeduplication and reuse. In Section IV, we present openchallenges and future research directions, and, in Section V,we conclude our work.

II. WHY COMPUTATION DEDUPLICATION AND REUSE ATTHE EDGE ARE IMPORTANT?

With the projected growth of the number of IoT, mobile,and other devices at the edge, several devices may be inclose proximity to each other. As a result, these devicesmay request the execution of the same services/processingfunctions offered at the edge with similar data as the inputsof these services/functions. For example, in Figure 1, weillustrate a scenario where visitors of the Eiffel Tower in Paris,France take pictures of the tower with their mobile phones.These pictures are offloaded to a nearby edge server wherea computer vision algorithm identifies the depicted sight andreturns information and content about the identified sight tovisitors (e.g., podcasts and videos related to the sight, the storybehind the sight). In this scenario, visitors request the samecomputation with similar inputs (e.g., pictures of the Eiffeltower from different angles or distances), which results in thesame output (the received information and content about theEiffel tower). In another scenario, where CCTV cameras ina smart city are used for the estimation of the volume ofvehicle traffic (Figure 2), these cameras may capture multiplesnapshots every second. Consecutive snapshots (e.g., snapshots𝑛−1 and 𝑛 in Figure 2) may be highly similar and, as a result,

arX

iv:2

109.

0160

8v1

[cs

.NI]

3 S

ep 2

021

2

when these snapshots are offloaded to an edge server (to beused as the input to a computer vision algorithm that identifiesthe number of vehicles in a snapshot), the produced output maybe the same (the same number of vehicles is detected). In otherwords, the execution of computational tasks in both scenariosmentioned above may result in massive volumes of redundant(duplicate) computation; popular sights around the world, suchas the Eiffel Tower, may have tens of thousands of visitors ona daily basis, while major cities around the world may haveseveral hundred thousands to millions of CCTV cameras each.

Fig. 1: Visitors of the Eiffel Tower, taking pictures of the tower fromdifferent angles and/or distances to learn more information about thissight.

Overall, redundant computation may occur in scenarioswhere temporal, spatial, and semantic correlation may existbetween the input data of offloaded tasks. Additional examplesmay include: (i) smart homes equipped with IoT devices,where users can control these devices through voice com-mands. In such cases, residents of the same or nearby homesmay invoke semantically similar commands that result in thesame action (e.g., turning on the light in a room); and (ii)AR applications, which, for example, can be used by firstresponders wearing AR headsets during a disaster to identifysurvivors and other objects. In such cases, first respondersworking in groups may capture similar scenes (e.g., scenesof the same office space in a building on fire from differentangles). As a result, running an edge service for the detectionof survivors and objects in such scenes may yield the sameexecution results.

At the same time, given that next-generation applicationsmay require ultra-low response times (e.g., AR may requireresponse times less than 10ms), the deduplication and reuse ofcomputation can speed up the execution of tasks offloaded byuser devices, since the execution results of previous similartasks can be reused instead of executing compute-intensivetasks from scratch. This also ensures that the available edgecomputing resources are effectively utilized given their poten-tially limited scale by essentially trading storage for computingresources (i.e., to store and reuse previously executed tasksand their results). As a result, the reuse of computation hasthe potential to increase the capacity of edge computingdeployments in terms of being able to accommodate more

tasks, users, and devices with a fixed amount of physical edgecomputing resources.

A. Computation Deduplication and Reuse: Making the Net-work Part of the Solution

Edge computing deployments are distributed in nature inthe sense that they consist of several edge servers for faulttolerance, scalability, and load balancing purposes. As a result,each computing service at the edge (e.g., object detection,face recognition) may be offered by multiple edge servers. Inthe scenario illustrated in Figure 2, if consecutive snapshotscaptured by a CCTV camera are offloaded to different edgeservers for processing (e.g., snapshot 𝑛−1 is offloaded to serverA, while snapshot 𝑛 is offloaded to server B), then computationdeduplication and reuse will not be possible.

In other words, in realistic edge computing deployments,where each computing service may be offered by multipleedge servers, it is vital that the edge network infrastructure isable to facilitate the reuse of computation. To achieve that, theedge network infrastructure needs to forward computationaltasks for the same computing service and with similar inputdata to the same edge server. Essentially, the network needs toidentify and forward tasks with similar input data with minimaloverhead and performance penalty, calling for solutions thatexpose data similarity semantics directly at the network layerin a light-weight manner. In the context of our CCTV scenario,background removal approaches could also be utilized toidentify similar snapshots [4]. However, such approaches maybe expensive, while they may also make the exposure of datasimilarity semantics to the network layer cumbersome.

In Table I, we present representative studies that have ex-plored computation deduplication and reuse in edge computingenvironments. Cachier [5] proposed optimizations of edgeserver caches leveraging the spatiotemporal locality of userrequests for computation. Potluck [6] proposed the dedupli-cation and reuse of computation across different applicationsrunning on the same user device, while FoggyCache [3]explored the reuse of computation at edge servers acrossdifferent user devices. Coterie [7] exploited the similarityamong background environment frames in multi-player VirtualReality applications, so that headsets can cache and reusesimilar frames. However, all these approaches did not considerthe challenges stemming from the distributed nature of edgecomputing deployments. ICedge [8] proposed a preliminarydesign to facilitate computation reuse with the assistance ofthe edge network infrastructure in distributed edge computingdeployments. However, in ICedge, computation deduplicationand reuse are unlikely to happen directly in the network, whileeach application may expose different computation reuse se-mantics to the network, making task forwarding complicated.To this end, there is a need for a solution that allows the edgenetwork infrastructure to forward tasks from different applica-tions based on the same semantics while facilitating pervasivecomputation deduplication and reuse—at user devices, withinthe edge network infrastructure, and at edge servers.

3

TABLE I: Studies on computation deduplication and reuse in edge computing environments.

Solution [5] [6] [3] [7] [8] Our approach

Are Deduplicationand Reuse Possible?

Partially–atedge servers

Yes–at userdevices

Yes–at edgeservers

Yes–at userdevices

Yes–at edgeservers

Yes–at user devices,edge network

infrastructure, andedge servers

FocusOptimizations of

edge servers’caches

Optimizations ofuser devices’

caches

Cross-devicededuplication

Exploit inter-framesimilarity in Virtual

Reality

Networkarchitecture

Multi-layerarchitecture for

deduplication & reuseConsiders Distributed

Edge ComputingDeployments?

No No No No Partially Yes

B. Goals and Technical Challenges

The fundamental goal to be achieved by solutions forpervasive reuse of computation at the edge is imposing min-imal overheads on the (potentially resource-constrained) userdevices, the edge network infrastructure, and the edge serversso that users and edge computing providers can receive thesubstantial benefits of computation reuse. These benefits fea-ture improved response times and the ability to accommodateincreased numbers of tasks, users, and devices with a fixedamount of physical edge computing resources. Based on ouranalysis in the prior parts of this section, we can conclude thatsolutions for computation deduplication and reuse at the edgeneed to tackle the following challenges:

• Impose minimal overheads on users, their devices, andthe network for the identification and forwarding of taskswith similar input data to the same edge server forprocessing and reuse. At the same time, edge servers mustefficiently search for similar previously executed tasksand execute incoming tasks only if previously executedtasks cannot be reused.

• Reuse previous computational tasks and their resultsaccurately. In other words, the execution of an incomingtask 𝑡 and a reused task 𝑡𝑟𝑒𝑢𝑠𝑒𝑑 with similar inputdata must yield the same execution results, so that theoperation of applications and the user-perceived qualityof experience are not negatively impacted. We discussextensions of this notion in Section IV.

III. A MULTI-LAYER ARCHITECTURE FOR COMPUTATIONDEDUPLICATION AND REUSE

In this section, we present a hierarchical architecture forthe deduplication and reuse of computation at the networkedge (Figure 2). Its first layer consists of user devices, whichcan cache the results of previously offloaded tasks dependingon the availability and capacity of their resources. The sec-ond layer consists of the edge network infrastructure, whichidentifies and forwards similar tasks to edge servers that canreuse previous computations, as well as features repositoriesfor caching previous tasks and their execution results directlyin the network. The third layer consists of edge servers, whichreceive offloaded tasks, search for previously executed tasksto reuse, and execute and store the results of incoming taskswhen reuse is not possible.

In the example of Figure 2, snapshot 𝑛 − 1 captured by aCCTV camera is offloaded by the camera and is forwardedby the edge network infrastructure to edge server A for the

detection of the number of vehicles in the snapshot. Snapshot𝑛 captured by the CCTV camera will first have an opportunityto reuse the results of previous tasks stored in the computationcache of the CCTV camera itself (if the camera has adequateresources to do so). If this is not possible, the snapshot isoffloaded to the edge, where it can reuse the results of previoustasks from in-network computation caches/storage. If this isnot possible, the snapshot will be forwarded by the edgenetwork infrastructure to the same edge server as snapshot𝑛−1 (server A), where the execution results of the processingof snapshot 𝑛 − 1 may be reused.

WiFi Router

3rd Layer

2nd Layer

1st Layer

CCTV Camera

Edge Service Input Data Hash Results

Car Detection 11234 <result-1>

Car Detection 32890 <result-2>

... ... ...

Car Detection 55687 <result-n>

Computation Cache

Edge Service Input Data Hash Results

Car Detection 11234 <result-1>

Object Detection 45092 <result-2>

... ... ...

Sight Recognition 36781 <result-n>

In-Network Computation Cache/Storage

Hash Value Range Server ID

0-21845 A

21846-43690 B

43691-65535 C

Reuse Information Table

Computation Cache/Storage

Edge Service Input Data Hash Results

Sight Recognition 10900 <result-1>

Car Detection 11234 <result-2>

... ... ...

Object Detection 48967 <result-n>

Edge Router

Edge Router

Edge Router

Server A Server B Server C

Edge Network Infrastructure

User Devices

Edge Servers

Snapshot n-1 Snapshot nHash Value: 10 Hash value: 10

Car detection execution for snapshot n-1

Car detection execution for snapshot n

Car Detection Service

Fig. 2: A CCTV camera capturing snapshots of vehicle traffic,which are offloaded to the edge, so that the number of cars ineach snapshot is detected and the volume of traffic is estimated.Consecutive snapshots may be highly similar, thus yielding the sameoutput once processed through a car detection service at edge serversand resulting in the execution of duplicate computation. To enablepervasive computation deduplication and reuse at the network edge,we propose a multi-layer architectural design (Section III).

A. Layer 1: User Devices

The first layer of our architecture consists of user devices.Each device may run one or more applications and offloadcomputational tasks to edge servers. Before offloading a task,each device needs to create a notion of how similar or differenta task may be compared to previous tasks, essentially aidingall the layers of our architecture to find previous tasks thatcan be reused in a light-weight manner. This can happen

4

through fast and space-efficient mechanisms, such as LocalitySensitive Hashing (LSH) and Feature Hashing (FH). LSH isa technique that allows to search for the nearest neighbor ofa data item 𝑖 by applying a hash function ℎ to 𝑖 and using theresulting hash ℎ(𝑖) as the index of a bucket of a hash tableto be searched for the nearest neighbor(s) of 𝑖. Furthermore,FH enables the vectorization of features extracted from dataitems (by applying a hash function ℎ to the extracted features),while the resulting vector can be further hashed through LSHto cluster together data items with similar feature values.

Through the application of such hashing techniques on theinput data (e.g., images, videos, voice commands) of tasks: (i)tasks with similar input data will likely be assigned the samehash value; and (ii) fast similarity-based search operationswill be enabled, so that previous tasks with similar input datacan be found and reused (no execution from scratch will beneeded). In the example of Figure 2, snapshots 𝑛 − 1 and 𝑛

may have the same hash values given that they are highlysimilar. A minimum similarity threshold may be selected byeach application, so that a task 𝑡 can reuse a task 𝑡𝑟𝑒𝑢𝑠𝑒𝑑 onlyif the similarity between the input data of 𝑡 and 𝑡𝑟𝑒𝑢𝑠𝑒𝑑 ishigher than this threshold. This offers flexibility and enablesdifferent applications to set different similarity thresholds thatmay be acceptable based on their requirements.

Depending on the available resources, devices can cacheoffloaded tasks and the results of their execution (once receivedby edge servers). This can act as a first layer of computa-tion reuse before new tasks are offloaded to the edge. Forexample, multiple applications may run on an AR headsetthat require the detection of objects in scenes captured by theheadset (e.g., a driving assistance application that identifiespotential accident conditions and informs drivers, and a smartnavigation application that provides instructions to drivers onhow to reach their final destinations) [6]. Such applications canessentially share and reuse the results of the tasks they offload.If deduplication and reuse are not possible at the device level(no similar previous tasks were found or no resources areavailable on devices to store previously executed tasks andtheir results), a task along with the hash of its input dataand the desired similarity threshold is sent towards the edgenetwork infrastructure. If a user device does not have adequatecomputing power to produce a hash of the task input data, thefirst edge router that receives the task can generate the hash.This router will attach the generated hash to the task, so thatedge routers and servers that subsequently receive this task donot need to generate the hash again.

B. Layer 2: Edge Network Infrastructure

The primary goal of the edge network infrastructure is toforward tasks for the same service and with similar inputdata to the edge server (among the multiple available edgeservers) that can maximize the chances of reusing previouscomputation. At the same time, in-network storage resourcesmay be available to cache/store previously executed tasksand their execution results as they transit the edge networkinfrastructure. When an offloaded task is received by a router,the router may search for previously executed similar tasks,

if local storage resources are available. This similarity searchprocess will take place based on the locality sensitive or featurehash that has been attached by user devices to the offloadedtask. If no previously executed task that can be reused is found,a router will forward a task based on its hash to an edge server.The space of the potential hash values is divided among theavailable edge servers, so that each edge server is responsiblefor the execution of tasks with input data that falls under therange of the hash values assigned to this server. For example,in Figure 2, each hash has a size of 4 bytes, as a result, thepotential hash values will be between 0 and 65,535, whilethese values are equally divided among the available edgeservers.

C. Layer 3: Edge Servers

Edge servers receive offloaded tasks and perform a nearestneighbor search to identify previously executed stored tasksthat could be reused. Once the nearest neighbor of an incomingtask 𝑡 is found, an edge server will check whether the similaritybetween the input data of 𝑡 and the nearest neighbor of 𝑡

exceeds the minimum similarity threshold selected by theapplication that offloaded 𝑡. If this is the case, the found nearestneighbor task will be reused and its results will be returned tothe user in response to 𝑡. Otherwise, the server will execute 𝑡

and store 𝑡 and its execution results for potential reuse in thefuture. Each edge server maintains one or more hash tables thatindex previously executed stored tasks based on the hashes ofthe tasks’ input data. Overall, the edge servers trade storage forcomputing to reduce response times for users and increase thenumber of users, devices, and tasks that can be simultaneouslyaccommodated.

D. Practicality Check: Could Such An Architecture Work?

We implemented and evaluated such an architecture basedon a topology that consists of two user devices, two edgerouters, and two edge servers. Each user device offloads tasksthat are received by an edge router and are forwarded to one ofthe edge servers (each router has connections to both servers).The Round Trip Time (RTT) between devices and serversranges between 12-16 ms. We implemented the LSH semantics(hashing and nearest neighbor search) using the FALCONNlibrary as our basis [9]. The edge servers run tensorflowmachine learning models offering an image annotation service,while images are offloaded from user devices to edge servers.Routers forward tasks towards edge servers as determined inSection III-B and store previously executed tasks directly inthe network. We used the following image datasets as the inputdata of tasks:

• The MNIST dataset consisting of 70K images of hand-written digits [10].

• The Pandaset dataset consisting of 48K images takenfrom cameras on-board autonomous vehicles in Califor-nia, USA [11].

• A dataset of mobile AR consisting of 1K object imagespublished by Stanford University [12].

5

• A dataset of 10K snapshots of vehicle traffic that wecaptured through CCTV cameras monitoring traffic inOmaha, Nebraska, USA.

Our evaluation results indicate that a low-end computer(equipped with a dual core processor and 8GBs of RAM) cangenerate a locality sensitive hash for an image in less than1.8ms. A nearest neighbor search can also be performed inless than 1ms for up to 100K stored images once a localitysensitive hash has been generated. In Table II, we presentthe completion time of offloaded tasks (i.e., the time elapsedbetween the generation of a task by a device and the retrievalof the task’s execution results by this device) for all datasets.Our results indicate that on average the deduplication and reuseof computation resulted in 5.67-16.05× lower task completiontimes than cases where computation deduplication and reuseare not applied.

Furthermore, as we present in Figure 3a, the percentageof tasks that can be reused relies on the similarity betweenthe input data of tasks and decreases as we increase theminimum similarity threshold. Our results show that the pro-posed architecture can accommodate tasks with input datathat exhibits high degrees of similarity (e.g., CCTV dataset),moderate degrees of similarity (e.g., Mobile AR dataset), aswell as lower degrees of similarity (e.g., Pandaset and MNISTdatasets). As we present in Figure 3b, the reuse accuracy(i.e., the percentage of offloaded tasks, which reused taskswith results that were the same as the results that their ownexecution would have produced) improves as we increasethe minimum similarity threshold. The reuse accuracy finallyreaches 95-100% among all datasets for a similarity thresholdof 90%.

TABLE II: Task completion times when reuse occurs: (i) at userdevices and within the edge network infrastructure; and (ii) at edgeservers.

Average Task Completion Time (ms)

Dataset No reuse Reuse (EdgeServers)

Reuse (Devices andEdge Network)

MNIST 120.42 21.23 8.82Pandaset 116.65 19.52 7.26

Mobile AR 106.64 18.32 6.68CCTV 115.68 17.80 7.67

IV. OPEN CHALLENGES AND FUTURE DIRECTIONS

Computation deduplication and reuse shows promise foredge computing environments, having the potential to improveresponse times. However, there are still open challenges to beaddressed leading to several directions of future research.The “curse” of dimensionality: Through hashing, high-dimensional data is converted to a fixed-size value. Thisprocess may require a large space of features for FH and afamily of hash functions for LSH to be applied to task inputdata to maintain satisfactory reuse accuracy. Large featurespaces and LSH function families may result in longer hashingand search times, while also increase the memory requirementsfor user devices, edge routers, and servers. Mechanisms, suchas hierarchical feature hashing [13] and multi-probe LSH [14],

60 70 80 90Similarity Threshold (%)

0102030405060708090

100

Perc

ent o

f Reu

se (%

)

MNISTPandasetMobile ARCCTV

(a) Percentage of reused (not executed from scratch) tasks.

60 70 80 90Similarity Threshold (%)

0102030405060708090

100

Reus

e Ac

cura

cy (%

)

MNISTPandasetMobile ARCCTV

(b) Accuracy of reuse.

Fig. 3: Percentage of reused tasks and accuracy of reuse forall datasets and varying similarity thresholds.

to keep the size of the feature space and the number of LSHfunctions manageable should be further explored.Distribution of hash value space among edge servers:The space of hash values needs to be divided and distributedamong the available edge servers. To achieve that, mecha-nisms of different natures (distributed and centralized) shouldbe explored. Distributed mechanisms can enable servers toessentially form a multicast communication group. In thecontext of this group, servers communicate directly to reacha consensus on how to divide the hash value space andwhich server will be responsible for which range of the hashvalue space. Logically centralized mechanisms may utilizeSoftware-Defined Networking (SDN) controllers, which actas coordination points for the distribution of the hash valuespace among servers. SDN controllers can inform edge routersabout the distribution of the hash value space among servers,populating the reuse information table of routers. Initially, thehash value space can be equally distributed among servers,while it can be dynamically redistributed to balance the loadamong servers as we describe below.Balancing the load across edge servers: As the space ofthe potential hash values is divided among edge servers, loadimbalances may occur. For example, if large amounts of taskswith similar input data are generated, all the tasks may beforwarded to the same server(s), increasing the load of certainservers, while leaving other servers under-utilized. This calls

6

for mechanisms to achieve load balancing and reuse at thesame time. For example, SDN controllers can monitor thecomputation reuse performance and overhead among serversover time as well as the load of servers and redistribute partsof the hash value space from one server to another to balancethe load.Predicting the likelihood of reuse: The storage resources ofuser devices, edge routers, and servers may have a limitedcapacity. In environments that offer computation reuse, thedifferent layers of the architecture may not be able to storethe results of all executed tasks. To increase the impact andbenefits of reuse, mechanisms to estimate/predict the chancesthat an executed task may be reused in the future need to befurther explored. As a result, tasks not likely to be reused inthe future may not be stored after execution, offering availablestorage space to tasks, which are likely to be reused. Overall,such mechanisms may also be essential in cases of tasks thatconsist of multiple sub-tasks (e.g., tasks that are formulatedas a computation graph) to determine which sub-tasks to storeand which ones to discard across the different layers of thearchitecture.Extending the notion of computation reuse: In this paper,we have focused on the reuse of computation for taskswith similar input data that yield the same execution results.This ensures that the operation of applications and the user-perceived quality of experience are not negatively impacted,since previously executed tasks are reused only if they yieldthe same results as offloaded tasks. However, research direc-tions, such as approximate computing [15], suggest that certainapplications may be able to operate with approximate (notfully precise) processing results of the data they generate with-out significant degradation of user experience. Such directionsmay enable the expansion of the notion of computation reuseas defined in our work, so that tasks that yield similar resultscan also be reused. A thorough assessment of the reuse oftasks that yield similar versus the same results and its impacton the perceived user quality of experience should be furtherinvestigated.Privacy implications: Attackers can probe the edge archi-tecture to discover if tasks for the same service and withsimilar input data have been previously executed. For example,attackers can offload tasks with images to be processed byan object detection edge service, while knowing that suchtasks may need hundreds of milliseconds to be executed. Asa result, if the execution results are received much soonerthan that, attackers can infer that a task with similar inputdata was reused. The implications of reuse on the privacy ofcomputations and the associated input data should be furtherinvestigated.Scalability: Given the projected growth of user devices andthe wide spectrum of next-generation applications, scalabilitybecomes a major challenge for computation deduplication andreuse architectures. Techniques to engineer and optimize theperformance of hashing and nearest neighbor search operationscan contribute to scaling up the number of tasks that can behandled. The scalability of computation reuse architecturescan be further enhanced by performing reuse not only on thebasis of individual applications, but for groups of applications

that require the same type of data processing. For example,applications in need of the detection of objects in images mayinvoke different services of the same type/nature deployed atthe edge. Such services essentially provide the same type ofdata processing (i.e., detection of objects in images), however,they may achieve that through different object detection algo-rithms.

V. CONCLUSION

In this paper, we presented the promise and challengesof computation deduplication and reuse in edge computingenvironments. We first presented use-cases, which computa-tion reuse can benefit, and we then discussed the technicalchallenges of realizing solutions for the reuse of computationat the edge. Moreover, we presented the design of a multi-layer architecture for computation reuse and several open chal-lenges and research directions. We believe that the effectivemanagement of the massive computation volumes projected tobe produced at the edge will become a pressing issue, whilereusing computation among devices, users, and applicationswill become a key mechanism to improve response times andaccommodate additional users, devices, and tasks.

ACKNOWLEDGEMENTS

This work is partially supported by NIH(NIGMS/P20GM109090), NSF under awards CNS-2016714and CNS-2104700, the Nebraska University CollaborationInitiative, and the Nebraska Tobacco Settlement BiomedicalResearch Development Funds.

REFERENCES

[1] W. Shi et al., “Edge computing: Vision and challenges,” IEEE internetof things journal, vol. 3, no. 5, pp. 637–646, 2016.

[2] M. Satyanarayanan, “The emergence of edge computing,” Computer,vol. 50, no. 1, pp. 30–39, 2017.

[3] P. Guo et al., “Foggycache: Cross-device approximate computationreuse,” in Proceedings of the 24th Annual International Conference onMobile Computing and Networking, 2018, pp. 19–34.

[4] Z. Zivkovic, “Improved adaptive gaussian mixture model for backgroundsubtraction,” in Proceedings of the 17th International Conference onPattern Recognition, 2004. ICPR 2004. IEEE, 2004.

[5] U. Drolia et al., “Cachier: Edge-caching for recognition applications,”in 2017 IEEE 37th international conference on distributed computingsystems (ICDCS). IEEE, 2017, pp. 276–286.

[6] P. Guo and W. Hu, “Potluck: Cross-application approximate deduplica-tion for computation-intensive mobile applications,” in Proceedings ofthe Twenty-Third International Conference on Architectural Support forProgramming Languages and Operating Systems, 2018, pp. 271–284.

[7] J. Meng et al., “Coterie: Exploiting frame similarity to enable high-quality multiplayer vr on commodity mobile devices,” in Proceedingsof the Twenty-Fifth International Conference on Architectural Supportfor Programming Languages and Operating Systems, 2020, pp. 923–937.

[8] S. Mastorakis et al., “ICedge: when edge computing meets information-centric networking,” IEEE Internet of Things Journal, vol. 7, no. 5, pp.4203–4217, 2020.

[9] A. Andoni et al., “Practical and optimal lsh for angular distance,” arXivpreprint arXiv:1509.02897, 2015.

[10] Y. LeCun, “The mnist database of handwritten digits,”http://yann.lecun.com/exdb/mnist/, Accessed on March 10, 2021,1998.

[11] “Pandaset by hesai and scale ai,” https://pandaset.org, Accessed onMarch 10, 2021.

[12] M. Makar et al., “Interframe coding of canonical patches for lowbit-rate mobile augmented reality,” International Journal of SemanticComputing, vol. 7, pp. 5–24, 2013.

7

[13] B. Zhao et al., “Hierarchical feature hashing for fast dimensionalityreduction,” in Proceedings of the IEEE Conference on Computer Visionand Pattern Recognition, 2014, pp. 2043–2050.

[14] Q. Lv et al., “Multi-probe lsh: efficient indexing for high-dimensionalsimilarity search,” in 33rd International Conference on Very Large DataBases, VLDB 2007. Association for Computing Machinery, Inc, 2007,pp. 950–961.

[15] J. Han and M. Orshansky, “Approximate computing: An emergingparadigm for energy-efficient design,” in 2013 18th IEEE European TestSymposium (ETS). IEEE, 2013, pp. 1–6.

BIOGRAPHIES

Md Washik Al Azad (malazad@unomaha.edu) is a Ph.D. student at theUniversity of Nebraska Omaha. He received his B.S. in Electronics andTelecommunication Engineering from the Rajshahi University of Engineering& Technology, Bangladesh in 2017. His interests include edge computing andsecurity.

Spyridon Mastorakis (smastorakis@unomaha.edu) is an Assistant Professorin Computer Science at the University of Nebraska Omaha. He received hisPh.D. in Computer Science from the University of California, Los Angeles in2019. His research interests include network systems and architectures, edgecomputing, and security.