Serverless Functions Research Articles

Resource Management for Latency-Sensitive IoT Applications With Satisfiability

Satisfying the software requirements of emerging service-based Internet of Things (IoT) applications has become challenging for cloud-centric architectures, as applications demand fast response times and availability of computational resources closer to end-users. Meeting application demands must occur at runtime, facing uncertainty and in a decentralized manner, something that must be reflected in system deployment. We propose a decentralized resource management technique and accompanying technical framework for the deployment of service-based IoT applications at the edge. Faithful to services engineering, applications we consider are composed of interdependent tasks, which in the IoT setting may be concretized as containerized microservices or serverless functions. A deployment for an arbitrary application is found at runtime through satisfiability; the mapping produced is compliant with tasks’ individual resource requirements and latency constraints by construction. Our approach ensures seamless deployment at runtime, assuming no design-time knowledge of device resources or the current network topology. We evaluate the applicability and realizability of our technique over single-board computers as edge devices, particularly in the absence of cloud resources.

Serverless Based Functions Aware Framework for Healthcare Application

These days, the usage of Internet of Medical Things (IoMT) to deal with the different diseases has been increasing with time in the practice. Cloud computing is a paradigm which offers services based on internet to run IoMT application in the efficient way. However, due to long latency, cloud computing introduces fog server which brings service at the edge of hospital network. All existing fog-cloud based system charged servicing rent based on hourly, weekly, monthly, and yearly. The result a lot of cost wastage for the patients whenever, they do not require service, but still, they are paying for rented services. To cope with the useless renting cost, the study devises the serverless function as a service system which offers services to run IoMT application with their usage instead of resource provisioning as existing studied exploited in the system. The virtual machine based healthcare charged based on hour, week, month, and year, and however, healthcare sensors need service at specific time. Therefore, there is a lot cost of services in the ideal time where services are free but users paid money due to rent from providers. This paper suggests serverless function as a service based system which charge only for usage instead of renting cost for execution inside system. Simulation results shows that, the proposed system not only minimize the IoMT application cost but improved the resource utilization of the system

Latency-Sensitive Edge/Cloud Serverless Dynamic Deployment Over Telemetry-Based Packet-Optical Network

The serverless technology, introduced for data center operation, represents an attractive technology for latency-sensitive applications operated at the edge, enabling a resource-aware deployment accounting for limited edge computing resources or end-to-end network congestion to the cloud. This paper presents and validates a framework for automated deployment and dynamic reconfiguration of serverless functions at either the edge or cloud. The framework relies on extensive telemetry data retrieved from both the computing and packet-optical network infrastructure and operates on diverse Amazon Web Services technologies, including Greengrass on the edge. Experimental demonstration with a latency-sensitive serverless application is then provided, showing fast dynamic reconfiguration capabilities, e.g., enabling even zero outage time under certain conditions.

λDNN: Achieving Predictable Distributed DNN Training With Serverless Architectures

Serverless computing is becoming a promising paradigm for Distributed Deep Neural Network (DDNN) training in the cloud, as it allows users to decompose complex model training into a number of <i>functions</i> without managing virtual machines or servers. Though provided with a simpler resource interface (i.e., function number and memory size), inadequate function resource provisioning (either under-provisioning or over-provisioning) easily leads to <i>unpredictable</i> DDNN training performance in serverless platforms. Our empirical studies on AWS Lambda indicate that, such <i>unpredictable performance</i> of serverless DDNN training is mainly caused by the resource bottleneck of Parameter Servers (PS) and small local batch size. In this article, we design and implement <i><inline-formula><tex-math notation="LaTeX">$\lambda$</tex-math><alternatives><mml:math><mml:mi>&#x03BB;</mml:mi></mml:math><inline-graphic xlink:href="xu-ieq1-3054656.gif"/></alternatives></inline-formula>DNN</i>, a cost-efficient function resource provisioning framework to provide predictable performance for serverless DDNN training workloads, while saving the budget of provisioned functions. Leveraging the PS network bandwidth and function CPU utilization, we build a <i>lightweight</i> analytical DDNN training performance model to enable our design of <i><inline-formula><tex-math notation="LaTeX">$\lambda$</tex-math><alternatives><mml:math><mml:mi>&#x03BB;</mml:mi></mml:math><inline-graphic xlink:href="xu-ieq2-3054656.gif"/></alternatives></inline-formula>DNN</i> resource provisioning strategy, so as to guarantee DDNN training performance with serverless functions. Extensive prototype experiments on AWS Lambda and complementary trace-driven simulations demonstrate that, <i><inline-formula><tex-math notation="LaTeX">$\lambda$</tex-math><alternatives><mml:math><mml:mi>&#x03BB;</mml:mi></mml:math><inline-graphic xlink:href="xu-ieq3-3054656.gif"/></alternatives></inline-formula>DNN</i> can deliver predictable DDNN training performance and save the monetary cost of function resources by up to 66.7 percent, compared with the state-of-the-art resource provisioning strategies, yet with an acceptable runtime overhead.

