Emotions have a significant impact on an individual’s life, and positive emotions can enhance their quality of life. Moreover, emotions play a crucial role in the field of medicine. However, the complexity of human emotions has hindered their rapid development in the medical field. Therefore, it is crucial to rapidly and accurately identify human emotions. In the field of emotion recognition, radar is widely used for monitoring human physiological features due to its strong penetrability and non-contact advantages. In deep learning, the Transformer model has been introduced into radar signal processing due to its excellent global perception ability, offering new possibilities for fast and accurate detection of human emotions. In this paper, we propose a human emotion recognition system based on ultra-wideband radar, utilizing the Convolutional Vision Transformer (CvT) model as the deep learning model for emotion classification. The CvT model incorporates convolution into the Vision Transformer architecture, combining the advantages of both in image recognition tasks. Unlike previous works with convolutional networks, CvT fully leverages the benefits of convolution while retaining the characteristics of the Transformer. We pre-trained the model on a publicly available radar dataset and then conducted experimental validation using our collected dataset. The experimental results demonstrate that our network outperforms traditional convolutional approaches, achieving a test accuracy of 86.25%, which is of significant importance for radar-based emotion recognition.

Traditional vital sign monitoring devices typically involve direct contact with the skin using electrodes, making them unsuitable for daily vital sign monitoring due to the discomfort and skin damage. Remote detection technology provides an effective solution to these issues. This article introduces an efficient and robust algorithm for estimating vital signs using frequency-modulated continuous-wave (FMCW) radar. The integration of this method with emerging technologies, such as the Internet of Things (IoT), enables long-term and contactless vital sign monitoring, which facilitates a new model of self-management for chronic diseases and their prevention. While the breathing estimation accuracy is typically constrained by noise, heart rate (HR) estimation is primarily hindered by strong interference from the breathing signal and its higher-order harmonics. A maximum likelihood estimator based on the Newton’s method is derived and proposed in this article to accurately assess the breathing and heartbeat frequencies by enhancing the precision of vital sign parameter estimation. The proposed algorithm is validated utilizing a 77 GHz FMCW radar and compared with a reliable reference sensor. Experimental results from eight subjects demonstrate that the proposed method enhances the estimation accuracy, outperforming both conventional spectral estimation and other methods. Specifically, the root mean-square error between the reference sensor measurements and the estimations is lower than 1 beats per minute (bpm) for breathing rates and 1.5 bpm for HRs. Additionally, the Bland-Altman plots demonstrate a high level of agreement between these estimations and the reference measurements.

The landscape of transformer model inference is increasingly diverse in model size, model characteristics, latency and throughput requirements, hardware requirements, etc. With such diversity, designing a versatile inference system is challenging. DeepSpeed-Inference addresses these challenges by (1) a multi-GPU inference solution to minimize latency while maximizing throughput for both dense and sparse transformers when the model fits in aggregate GPU memory, and (2) a heterogeneous inference solution that leverages CPU/NVMe/GPU memory to enable high-throughput inference for models larger than aggregate GPU memory. DeepSpeed-Inference reduces latency by 6.4× and increases throughput by 1.5 ×over the state-of-the-art. It enables trillion parameter scale inference under real-time latency constraints by leveraging hundreds of GPUs, an unprecedented scale for inference. It can inference 25 ×larger models than with GPU-only solutions, while delivering a high throughput of 84 TFLOPS (over 50% of A6000 peak).

Order of shared memory accesses, known as the shared memory dependence, is the cornerstone of dynamic analyses of concurrent programs. In this paper, we study the problem of reducing shared memory dependences. We present the first online software-only algorithm to reduce shared memory dependences without vector clock maintenance, opening a new direction to a broad range of applications (e.g., deterministic replay and data race detection). Our algorithm exploits a simple yet effective observation, that adaptive variable grouping can recognize and match spatial locality in shared memory accesses, to reduce shared memory dependences. We designed and implemented the bisectional coordination protocol, which dynamically maintains a partition of the program's address space without its prior knowledge, such that shared variables in each partitioned interval have consistent thread and spatial locality properties. Evaluation on a set of real-world programs showed that by paying a 0--54.7% (median 21%) slowdown, bisectional coordination reduced 0.95--97% (median 55%) and 16--99.99% (median 99%) shared memory dependences compared with RWTrace and LEAP, respectively.

