Reviewerly/exHarmony huggingface dataset:
Efficient Implementation of Ring-Binary-LWE-based Lightweight PQC Accelerator on the FPGA Platform

Post-quantum cryptography (PQC) has gained sub-stantial attention from various communities recently. Along with the ongoing National Institute of Standards and Technology (NIST) PQC standardization process that targets the general-purpose PQC algorithms, the research community is also looking for efficient lightweight PQC schemes. Among this direction of efforts, Ring-Binary-Learning-with-Errors (RBLWE)-based encryption scheme (RBLWE-ENC) is regarded as a promising lightweight PQC fitting Internet-of-Things (IoT) and edge computing applications. As hardware implementation for PQC algorithms has become one of the major advances in the field, in this paper, we follow this trend to present an efficient implementation of RBLWE-ENC lightweight accelerator on the field-programmable gate array (FPGA) platform. Overall, we have demonstrated three coherent interdependent stages of efforts: (i) we have presented detailed derivation processes to formulate the proposed algorithmic operation; (ii) we have then implemented the proposed algorithm into a desired hardware accelerator; and (iii) we provided thorough complexity analysis and comparison to showcase the superior performance of the proposed accelerator over the state-of-the-art designs, e.g., the proposed accelerator with <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$v=8$</tex> has at least 66.67% less area-time complexities than the existing ones (Virtex-7 FPGA). We hope the outcome of this work can facilitate lightweight PQC development.
Cracking-Like Join for Trusted Execution Environments

Data processing on non-trusted infrastructures, such as the public cloud, has become increasingly popular, despite posing risks to data privacy. However, the existing cloud DBMSs either lack sufficient privacy guarantees or underperform. In this paper, we address both challenges (privacy and efficiency) by proposing CrkJoin, a join algorithm that leverages Trusted Execution Environments (TEE). We adapted CrkJoin to the architecture of TEEs to achieve significant improvements in latency of up to three orders of magnitude over baselines in a multi-tenant scenario. Moreover, CrkJoin offers at least 2.9x higher throughput than the state-of-the-art algorithms. Our research is unique in that it focuses on both privacy and efficiency concerns, which has not been adequately addressed in previous studies. Our findings suggest that CrkJoin makes joining in TEEs practical, and it lays a foundation towards a truly private and efficient cloud DBMS.
A Metric for Measuring Software Engineering Post-Graduate Outcomes

Professional software engineering (SE) degree programs provide students with the education and skills needed to enter a new SE career, or take on increasing responsibility within their current career. An important metric for evaluating such programs is the impact that completing the program has on postgraduate, career outcomes. Apart from hiring rates and median salaries, this is challenging to measure, because alumni survey response rates are frequently low, and without alumni feedback, insight into individual career advancement after graduation is difficult to observe. In this paper, we propose a new metric, called Career Velocity, that measures the impact of a degree program on alumni promotion into senior positions. The metric requires tracing alumni directory information, consisting of a person’s full name, degree name, and graduation year, to public data that includes employment histories, before computing the number of months prior to promotion into a senior SE position. The metric was developed and evaluated on a mix of six degree programs, including undergraduate and graduate computer science, software engineering and data science programs. The metric was further evaluated by assessing the impact of a graduate’s number of months of industry experience prior to graduation. The results suggest that, independent of prior industry experience, specialized education that targets advancement in a specific career class, e.g., software engineering, leads to faster career progression than general education.
A Deep Learning Pipeline Parallel Optimization Method

In recent years, with the continuous development of artificial intelligence, deep learning algorithms are becoming more and more complex, and the scale of model training is also growing. The artificial intelligence platform also involves large-scale model training in our computing network operating system project. However, with the increasing size of data sets and models, the traditional single-card training makes the training speed very slow, and the training accuracy needs to converge, which has yet to meet people's computational needs. This has led to the development of GPipe, PipeDream, and other famous pipelines. In this paper, an efficient pipeline parallel training optimization method is proposed. In our approach, multiple computing nodes process small batches of data in parallel in a pipeline manner. We have mainly done the following two aspects of work: First, we designed a weight buffer strategy to limit the number of weight versions generated and ensure the model's accuracy. And we also developed a tensor compression mechanism to improve the transmission rate. Secondly, we propose a prefix sum partition algorithm to ensure that the pipeline can achieve balanced partitioning and save the memory of computing resources. Compared with several popular pipeline parallel frameworks, the proposed method can achieve about twice the training acceleration and save about 30% - 40% of the memory usage.
Rethinking Design Paradigm of Graph Processing System with a CXL-like Memory Semantic Fabric