Edge‐adaptable serverless acceleration for machine learning Internet of Things applications

AbstractServerless computing is an emerging event‐driven programming model that accelerates the development and deployment of scalable web services on cloud computing systems. Though widely integrated with the public cloud, serverless computing use is nascent for edge‐based, Internet of Things (IoT) deployments. In this work, we present STOIC (serverless teleoperable hybrid cloud), an IoT application deployment and offloading system that extends the serverless model in three ways. First, STOIC adopts a dynamic feedback control mechanism to precisely predict latency and dispatch workloads uniformly across edge and cloud systems using a distributed serverless framework. Second, STOIC leverages hardware acceleration (e.g., GPU resources) for serverless function execution when available from the underlying cloud system. Third, STOIC can be configured in multiple ways to overcome deployment variability associated with public cloud use. We overview the design and implementation of STOIC and empirically evaluate it using real‐world machine learning applications and multitier IoT deployments (edge and cloud). Specifically, we show that STOIC can be used for training image processing workloads (for object recognition)—once thought too resource‐intensive for edge deployments. We find that STOIC reduces overall execution time (response latency) and achieves placement accuracy that ranges from 92% to 97%.

Benchmarking Deep Neural Network Inference Performance on Serverless Environments With MLPerf

We provide a novel decomposition methodology from the current MLPerf benchmark to the serverless function execution model. We have tested our approach in Amazon Lambda to benchmark the processing capabilities of OpenCV and OpenVINO inference engines.

A Lightweight Design for Serverless Function as a Service

FaaS (Function as a Service) allows developers to upload and execute code in the cloud without managing servers. FaaS offerings from leading public cloud providers are based on system microVM or application container technologies such as Firecracker or Docker. In this paper, we demonstrate that lightweight high-level runtimes, such as WebAssembly, could offer performance and scaling advantages over existing solutions, and could enable finely-grained pay-as-you-use business models. We compared widely used performance benchmarks between Docker native and WebAssembly implementations of the same algorithms. We also discuss the barriers for WebAssembly adoption in serverless computing, such as the lack of tooling support.

Execution of Long-Duration Multi-Cloud Serverless Functions Using Selective Migration-Based Approach

A relatively new paradigm for the Cloud-based software deployment is serverless computing. By adopting stateless loosely-coupled functions, the system can obtain many compositions for several purposes. Contrarily to monolithic approach, serverless computing facilitates the evolution of the applications, since the functions may be independently scheduled for reconstitution. Nevertheless, serverless computing dictates that function execution should be within a short duration (five minutes max in most Cloud platforms), after which the function is abruptly ended even if it has not completed its task. This leads to prevent functions requiring longer time from being adopted as Serverless functions. This paper deals with this drawback. It proposes a migration-based approach that promotes the execution of long-duration serverless functions: each running function that reaches the maximum time limit is repeatedly transferred to another cloud platform where it is carried on. At each migration step, the destination cloud is selected regarding the most relevant criteria.

Serverless Blockchain-Enabled Architecture for IoT Societal Applications