Recent studies have found that parallel garbage collection performs worse with more CPUs and more collector threads. As part of this work, we further investigate this enomenon and find that poor scalability is worst in highly scalable Java applications. Our investigation to find the causes clearly reveals that efficient multi-threading in an application can prolong the average object lifespan, which results in less effective garbage collection. We also find that prolonging lifespan is the direct result of Linux's Completely Fair Scheduler due to its round-robin like behavior that can increase the heap contention between the application threads. Instead, if we use pseudo first-in-first-out to schedule application threads in large multicore systems, the garbage collection scalability is significantly improved while the time spent in garbage collection is reduced by as much as 21%. The average execution time of the 24 Java applications used in our study is also reduced by 11%. Based on this observation, we propose two approaches to optimally select scheduling policies based on application scalability profile. Our first approach uses the profile information from one execution to tune the subsequent executions. Our second approach dynamically collects profile information and performs policy selection during execution.

Modern Java applications employ multithreading to improve performance by harnessing execution parallelism available in today’s multicore processors. However, as the numbers of threads and processing cores are scaled up, many applications do not achieve the desired level of performance improvement. In this paper, we explore two factors, lock contention and garbage collection performance that can affect scalability of Java applications. Our initial result reveals two new observations. First, applications that are highly scalable may experience more instances of lock contention than those experienced by applications that are less scalable. Second, efficient multithreading can make garbage collection less effective, and therefore, negatively impacting garbage collection performance.

Inter-thread shared memory dependences are crucial to understanding the behavior of concurrent systems, as such dependences are the cornerstone of time-travel debugging and further predictive trace analyses. To enable effective and efficient shared memory dependence tracing, we present an optimistic scheme addressing the challenge of capturing exact dependences between unsynchronized events to reduce the probe effect of program instrumentation. Specifically, our approach achieved a wait-free fast path for thread-local reads on x86-TSO relaxed memory systems, and simultaneously achieved precise tracing of exact read-after-write, write-after-write and write-after-read dependences on the fly. We implemented an open-source RWTrace tool, and evaluation results show that our approach not only achieves efficient shared memory dependence tracing, but also scales well on a multi-core computer system.

Small talk is an important social lubricant that helps people, especially strangers, initiate conversations and make friends with each other in physical proximity. However, due to difficulties in quickly identifying significant topics of common interest, real-world small talk tends to be superficial. The mass popularity of mobile phones can help improve the effectiveness of small talk. In this paper, we present E-SmallTalker, a distributed mobile communications system that facilitates social networking in physical proximity. It automatically discovers and suggests topics such as common interests for more significant conversations. We build on Bluetooth Service Discovery Protocol (SDP) to exchange potential topics by customizing service attributes to publish non-service-related information without establishing a connection. We propose a novel iterative Bloom filter protocol that encodes topics to fit in SDP attributes and achieves a low false-positive rate. We have implemented the system in Java ME for ease of deployment. Our experiments on real-world phones show that it is efficient enough at the system level to facilitate social interactions among strangers in physical proximity. To the best of our knowledge, E-SmallTalker is the first distributed mobile system to achieve the same purpose.

For new social service providers (freshmen), it is critical to determine where to deploy the computational resources to best accommodate future client requests. Existing proposals on server placement rely on collecting and analyzing request history from servers that are already running, which are not so useful to those starting new online social network services (OSNs). In this work, we aim at helping new OSN providers with intelligent server placement by exploring available public information from existing social network communities. We explore the commonality between the selected set of server locations from multiple OSNs and utilize such similarity for future OSNs to select their server locations. The similarity is ultimately due to the fact that the underlying human relationship is relatively consistent across OSNs.