With the evolution of network fabrics, message-passing clusters have been promising solutions for large-scale graph processing. Alternatively, the shared-memory model is also introduced to avoid redundant copies and extra storage space of graph data. Compared to conventional network fabrics, with the capability of fine-grained, byte-addressable remote memory access, emerging memory semantic interconnects and fabrics, e.g., Intel's Compute Express Link (CXL), are intuitively more appropriate for adoption in shared-memory clusters. However, due to the latency gap between local and remote memory, it is still challenging to take advantage of the shared-memory graph processing with memory semantic fabrics. To tackle this problem, in this paper, we first investigate memory access characterizations of graph vertex propagation based on the shared-memory model. Then we propose GraCXL, a series of design paradigms to address high-frequency and long-latency of remote memory access potentially incurred in CXL-based clusters. For system adaptiveness, we elaborate GraCXL towards the general-purpose CPU cluster and the domain-specific FPGA accelerator array, respectively. We design a custom fabric with the CXL.mem protocol and leverage a couple of ARM SoC-equipped FPGAs to build an evaluation prototype in the absence of commodity CXL hardware and platforms. Experimental results show that the proposed GraCXL CPU and FPGA clusters achieve 1.33x-8.92x and 2.48x-5.01x performance improvement, respectively.
KalpaVriksh: Efficient and Cost-effective GUI Application Hosting using Singleton Snapshots

Hosting popular GUI applications in different virtual machines (VMs) in a cloud can provide strong intra- application isolation and enhance the security of end-user devices. In this context, micro-VMs can be a very good fit where different applications are hosted in different micro-VMs hosted in the cloud. However, one of the challenges for the cloud service provider is to launch the application quickly when requested by any client. Techniques like VM snapshots can be used to improve the application launch time as shown in many existing research works. In this paper, we argue that GUI applications are different from snapshot-optimized cloud services like FaaS because the GUI applications are stateful and require specialized techniques for snapshot management. To manage application snapshots in a memory-efficient manner, the proposed KalpaVriksh framework maintains a single snapshot to launch multiple GUI applications from different end users. Furthermore, the unified snapshot framework does not impact the application launch time by using intelligent snapshot creation procedures. The experimental analysis shows that KalpaVriksh snapshot techniques apart from being memory- efficient, reach the farthest feasible point of snapshot capture (i.e., first external communication) during application execution, faster than a normal application launch (by 4.9x).
Training for Security: Planning the Use of a SAT in the Development Pipeline of Web Apps

We designed a prospective empirical investigation to study our STW (Software Technologies for the Web) course with respect to the training of bachelor students in the context of software security when developing e-commerce Web apps. To that end, we devised the following steps: (i) studying the state of the students enrolled in the STW course in the a.y. (academic year) 2021-22; (ii) defining a training plan for the a.y. 2022-23; and (iii) acting the plan and measuring the differences (if any) between the students of the a.y. 2021-22 and 2022-23. In this idea paper, we present the results of the former two steps, as well as the evaluation strategy of the proposed training plan. We observed that security concerns are widespread in the code of the Web apps the students of the STW course (a.y. 2021-22) developed. Therefore, we plan (second step) to ask the students of the STW course (a.y. 2022-23) to use in their development pipeline a Static Analysis Tool (SAT) to detect security concerns.
CXL over Ethernet: A Novel FPGA-based Memory Disaggregation Design in Data Centers

Memory resources in data centers generally suffer from low utilization and lack of dynamics. Memory disaggregation solves these problems by decoupling CPU and memory, which currently includes approaches based on RDMA or interconnection protocols such as Compute Express Link (CXL). However, the RDMA-based approach involves code refactoring and higher latency. The CXL-based approach supports native memory semantics and overcomes the shortcomings of RDMA, but is limited within rack level. In addition, memory pooling and sharing based on CXL products are currently in the process of early exploration and still take time to be available in the future. In this paper, we propose the CXL over Ethernet approach that the host processor can access the remote memory with memory semantics through Ethernet. Our approach can support native memory load/store access and extends the physical range to cross server and rack levels by taking advantage of CXL and RDMA technologies. We prototype our approach with one server and two FPGA boards with 100 Gbps network and measure the memory access latency. Furthermore, we optimize the memory access path by using data cache and congestion control algorithm in the critical path to further lower access latency. The evaluation results show that the average latency for the server to access remote memory is <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$1.97\ \mu\mathrm{s}$</tex> , which is about 37% lower than the baseline latency in the industry. The latency can be reduced to 415 ns when memory accesses hit cache on FPGA.
Open Design Case Study - A Crowdsourcing Effort to Curate Software Design Case Studies