IoT-enabled applications, such as cloud manufacturing, guided water quality or air quality analysis, energy-conscious societal applications, and smart agricultural economics, are designed using a blend of high-end computing technologies, such as cloud, edge, and fog. Smart cities and governmental authorities keep a keen eye out for implementing IoT applications in an automated/decentralized approach with enhanced security measures so that tens of thousands of users, including entrepreneurs, are benefited. Existing IoT architectures are prone to energy inefficiency or resource underutilization problems due to the avoidance of apt technologies, such as serverless computing. This article proposes to set forth a serverless blockchain-enabled IoT architecture for societal applications. It explores the existing IoT architectures and pinpoints the advantages of applying serverless blockchains on IoT architectures. In addition, the proposed IoT architecture is illustrated with a specific use case of IoT societal applications namely air quality monitoring for smart cities (AQMS). This article discloses how air quality sensor data from defective industries were securely transacted to blockchain networks surpassing from the three levels of computing namely edge, fog, and cloud while utilizing serverless and server-oriented functions. In addition, this article exposes a list of the most potent serverless functions that assist AQMS IoT societal applications in detail. The IoT architecture, discussed in this article, will enable innovations and research works for IoT developers and researchers.

HCloud: A trusted JointCloud serverless platform for IoT systems with blockchain

Cloud computing has been exploited in managing large-scale IoT systems. IoT cloud servers usually handle a large number of requests from various IoT devices. Due to the fluctuant and heavy workload, the servers require the cloud to provide high scalability, stable performance, low price and necessary functionalities. However, traditional clouds usually offer computing service with the abstraction of virtual machine (VM), which can hardly meet these requirements. Meanwhile, different cloud vendors provide different performance stabilities and price models, which fluctuate according to the dynamic workload. A single cloud cannot satisfy all the requirements of the IoT scenario well. The JointCloud computing model empowers the cooperation among multiple public clouds. However, it is still difficult to dynamically schedule the workload on different clouds based on the VM abstraction. This paper introduces HCloud, a trusted JointCloud platform for IoT systems using serverless computing model. HCloud allows an IoT server to be implemented with multiple serverless functions and schedules these functions on different clouds based on a schedule policy. The policy is specified by the client and includes the required functionalities, execution resources, latency, price and so on. HCloud collects the status of each cloud and dispatches serverless functions to the most suitable cloud based on the schedule policy. By leveraging the blockchain technology, we further enforce that our system can neither fake the cloud status nor wrongly dispatch the target functions. We have implemented a prototype of HCloud and evaluated it by simulating multiple cloud providers. The evaluation results show that HCloud can greatly improve the performance of serverless workloads with negligible costs.

AFCL: An Abstract Function Choreography Language for serverless workflow specification

Serverless workflow applications or function choreographies (FCs), which connect serverless functions by data- and control-flow, have gained considerable momentum recently to create more sophisticated applications as part of Function-as-a-Service (FaaS) platforms. Initial experimental analysis of the current support for FCs uncovered important weaknesses, including provider lock-in, and limited support for important data-flow and control-flow constructs. To overcome some of these weaknesses, we introduce the Abstract Function Choreography Language (AFCL) for describing FCs at a high-level of abstraction, which abstracts the function implementations from the developer. AFCL is a YAML-based language that supports a rich set of constructs to express advanced control-flow (e.g. parallelFor loops, parallel sections, dynamic loop iterations counts) and data-flow (e.g multiple input and output parameters of functions, DAG-based data-flow). We introduce data collections which can be distributed to loop iterations and parallel sections that may substantially reduce the delays for function invocations due to reduced data transfers between functions. We also support asynchronous functions to avoid delays due to blocking functions. AFCL supports properties (e.g. expected size of function input data) and constraints (e.g. minimize execution time) for the user to optionally provide hints about the behavior of functions and FCs and to control the optimization by the underlying execution environment. We implemented a prototype AFCL environment that supports AFCL as input language with multiple backends (AWS Lambda and IBM Cloud Functions) thus avoiding provider lock-in which is a common problem in serverless computing. We created two realistic FCs from two different domains and encoded them with AWS Step Functions, IBM Composer and AFCL. Experimental results demonstrate that our current implementation of the AFCL environment substantially outperforms AWS Step Functions and IBM Composer in terms of development effort, economic costs, and makespan.

SDCF: A Software-Defined Cyber Foraging Framework for Cloudlet Environment