Current Web 2.0 services are making mass collaboration a reality. Using a Web browser, people can participate in cooperative work anytime, anywhere from any computing device as long as there is an Internet connection. Lying in the heart of some well-known services is an optimistic consistency control technique called operational transformation (OT). This paper proposes TIPS, a novel sync protocol that adapts OT for Web 2.0 applications. Based on a recent theoretical framework called ABT, it ensures not only convergence but also the right object order for linear documents. Designed to address the HTTP style of communication, TIPS allows clients to sync with the server by independent time intervals and dynamically join and leave at any time. When processing do operations, its time complexity is linear in the total number of operations generated by all clients during one server interval and independent of the size of history. TIPS is efficient for supporting a spectrum of (near-)realtime to asynchronous collaboration editing tasks.

This paper presents a collaboration transparency system that allows for distributed sharing of legacy collocated video games in real time without modifying the original games. Our system has attracted two million registered players since it was launched in late 2008. As the system went beyond a research prototype and reached a large number of real users, we observed performance issues that were mainly caused by unpredicted networking latencies over the public Internet and opportunistic distinction of roles such as active players and passive observers. To address these issues, we propose a novel hybrid consistency control approach that combines the merits of optimistic methods, which help achieve interactivity, and pessimistic methods, which guarantee consistency. As a result, the system can tolerate network round-trip time up to 230 ms, improving the latest work by 43.7%. In addition, the system can support over 1,000 simultaneous observers when a video game is played over the Internet.

Trip detection is a fundamental issue in many context-sensitive information services on mobile devices. It aims to automatically recognize significant places and trips between them. The key challenge is how to minimize energy consumption while maintaining high accuracy. Previous works that use GPS/WiFi sampling are accurate but energy efficiency is low and does not improve over time. Learning from the human decision making process, we propose an energy-efficient trip detection framework that consists of two modes: The deliberation mode learns cell-id patterns using GPS/WiFi based localization methods; the intuition mode only uses cell-ids and learned patterns for trip detection; transition between the two modes is controlled by parameters that are also learned. We evaluated our framework using real-life traces of six people over five months. Our experiments demonstrate that its energy consumption decreases rapidly as users' activities manifest regularity over time.

Data races are subtle and difficult to detect errors that arise during concurrent program execution. Traditional testing techniques fail to find these errors, but recent research has shown that targeted dynamic analysis techniques can be developed to precisely detect races (i.e., no false race reports are generated) that occur during program execution. Unfortunately, precise race detection is still too expensive to be used in practice. State-of-the-art techniques still slow down program execution by a factor of eight or more. In this paper, we incorporate an optimization technique based on the observation that many thread-shared objects are written early in their lifetimes and then become read-only for the remainder of their lifetimes; these are known as stationary objects. The main contribution of our work is the insight that once a stationary object becomes thread-shared, races cannot occur. Therefore, our proposed approach does not monitor access to these objects. As such, our system only incurs an average overhead of 45% of that of an implementation of FastTrack, a low-overhead dynamic race detector. We then compared the effectiveness of our approach to de- tect races in deployed environments with that of Pacer, a sampling based race detector based on FastTrack. We found that our approach can detect over five times more races than Pacer when we budget 50% for runtime overhead.

Operational transformation (OT) is a promising technique for supporting collaboration using mobile devices because it allows users to work on local data replicas even in a disconnected mode. However, as work goes mobile, a large number of operations may accumulate, defying the capacity of current OT algorithms that are mostly designed for real-time group editing. Since their assumption is that operations are propagated frequently, they generally only address how to integrate one remote operation at a time. As a consequence, most algorithms take O(|H|2) to integrate one operation and thus O(|H|3) to integrate a long sequence, where H is the operation history. This paper proposes a novel algorithm that provides optimized transformation of long sequences, improving the time complexity to O(|H|). Our experiments will show that it takes 59 minutes in a recent algorithm versus 1.5 seconds in this work to integrate two long sequences on a mobile device. The performance improvement is critical towards achieving desired responsiveness and group productivity in a class of mobile collaborative applications.

