Isolation without taxation: near-zero-cost transitions for WebAssembly and SFI

Software sandboxing or software-based fault isolation (SFI) is a lightweight approach to building secure systems out of untrusted components. Mozilla, for example, uses SFI to harden the Firefox browser by sandboxing third-party libraries, and companies like Fastly and Cloudflare use SFI to safely co-locate untrusted tenants on their edge clouds. While there have been significant efforts to optimize and verify SFI enforcement, context switching in SFI systems remains largely unexplored: almost all SFI systems use heavyweight transitions that are not only error-prone but incur significant performance overhead from saving, clearing, and restoring registers when context switching. We identify a set of zero-cost conditions that characterize when sandboxed code has sufficient structured to guarantee security via lightweight zero-cost transitions (simple function calls). We modify the Lucet Wasm compiler and its runtime to use zero-cost transitions, eliminating the undue performance tax on systems that rely on Lucet for sandboxing (e.g., we speed up image and font rendering in Firefox by up to 29.7% and 10% respectively). To remove the Lucet compiler and its correct implementation of the Wasm specification from the trusted computing base, we (1) develop a static binary verifier , VeriZero, which (in seconds) checks that binaries produced by Lucet satisfy our zero-cost conditions, and (2) prove the soundness of VeriZero by developing a logical relation that captures when a compiled Wasm function is semantically well-behaved with respect to our zero-cost conditions. Finally, we show that our model is useful beyond Wasm by describing a new, purpose-built SFI system, SegmentZero32, that uses x86 segmentation and LLVM with mostly off-the-shelf passes to enforce our zero-cost conditions; our prototype performs on-par with the state-of-the-art Native Client SFI system.

Hardware Context Switch-based Cryptographic Accelerator for Handling Multiple Streams

The confidentiality and integrity of a stream has become one of the biggest issues in telecommunication. The best available algorithm handling the confidentiality of a data stream is the symmetric key block cipher combined with a chaining mode of operation such as cipher block chaining (CBC) or counter mode (CTR). This scheme is difficult to accelerate using hardware when multiple streams coexist. This is caused by the computation time requirement and mainly by management of the streams. In most accelerators, computation is treated at the block-level rather than as a stream, making the management of multiple streams complex. This article presents a solution combining CBC and CTR modes of operation with a hardware context switching. The hardware context switching allows the accelerator to treat the data as a stream. Each stream can have different parameters: key, initialization value, state of counter. Stream switching was managed by the hardware context switching mechanism. A high-level synthesis tool was used to generate the context switching circuit. The scheme was tested on three cryptographic algorithms: AES, DES, and BC3. The hardware context switching allowed the software to manage multiple streams easily, efficiently, and rapidly. The software was freed of the task of managing the stream state. Compared to the original algorithm, about 18%–38% additional logic elements were required to implement the CBC or CTR mode and the additional circuits to support context switching. Using this method, the performance overhead when treating multiple streams was low, and the performance was comparable to that of existing hardware accelerators not supporting multiple streams.

Task Scheduling Management for Load Balancing Using Task Grouping Based on Cloud Computing

Managing task scheduling management in cloud computing is an essential part for the landscape of complex procedure tasks based on various resources in a proficient and scalable path. The aim of this research is to dynamically optimize the aforesaid issue of task scheduling. The task management improvises the imperfection algorithm by pursue on weighted fair queuing model, which is significantly effective compared to the existing method. A task scheduling model has been created to demonstrate the proposed scheduler management. Study shows the improvement in the adaptation of round robin and shortest job first algorithm performing better than the existing algorithm according to the differentiate execution measurements such as, turnaround time, task size and average waiting time. In addition, context switches play an important role in algorithm by sharing between multiple tasks and running task in the scheduler. Altogether, a significant improvement between existing algorithm and proposed studies follows up accordingly to a specific context switching takes place.

Analisis Algoritma Round Robin pada Penjadwalan CPU