The cloudlets can be deployed over mobile devices or even fixed state powerful servers that can provide services to its users in physical proximity. Executing workloads on cloudlets involves challenges centering on limited computing resources. Executing Virtual Machine (VM) based workloads for cloudlets does not scale due to the high computational demands of a VM. Another approach is to execute container-based workloads on cloudlets. However, container-based methods suffer from the cold-start problem, making it unfit for mobile edge computing scenarios. In this work, we introduce executing serverless functions on Web-assembly as workloads for both mobile and fixed state cloudlets. To execute the serverless workload on mobile cloudlets, we built a lightweight Web-assembly runtime. The orchestration of workloads and management of cloudlets or serverless runtime is done by introducing software-defined Cyber Foraging (SDCF) framework, which is a hybrid controller including a control plane for local networks and cloudlets. The SDCF framework integrates the management of cloudlets by utilizing the control plane traffic of the underlying network and thus avoids the extra overhead of cloudlet control plane traffic management. We evaluate SDCF using three use cases: (1) Price aware resource allocation (2) Energy aware resource scheduling for mobile cloudlets (3) Mobility pattern aware resource scheduling in mobile cloudlets. Through the virtualization of cloudlet resources, SDCF preserves minimal maintenance property by providing a centralized approach for configuring and management of cloudlets.

I/O resource isolation of public cloud serverless function runtimes for data-intensive applications

Serverless computing and a function execution model, Function-as-a-Service (FaaS), are currently receiving considerable attention from both academia and industry. One of the reasons for the success of serverless computing is its straightforward interface that abstracts complex internals of cloud computing resource usage and configurations. However, this approach may result in hiding too much information about how underlying cloud resources would work, entailing that users cannot predict how their applications will perform, especially for IO-heavy ones. To address this issue, we evaluate several aspects of network and disk IO performance with realistic workloads using public FaaS systems. Our analysis reveals that current public FaaS systems do not provide appropriate levels of IO performance differentiation, and the ability to isolate network resource allocation during concurrent execution is rarely offered by service providers. Based on the results presented in this paper, we insist that it must be mandatory for network and disk IO resource performance of FaaS to be more visible and predictable, as is the case for memory and CPU, in order to expand serverless computing applications to data-intensive ones.

Stateless IoT

Energy consumption is a relevant matter in the design of IoT applications. Edge units—sensors and actuators—save energy by operating intermittently. When idle, they suspend their operation, losing the content of the onboard memory. Their internal state, needed to resume their work, is recorded on external storage: in the end, their internal operation is stateless. The backend infrastructure does not follow the same design principle: concentrators, routers, and servers are always-on devices that frustrate the energy-saving operation of edge devices. In this paper, we show how serverless functions, asynchronously invoked by the stateless edge devices, are an energy-saving option. We introduce a basic model for system operation and energy footprint evaluation. To demonstrate its soundness, we study a simple use case, from the design to a prototype.

Enabling Serverless Deployment of Large-Scale AI Workloads

We propose a set of optimization techniques for transforming a generic AI codebase so that it can be successfully deployed to a restricted serverless environment, without compromising capability or performance. These involve (1) slimming the libraries and frameworks (e.g., pytorch) used, down to pieces pertaining to the solution; (2) dynamically loading pre-trained AI/ML models into local temporary storage, during serverless function invocation; (3) using separate frameworks for training and inference, with ONNX model formatting; and, (4) performance-oriented tuning for data storage and lookup. The techniques are illustrated via worked examples that have been deployed live on geospatial data from the transportation domain. This draws upon a real-world case study in intelligent transportation looking at on-demand, realtime predictions of flows of train movements across the UK rail network. Evaluation of the proposed techniques shows the response time, for varying volumes of queries involving prediction, to remain almost constant (at 50 ms), even as the database scales up to the 250M entries. The query response time is important in this context as the target is predicting train delays. It is even more important in a serverless environment due to the stringent constraints on serverless functions’ runtime before timeout. The similarities of a serverless environment to other resource constrained environments (e.g., IoT, telecoms) means the techniques can be applied to a range of use cases.

6G Architecture to Connect the Worlds

The post-pandemic future will offer tremendous opportunity and challenge from transformation of the human experience linking physical, digital and biological worlds: 6G should be based on a new architecture to fully realize the vision to connect the worlds. We explore several novel architecture concepts for the 6G era driven by a decomposition of the architecture into platform, functions, orchestration and specialization aspects. With 6G, we associate an open, scalable, elastic, and platform agnostic het-cloud, with converged applications and services decomposed into micro-services and serverless functions, specialized architecture for extreme attributes, as well as open service orchestration architecture. Key attributes and characteristics of the associated architectural scenarios are described. At the air-interface level, 6G is expected to encompass use of sub-Terahertz spectrum and new spectrum sharing technologies, air-interface design optimized by AI/ML techniques, integration of radio sensing with communication, and meeting extreme requirements on latency, reliability and synchronization. Fully realizing the benefits of these advances in radio technology will also call for innovations in 6G network architecture as described.