Selective undo allows users to undo any operation in the history and is considered a key feature in collaborative applications. Operational transformation (OT) is a powerful tool for implementing selective undo because it can be used to rearrange operations in a history in arbitrary orders. Despite the significant progress over the past two decades, however, there is still a space for improvements. Most existing works take time quadratic or even exponential in the size of the operation history H to undo an operation. Although this might be acceptable for real-time collaboration, it would be suboptimal in mobile and asynchronous collaborative applications in which a long history may accumulate. In addition, it is important to prove an algorithm with regard to the correctness criteria it assumes. This paper proposes a novel OT-based algorithm that provides integrated do and selective undo. The algorithm achieves time complexity of O(|H|) in both do and undo by keeping the history in a special operation effects relation order. Its correctness is formally proved with regard to formalized, provable conditions that are extended from a recent theoretical framework.

Small talk is an important social lubricant that helps people, especially strangers, initiate conversations and make friends with each other in physical proximity. However, due to difficulties in quickly identifying significant topics of common interest, real-world small talk tends to be superficial. The mass popularity of mobile phones can help improve the effectiveness of small talk. In this paper, we present E-SmallTalker, a distributed mobile communications system that facilitates social networking in physical proximity. It automatically discovers and suggests topics such as common interests for more significant conversations. We build on Bluetooth Service Discovery Protocol (SDP) to exchange potential topics by customizing service attributes to publish non-service-related information without establishing a connection. We propose a novel iterative Bloom filter (IBF) protocol that encodes topics to fit in SDP attributes and achieves a low false positive rate. We have implemented the system in Java ME for ease of deployment. Our experiments on real-world phones show that it is efficient enough at the system level to facilitate social interactions among strangers in physical proximity. To the best of our knowledge, E-SmallTalker is the first distributed mobile system to achieve the same purpose.

In a mobile collaboration environment, the shared files are often replicated so that the users can work in parallel during periods of disconnection. When reconnected, sequences of updates made by different users are merged to produce a consistent view of shared files. This paper presents a novel transformation-based merging algorithm for supporting mobile collaboration. Compared to alternative optimistic consistency control methods, it can merge any updates to the same file automatically at the finest granularity without causing loss of work. Moreover, it improves the time complexity of the state-of-the-art transformation-based merging algorithms from O(n3) to O(n), where n is the size of either sequence when their sizes are comparable. This improvement is drastic and important especially for mobile devices that run on batteries and have limited processing power.

Operational transformation (OT) is an established optimistic consistency control method in collaborative applications. Most existing OT algorithms are developed under a well-accepted framework with a condition that cannot be formally proved. In addition, they generally support two character-based pr

Interactive TV/arcade games have been entertaining people for over 50 years. Nowadays a large number of legacy TV/arcade games have been ported to new platforms such as PCs by emulation. However, they generally require that the players be co-located to interact with one computer that emulates the game. This paper proposes a novel approach to turning those single-computer games into multi-computer games such that multiple players can play their favorite legacy games in real time over a computer network. The main challenge in this work is how to synchronize multiple replicas of a game without semantic knowledge about or modifications to the game. We have developed a novel synchronization algorithm and a working system to validate the ideas. In this paper we present the approach, especially the synchronization algorithm, and evaluate its effectiveness under a variety of network conditions. In future research we will extend this work on mobile devices.

Operational transformation (OT) is an optimistic consistency control method for supporting collaboration over high-latency networks. The technique lies in the heart of many recent products such as Google Wave. It replicates the shared data and allows the users to concurrently modify any part of a shared document in a nonblocking manner. Most of the published results only support two characterwise primitives and take O(|H|2) or even longer time to integrate one remote characterwise operation, where H is the operation history. However, as the history grows long and operations are integrated in batches, the high complexity can make an algorithm easily exceed the 100 ms responsiveness threshold that is critical for interactive applications. This paper proposes a new OT algorithm that supports string primitives and reduces the time complexity to O(|H|). The result can be used in a range of parallel and distributed applications that can be abstracted as realtime group editors.