Case study-based learning has been successfully integrated into various courses, including software engineering education. In the context of software design courses, the use of case studies often entails sharing of real successful or failed software development. Using examples of real-world case studies allows educators to reinforce the applicability and usefulness of fundamental design concepts, relate the importance of evaluating design trade-offs with respect to stakeholders’ requirements, and highlight the importance of upfront design where students that lack industrial experience tend to overlook. However, the use of real-world case studies is not straightforward because 1.) there is a lack of open source repositories for real software design case studies and 2.) even if case studies are available, they are often reported without a standardized format, which may hinder the alignment between the case and the desired learning outcomes. To address the lack of software design case studies for educational purposes, we propose the idea of Open Design Case Study, a repository to crowdsource, curate, and recruit other educators to contribute case studies for teaching software design courses. The platform will also allow educators and students to share, brainstorm, and discuss design solutions based on case studies shared publicly on the repository.
Improving Grading Outcomes in Software Engineering Projects Through Automated Contributions Summaries

Teaming is a key aspect of most professional software engineering positions, and consequently, team-based learning (TBL) features heavily in many undergraduate computer science (CS) and software engineering programs. However, while TBL offers many pedagogical benefits, it is not without challenges. One such challenge is assessment, as the course teaching staff must be able to accurately identify individual students’ contributions to both encourage and reward participation. In this paper, we study improvements to grading practises in the context of a CS1.5 introductory software engineering course, where assessing individual students’ contributions to weekly lab assignments is done manually by teaching assistants (TAs). We explore the impact of presenting TAs with automated summaries of individual student contributions to their team’s GitHub repository. To do so, we propose a novel algorithm, and implement a tool based off of it, AutoVCS. We measure the impact on grading metrics in terms of grading speed, grading consistency, and TA satisfaction. We evaluate our algorithm, as implemented in AutoVCS, in a controlled experimental study on Java-based lab assignments from a recent offering of NC State University’s CS1.5 course. We find our automated summaries help TAs grade more consistently and provides students with more actionable feedback. Although TAs grade no faster using automated summaries, they nonetheless strongly prefer grading with the support of them than without. We conclude with recommendations for future work to explore improving consistency in contribution grading for student software engineering teams.
BARA: A Dynamic State-based Serious Game for Teaching Requirements Elicitation

Teaching requirements elicitation to students who do not have practical experience is challenging, as they usually cannot understand the difficulty. Several recent studies have reported their experience of teaching requirements elicitation with a serious game. However, in these games, the fictitious characters have not been carefully designed to reflect real scenarios. For example, they always respond the same no matter how many times a learner interacts with them. Moreover, most existing serious games contain only one specific scenario and cannot be easily extended to cover various cases. In this paper, we design and implement a dynamic state-based serious game (BARA) for teaching requirements elicitation, which can realistically simulate real-world scenarios and automatically record learners’ actions for assessment. Specifically, we model fictitious characters’ behaviors using finite-state machines in order to precisely characterize the dynamic states of stakeholders. We also developed an easy-to-use editor for non-programmers to design fictitious characters and thus construct various simulated scenarios. Finally, BARA records learners’ actions during the game, based on which we can gain an in-depth understanding of learners’ performance and our teaching effectiveness. We evaluated BARA with 60 participants using a simulated scenario. The result shows that most participants are immersed in BARA and can reasonably complete the requirements elicitation task within the simulated scenario.
Optimizing Decentralized Learning with Local Heterogeneity using Topology Morphing and Clustering

Recently, local peer topology has been shown to influence the overall convergence of decentralized learning (DL) graphs in the presence of data heterogeneity. In this paper, we demonstrate the advantages of constructing a proxy-based locally heterogeneous DL topology to enhance convergence and maintain data privacy. In particular, we propose a novel peer clumping strategy to efficiently cluster peers before arranging them in a final training graph. By showing how locally heterogeneous graphs outperform locally homogeneous graphs of similar size and from the same global data distribution, we present a strong case for topological pre-processing. Moreover, we demonstrate the scalability of our approach by showing how the proposed topological pre-processing overhead remains small in large graphs while the performance gains get even more pronounced. Furthermore, we show the robustness of our approach in the presence of network partitions.
PrivFlow: Secure and Privacy Preserving Serverless Workflows on Cloud

The recent advancement of serverless computing in the widespread deployment of applications prompts the need to protect serverless workflows against cloud vulnerabilities and threats. We propose PrivFlow, a workflow-centric, privacy preserving framework to protect the information flow in serverless computing applications in semi-honest (S-PrivFlow) and malicious (M-PrivFlow) adversarial settings. An Authenticated Data Structure is used to store the valid workflows encoded in the proposed format. The validation of workflows is performed in a privacy preserving manner that leaks no sensitive information to any unauthorized user. We focus on the two most prevalent attacks on the serverless cloud platforms, namely the Denial-of-Wallet and Wrong Function Invocation attacks. We demonstrate that PrivFlow mitigates both of these attacks. Further, we evaluate PrivFlow on the popular benchmark application- Hello Retail, and a customized scaled application. Though the comparison with the state-of-the-art approaches in terms of the runtime performance shows a latency of 1.6 times for S-PrivFlow and 8 times for M-PrivFlow, the PrivFlow provides high security and privacy. PrivFlow acts as a wrapper to the application resulting in no change to the source code.
Are you cloud-certified? Preparing Computing Undergraduates for Cloud Certification with Experiential Learning