ABSTRAK. Penjadwalan adalah konsep penting dalam sistem operasi multiprosesor dan multitasking pada sistem operasi waktu-nyata dengan mengalihkan proses pada CPU. Algoritma Round Robin adalah algoritma yang terkenal pada penjadwalan CPU. Algoritma Round Robin memberikan waktu quantum antara pengalihan proses. Memilih waktu quantum dalam Algoritma Round Robin sangatlah penting, waktu quantum besar akan mengakibatkan context switching lebih sedikit, sementara waktu quantum lebih kecil akan mengakibatkan context switching yang lebih sering. Algoritma Round Robin yang efisien adalah jumlah context switching lebih rendah. Untuk waktu tunggu, ide dasarnya adalah untuk mendapatkan waktu tunggu rata-rata yang lebih kecil, sehingga sistem lebih efisien. Turn around time juga harus minimum, yang berarti juga lebih efisien. Dua studi kasus didiskusikan untuk memahami algoritma ini dengan lebih mendalam. Kata kunci: Algoritma Round Robin, waktu quantum, context switching, rata-rata waktu tunggu, rata-rata turn around time

Dynamic approach to minimize overhead and response time in scheduling periodic real-time tasks

In real-time systems, a task or a set of tasks needs to be executed and completed successfully within a predefined time. Those systems require a scheduling technique or a set of scheduling methods to distribute the given task or the set of tasks among different processors or on a processor. In this paper, a new novel scheduling approach to minimize the overhead from context switching between several periodic tasks is presented. This method speeds up a required response time while ensuring that all tasks meet their deadline times and there is no deadline miss occurred. It is a dynamic-priority technique that works either on a uniprocessor or several processors. In particular, it is proposed to be applied on multiprocessor environments since many applications run on several processors. Various examples are presented within this paper to demonstrate its optimality and efficiency. In addition, several comparison experiments with an earlier version of this approach were performed to demonstrate its efficiency and effectiveness too. Those experiments showed that this novel approach sped up the execution time from 15% to nearly around 46%. In addition, it proved that it reduced the number of a context switch between tasks from 12% to around 50% as shown from simulation tests. Furthermore, this approach delivered all tasks/jobs successfully and ensured there was no deadline miss happened.

The Decidability of Verification under PS 2.0

We consider the reachability problem for finite-state multi-threaded programs under thepromising semantics() of Lee et al., which captures most common program transformations. Since reachability is already known to be undecidable in the fragment of with only release-acquire accesses (-), we consider the fragment with only relaxed accesses and promises (). We show that reachability under is undecidable in general and that it becomes decidable, albeit non-primitive recursive, if we bound the number of promises.Given these results, we consider a bounded version of the reachability problem. To this end, we bound both the number of promises and of “view-switches”, i.e., the number of times the processes may switch their local views of the global memory. We provide a code-to-code translation from an input program under (with relaxed and release-acquire memory accesses along with promises) to a program under SC, thereby reducing the bounded reachability problem under to the bounded context-switching problem under SC. We have implemented a tool and tested it on a set of benchmarks, demonstrating that typical bugs in programs can be found with a small bound.

Synchronization-Aware Task Allocation Techniques for Preemption Control to Reduce Blocking Time in Multiprocessor Real-Time System

Multiprocessor real-time systems receive a great deal of attention. For better utilization of multiprocessors in a real-time context, an optimal approach for scheduling, allocation, and synchronization is required. In this research, a novel heuristic synchronization-aware scheduling has been proposed to reduce the blocking delays in a critical section and also bound to minimize multiple priority inversion. The key idea of this technique is to assign the task set in the same processor that accesses a common shared resource and also access them for the longest period of time; thereby, the global sharing of resource transforms into local sharing. From simulation results, it was concluded that the duration of blocking overheads should be minimized up to 25% to 30% and context switching between processors also reduced up to 10% to 15%. On the basis of result analysis, schedulability, minimization of context switching, and reduced blocking time indicate that the proposed method outperforms the existing methods and does not affect the task completion time.