The Web has become the host platform for interactive and collaborative applications that usually consist of multiple Web services. This transition is pushing the browsers to perform operating system like functionalities for better resource utilization. Unfortunately, there exists limited support for resource management on current Web platforms. This problem is further aggravated on mobile devices because of their limited resources. If current Web communication APIs were used as-is, mobile users would suffer from low responsiveness, battery drainage, and expensive charges.

Group editors allow a distributed group of users to collaboratively edit shared documents such as source code and web pages. As a well-accepted consistency control method in group editors, operational transformation (OT) is intuitively believed to be able to preserve operation intentions. However, intention preservation as a consistency constraint has not been rigorously formalized, making it difficult to design OT algorithms and prove their correctness. This work proposes a formalization of intention preservation and analyzes several OT-based approaches to achieving it.

Group editors allow a group of distributed human users to edit a shared multimedia document at the same time over a computer network. Consistency control in this environment must not only guarantee convergence of replicated data, but also attempt to preserve intentions of operations. Operational transformation (OT) is a well-established method for optimistic consistency control in this context and has drawn continuing research attention since 1989. However, counterexamples to previous works have often been identified despite the significant progress made on this topic over the past 15 years. This paper analyzes the root of correctness problems in OT and establishes a novel operational transformation framework for developing OT algorithms and proving their correctness.

Special-purpose group editors remain underused despite significant work over the past two decades.This paper proposes a novel approach to transparently adapting familiar single-user editors for group editing without modifying their source code. It only needs to adapt single-user editors to support two simple interfaces that get and set their states; edit scripts are derived between document states by diffing and concurrent scripts are merged on the fly. The approach is significantly less expensive than recent alternatives because it no longer needs to translate editing operations at the windows event level. The users are free to use any editing commands and even heterogeneous single-user editors can be used in the same group editing task. This work is part of a project called intelligent collaboration transparency (ICT).

Commutativity of operations is often exploited in concurrent systems to attain high levels of concurrency. A commutativity-based concurrency control method, called operational transformation (OT), has been actively researched in groupware over the past 15 years. However, much progress can still be made on more practicable approaches to developing and proving OT algorithms. Several constraints have been proposed previously but they are generally difficult to follow and verify in practice. This paper proposes an alternative approach to address this problem. A new consistency model is defined which greatly simplifies the design and proof of OT algorithms.

Operational transformation (OT) is a responsive and nonblocking concurrency control method widely-accepted in group editors. Correctness and performance are the basis of usefulness and usability of OT-based group editors. However, the correctness of previous OT algorithms depends on conditions that are very difficult to verify. In this paper we propose a novel landmark-based transformation (LBT) approach, its correctness no longer depending on those conditions and thus easy to prove. In addition, we give an example algorithm that significantly outperforms a state-of-the-art OT algorithm. This work reveals a more practical approach to developing OT algorithms.

Consistency maintenance is a critical and challenging issue in many interactive groupware applications that can be modeled as group editors. This paper addresses two open consistency problems: divergence and operation effects relation violation. While the former has been partly solved, the latter has never been addressed in any published work. We propose a novel approach to solving both problems in the same framework. Particularly it preserves the effects relation of concurrent operations so that convergence is achieved automatically. Our work provides a new perspective into group editors and operational transformation algorithms.

Consistency control is critical for the correct functioning of distributed collaboration support systems. A large number of consistency control methods have appeared in the literature with different design tradeoffs and usability implications. However, there has been relatively little work on how to accommodate different protocols and variations in one framework to address the dynamic needs of collaboration. In this paper, we propose a novel approach for supporting adaptable consistency protocols in collaborative systems. Our approach cleanly separates data and control, allowing consistency protocols to be dynamically attached to shared data at the object level. Protocols can be switched at run time without modifying source code.

Real-time group editors allow distributed users to work on local replicas of a shared document simultaneously to achieve high responsiveness and free interaction. Operational transformation (OT) is the standard method for consistency maintenance in state-of-the-art group editors. It is potentially able to achieve content consistency (convergence) as well as intention consistency (so that the converged content is what the users intend), while traditional concurrency control methods such as locking and serialization often cannot. However, existing OT algorithms are often not able to really guarantee consistency due to important algorithmic flaws that have been there for fourteen years. We present a novel state difference based transformation (SDT) algorithm to solve the problem. Our result also reveals that the standard priority schemes to break ties in distributed systems should be used with more caution.