Cloud Computing skills have been increasing in demand. Many software engineers are learning these skills and taking cloud certification examinations to be job competitive. Preparing undergraduates to be cloud-certified remains challenging as cloud computing is a relatively new topic in the computing curriculum, and many of these certifications require working experience. In this paper, we report our experiences designing a course with experiential learning to prepare our computing undergraduates to take the cloud certification. We adopt a university project-based experiential learning framework to engage industry partners who provide project requirements for students to develop cloud solutions and an experiential risk learning model to design the course contents. We prepare these students to take on the Amazon Web Services Solution Architect - Associate (AWS-SAA) while doing the course. We do this over 3 semester terms and report our findings before and after our design with experiential learning. We are motivated by the students’ average 93% passing rates over the terms. Even when the certification is taken out of the graded components, we still see an encouraging 89% participation rate. The quantitative feedback shows increased ratings across the survey questions compared to before experiential learning. We acknowledge concerns about the students’ heavy workload and increased administrative efforts for the faculty members. We summarise our approach with actionable weekly topics, activities and takeaways. We hope this experience report can help other educators design cloud computing content and certifications for computing students in software engineering.
A Framework for Graph Machine Learning on Heterogeneous Architecture

Graph Machine Learning (Graph ML) has shown great success in many domains such as Electronic Design Automation (EDA) [1], traffic prediction [2], recommendation systems [3], etc. where data is represented as graphs. In real-world scenarios, these domains often involve large-scale graphs with over billions of edges [4]; training Graph ML models on these large datasets using only a single CPU or GPU would take hours or even days [5], which calls for the need for acceleration. To provide more computing power and to efficiently process different types of workloads, state-of-the-art machines feature heterogeneous architecture [6], [7] that consists of multiple CPUs and a variety of accelerators such as GPUs, FPGAs, or AI-specific accelerators [8]–[10]. Heterogeneous architectures have great potential to accelerate Graph ML; however, due to the complexity of such platforms, accelerating Graph ML remains challenging. First, it requires extensive programming to accelerate Graph ML on a heterogeneous architecture [11]. In particular, launching each accelerator requires a different program (e.g., CUDA for GPU, Verilog for FPGA); one also needs to develop a complex host program to orchestrate the task coordination among the CPUs and the accelerators. Second, in order to achieve high performance, the Graph ML kernels on each device (i.e., the CPUs or the accelerators) need to be highly optimized. In addition, training a Graph ML on multiple devices in parallel suffers from workload imbalance and high communication overhead [12]; these issues limit the speedup that can be achieved on the heterogeneous architecture. Finally, it is challenging to build a portable design that can run on various heterogeneous architectures while achieving high performance. Portability is critical for one to build an impactful design that contributes to the research community and the industry as it allows others to easily build upon his or her work. To this end, we propose a novel framework for accelerating Graph ML training on a heterogeneous architecture. The framework aims to achieve high programmability, high performance, and high portability; we introduce how these three objectives are achieved in Section III.
Overcoming Noisy Labels in Federated Learning Through Local Self-Guiding

Federated Learning (FL) is a privacy-preserving machine learning paradigm that enables clients such as Internet of Things (IoT) devices, and smartphones, to train a high-performance global model jointly. However, in real-world FL deployments, carefully human-annotated labels are expensive and time-consuming. So the presence of incorrect labels (noisy labels) in the local training data of the clients is inevitable, which will cause the performance degradation of the global model. To tackle this problem, we propose a simple but effective method Local Self-Guiding (LSG) to let clients guide themselves during training in the presence of noisy labels. Specifically, LSG keeps the model from memorizing noisy labels by enhancing the confidence of model predictions. Meanwhile, it utilizes the knowledge from local historical models which haven't fit noisy patterns to extract potential ground truth labels of samples. To keep the knowledge without storing models, LSG records the exponential moving average (EMA) of model output logits at different local training epochs as self-ensemble logits on clients' devices, which will lead to negligible computation and storage overhead. Then logit-based knowledge distillation is conducted to guide the local training. Experiments on MNIST, Fashion-MNIST, CIFAR-10, ImageNet-100 with multiple noise levels, and an unbalanced noisy dataset, Clothing1M, demonstrate the resistance of LSG to noisy labels. The code of LSG is available at https://github.com/DaokuanBai/LSG-Main