Serverless Stream Processing with Elastic Multi-M/M/s/K Queue System

The high throughput - low latency stream processing systems are required to be elastic enough to scale for varying load spike on-demand. However, in the current stream processing systems, the load shedding is observed which impacts the final accuracy. In order to get rid of this issue, the elasticity can be implemented in all kinds of resources involved in the stream processing systems. This paper focuses on providing the elastic scalability in queues and Serverless functions for the event stream processing systems. First, we explain the need of elastic multi-queue with Serverless function in detail for event stream processing, and then will propose an algorithm for elastic scalability of multi-M/M/s/K Queuing with Serverless functions for the efficient stream processing. The experiment result shows that the system scales very well in short span of time with the help of our proposed algorithm. The increased availability in turn helps improving the high processing throughput in low latency.

Formal foundations of serverless computing

Serverless computing (also known as functions as a service) is a new cloud computing abstraction that makes it easier to write robust, large-scale web services. In serverless computing, programmers write what are called serverless functions, which are programs that respond to external events. When demand for the serverless function spikes, the platform automatically allocates additional hardware and manages load-balancing; when demand falls, the platform silently deallocates idle resources; and when the platform detects a failure, it transparently retries affected requests. In 2014, Amazon Web Services introduced the first serverless platform, AWS Lambda, and similar abstractions are now available on all major cloud computing platforms. Unfortunately, the serverless computing abstraction exposes several low-level operational details that make it hard for programmers to write and reason about their code. This paper sheds light on this problem by presenting λ λ , an operational semantics of the essence of serverless computing. Despite being a small (half a page) core calculus, λ λ models all the low-level details that serverless functions can observe. To show that λ λ is useful, we present three applications. First, to ease reasoning about code, we present a simplified naive semantics of serverless execution and precisely characterize when the naive semantics and λ λ coincide. Second, we augment λ λ with a key-value store to allow reasoning about stateful serverless functions. Third, since a handful of serverless platforms support serverless function composition, we show how to extend λ λ with a composition language and show that our implementation can outperform prior work.

RADON: rational decomposition and orchestration for serverless computing

Emerging serverless computing technologies, such as function as a service (FaaS), enable developers to virtualize the internal logic of an application, simplifying the management of cloud-native services and allowing cost savings through billing and scaling at the level of individual functions. Serverless computing is therefore rapidly shifting the attention of software vendors to the challenge of developing cloud applications deployable on FaaS platforms. In this vision paper, we present the research agenda of the RADON project (http://radon-h2020.eu), which aims to develop a model-driven DevOps framework for creating and managing applications based on serverless computing. RADON applications will consist of fine-grained and independent microservices that can efficiently and optimally exploit FaaS and container technologies. Our methodology strives to tackle complexity in designing such applications, including the solution of optimal decomposition, the reuse of serverless functions as well as the abstraction and actuation of event processing chains, while avoiding cloud vendor lock-in through models.

Troubleshooting Serverless functions: a combined monitoring and debugging approach

Today, Serverless computing gathers pace and attention in the cloud computing area. The abstraction of operational tasks combined with the auto-scaling property are convincing reasons to adapt this new cloud paradigm. Building applications in a Serverless style via cloud functions is challenging due to the fine-grained architecture and the tighter coupling to back end services. Increased complexity, loss of control over software layers and the large number of participating functions and back end services complicate the task of finding the cause of a faulty execution. A tedious but widespread strategy is the manual analysis of log data. In this paper, we present a semi-automated troubleshooting process to improve fault detection and resolution for Serverless functions. Log data is the vehicle to enable a posteriori analysis. The process steps of our concept enhance the log quality, detect failed executions automatically, and generate test skeletons based on the information provided in the log data. Ultimately, this leads to an increased test coverage, a better regression testing and more robust functions. Developers can trigger this process asynchronously and work with their accustomed tools. We also present a prototype SeMoDe to validate our approach for Serverless functions implemented in Java and deployed to AWS Lambda.