Multi-user applications generally lag behind in features or compatibility with single-user applications. As a result, users are often not motivated to abandon their favorite single-user applications for groupware features that are less frequently used. A well-accepted approach, collaboration transparency, is able to convert off-the-shelf single-user applications into groupware without modifying the source code. However, existing systems have been largely striving to develop generic application-sharing mechanisms and undesirably force users to share the same application in cooperative work. In this paper we analyze this problem and present a novel approach (called intelligent collaboration transparency) to addressing this problem. Our approach allows for heterogeneous application sharing by considering the particular semantics of the applications and the collaboration task in question.

As a promising approach to end-user computing, programming by demonstration (PBD) techniques have been explored by many researchers in single-user applications. This paper investigates how PBD techniques can be used to support end-user customization of groupware tools. In collaborative applications, complex semantic relationships can emerge unanticipatedly among objects (participants, data artifacts, tools, devices, etc.) such as the hierarchical organization of participants, consistency maintenance among different views of the same data, and awareness control. It is important that end users are empowered to customize the groupware application to model and enforce such relationships. We present an active rule based approach to modeling user-defined semantic relationships in collaborative applications and explore a demonstrational approach for end-user customization of collaboration tools to support the definition of those relationships. The presented work is based on our work on a shared whiteboard tool, CAB or Collaborative Active whiteBoard. Our approach is being generalized to support end user defined object relationships in shared workspaces.

Providing information about other users and their activites is a central function of many collaborative applications. The data that provide this "presence awareness" are usually automatically generated and highly dynamic. For example, services such as AOL Instant Messenger allow users to observe the status of one another and to initiate and participate in chat sessions. As such services become more powerful, privacy and security issues regarding access to sensitive user data become critical. Two key software engineering challenges arise in this context:

The concept of time and the ordering of events are correlated key issues in distributed computing as well as in computer-supported collaborative work (CSCW) systems. The paper revisits some of the assumptions that have generally been made regarding time and event ordering in distributed systems and argues that they are no longer appropriate if the goal is to faithfully preserve user intentions in CSCW systems. In particular, the following contributions are made in the context of collaborative editing systems. First, we discuss how the user intentions might be impacted when the finite duration of drawing operations are considered. Secondly, we propose that the total ordering of events should give the users the right of participation instead of being solely determined mechanically by the system. Thirdly, a new concept of an active whiteboard is proposed which supports various integrity constraints on objects and object groups to maintain user intentions in a more sophisticated way. Additionally, for the sake of completeness, the problem of maintaining consistency in the face of unreliable and high-latency communication channels is also covered.

The importance of supporting flexible roles and dynamic policies has long been recognized in the CSCW (Computer-Supported Cooperative Work) literature but unfortunately never with a systematic solution. This paper proposes a taxonomy of runtime dynamics in collaborative systems in general and discusses our solution in the COCA framework. Firstly, individual participants can take roles, drop roles, and switch between roles as a collaboration runs, Secondly, a role can be transferred from one participant to another at runtime. Thirdly, session-wide, authorized participants can change the definition of roles and coordination policies on the fly while keeping the mapping between roles and participants. When such changes happen on the fly, the runtime environment of the sites which are potentially affected, including the state information within the computation modules and the communication channels, must be handled properly according to the semantics of the collaboration itself.

Coordination poticies vary from collaboration to collaboration and are even subject to evolution in different phases of the same co~aboration.It is titi for co~aborative systems to be flexible enough to accommodate changes to the coordination poficies during development and the Kietime of the coHaboration.Motivated by previous work of separating coordination and computation, we propose COCA as a generic &amew'ork for developing co~aborative systems and modeling the coordination poficies.Participants expficidy adopt roles, and coordination poficies are sptid in terms of roIes in a logic-based specification language.Po5cies me interpret at runtime at each collaboration site by a COCA virturd machine.It is easy to change the coordination policies both during development and at runtime.KeSvor&