In this project, we address 4 issues with existing Mission-Critical Push-to-talk (MCPTT) systems:

• The messages cannot be stored or re-played. When the receiver could not hear it clearly, he/she has to ask the sender to repeat. This wastes not only the channel resource but also the precious time of the first responders.
• When a first responder needs to focus on some work and come back to the communication later, he/she cannot pause the messages and play them when he/she is ready to hear.
• It is difficult to serialize speech, especially on the connection with long delay, e.g., satellite. The first responders would end up wasting a lot of time waiting for the floor or just overtalk each other.
• Existing solutions lack support for intermittently-connected and infrastructure-less environments.

To address these issues, we consolidate the existing Mission Critical Open Platform (MCOP) with our enhancements:

• Our application stores messages received from the platform and play them when the user wants. This includes message replay.
• We allow users to push and talk whenever they want to. The application will monitor the availability of the channel and send the messages when it can acquire the floor.
• We take advantage of cloud-based speech-to-text and text-to-speech capabilities to accelerate communication.
• We added store-and-forward and device-to-device (D2D) communication capabilities to support for different scenarios, including 1) all the users are connected, 2) users have intermittent connectivity, 3) only some of the users in an area has connectivity, and 4) none of the users in an area has connectivity but they need to communicate among them. Our application allows smooth transition among all these scenarios.
• We also made other improvements like SMS (text messaging) capability, dynamic group management with geo-location support, upgrade/downgrade calls & call prioritization, log in using biometric information, etc.

Our project was awarded overall #1 and best in class (Contest 2) in the in-person contest at the New York competition in Nov. 2019. We then received the "Superior" award in the nationwide contest. NIST PSCR awarded us a seed round award at the same time as the nationwide online contest in May 2020. We were subsequently selected as the best project in the progress round in Nov. 2020, based on the improvements to our application in the last phase.

Please visit our project website for more information.

Effective communication among first responders during and in the aftermath of a disaster can affect outcomes dramatically. The challenges usually include:

• Damage to infrastructure — civilian and/or specialized communication facilities may be damaged by the disaster
• Congested channels — because affected people report something about the disaster, and these messages may be broadcast
• Dynamically formed groups — first responder teams may be formed dynamically in response to a disaster and team member addresses (e.g., phone numbers) may not be known to one another, and thus causing:
  • Impediments to communication — because the new command chain to manage the disaster may be different from the original organizational hierarchy,
  • Poor interoperability — each sub-team might use different communication facilities,
• High computation requirements — first responders need computation intensive tasks like face recognition, object detection, speech-to-text, text-to-speech, etc.
• Security attacks — disaster situations are often vulnerable to attacks, requiring authentication and authorization as well as establishing data integrity and provenance

ReDiCom seeks to build a resilient architecture that allows efficient communications among dynamically formed groups of first responder teams even when there is damage to infrastructure. The architecture includes the following components:

• A dynamic naming schema allowing the first responders to address each other via roles instead of the identities of units instantiating the roles. To support efficient and secure communication over the naming schema, we proposed:
  • A protocol supporting effiient pub/sub over graph-based namespace. We realized that supporting the graph logic directly in the network layer incurs too much overhead. To address this issue, we introduced an information layer that resides only on some nodes in the network to deal with the rich semantics, while the other nodes perform flat name lookups for efficient forwarding.
  • A namespace synchronization protocol that helps deliver namespace updates efficiently even in the disconnected environments.
  • A semi-automated natural-language processing (NLP) solution that maps text to corresponding names so that the first responders can send messages to correct receivers even without knowing the namespace. The solution minimizes the learning effort while keeps high accuracy of the name mapping.
  • A security solution using attribute-based encryption (ABE) to ensure the confidentiality and digital signature (with chain of trust) for authenticity. The security minimizes the control overhead on namespace updates to support the use in disconnected environments.
• An efficient binary-state distance-vector routing mechanism that combines traditional routing and delay-tolerant networking (DTN) for data dissemination in fragmented networks.
• A coded communication algorithm that allows the receivers to recover data for each other when the channel is unreliable. The algorithm minimizes the total amount of retransmissions to improve the throughput of the channel.
• An efficient and secured coded computation mechanism allowing the first responders to distribute computation-intensive tasks to helpers (including civilians) in a disconnected environment where cloud is not available. The solution uses coding to address the issues of stragglers (slow helpers) and eavesdroppers (helpers that try to infer data from the work).

This is a project in collaboration with Prof. K. K. Ramakrishnan from University of California, Riverside, Prof. Murat Yuksel from University of Central Florida, and Prof. Hulya Seferoglu from University of Illinois, Chicago. We received a $1.2M grant from the National Institute of Standards and Technology (NIST) under the Public Safety Innovation Accelerator Program (PSIAP) for "Modeling and Development of Resilient Communication".

Please visit our project website for more information.

The original MobilityFirst already has an implementation over Click. Yet, that implementation focuses mostly on the functionality rather than the architectural design since the functions are added piece-by-piece in the progress of the MF project. When we revisit the implementation at the end of the project, other than the bugs we discovered when working on different applications and in different scenarios, we also found some issues in the architectural design, including:

• No clear boundaries between functions like encapsulation/decapsulation, segmentation/aggregation and routing. This makes it difficult for new developers to replace a piece of function (e.g., use a new centralized routing like SDN).
• There are many data structures (e.g., chunk table) that are shared between functions/threads. This requires locking on these data structures and causing wait when we try to make the implementation multi-threaded.
• Lack of parallelism, the design puts all the incoming packets from different ports into a single incoming queue before processing, causing the implementation difficult to take advantage of multi-core processors that are widely used in servers and software routers nowadays.
• The seprated hoststack implementation repeats many functions already implemented in the click router. The reduced functions also limit the desired capabilities like multi-homing.
• The GNRS implementation uses a separate (UDP) channel instead of MobilityFirst.
• The implementation is written directly in Click source code, making it difficult to deploy and update.
• Other function requirements like more reliable hop-by-hop transport, a type field needed in GNRS to support services like multicast, etc.

In this project, we redesign the architecture of the MF implementation, enabling better performance and extensibility for future use.

• Firstly, MF2020 is implemented as a Click module library that can be compiled and loaded separately. Making it easy to deploy.
• Then, we look at the different functions in the system and defined several components that has low coupling with each other. They include:
  • Encapsulator & Decapsulator that removes/adds lower-layer headers for incoming/outgoing packets.
  • Topology Manager that discards packets that should not be received by the router, based on a virtual topology. This is particularly useful for experiments that are executed in a testbed where broadcast messages are sent to every device (e.g., ORBIT).
  • Hop-by-hop Transport aggregating incoming packets and form chunks for other components (e.g., routing) to process, and segmenting outgoing chunks into packets for forwarding. It supports both the reliable and unreliable chunk deliveries.
  • Routing & Replication that determines the next-hop NA(s) for each chunk based on its destination GUID.
  • GNRS & GNRS Cache that map GUIDs to destination NAs. With the new design, GNRS will use MF channel naturally.
  • In-network Storage for delay-tolerant network and in-network caches.
  • Application Interface that interacts with the residing applications. This design avoids creating yet another hoststack, and allows the end hosts (with applications) also take advantage of the advanced MF routing services. At the same time, the applications can also be the virtual network functions (VNFs) on the MF routers, allowing MF to support NFV naturally.
  This design defines the functions and interfaces of each component, and provides a basic implementation. Future developers can choose to replace any component as needed without modifying the other components, as long as they follow the interface requirements.
• To avoid potential miss-behave between components, we eliminate all the data structures shared between components. The components can only communicate via packets or handler calls. This avoids the potential misuse of data structures (or locks) from different components (written by different developers), especially in a multi-threaded implementation.
• Yet, we allow elements in a component to share data even when they might be executed in different threads. The developer of the component should take care of the thread-safety of the shared data structures. We recommend that read-copy-update (RCU) strategy can be adopted on the shared data structures especially between the control plane (writer) and the data plane (reader).

The rapid growth in IoT deployment has posed unprecedented challenges to the underlying network design. We envision tomorrow's global-scale IoT systems should support global device reach-ability, mobility, diverse communication patterns, and resource efficiency. Existing solutions either rely on IP protocols that do not have efficient mobility support, or seek application-layer optimizations that incur high computing and deployment overhead.

To fill this void, we propose to adopt clean-slate network architecture in the core network that decouples locators from network addresses, and towards this end, we propose MF-IoT, which is centered around the MobilityFirst architecture that focuses on mobility handling. MF-IoT enables efficient communication between devices from different local domains, as well as communication between devices and the infrastructure network. The MF-IoT network layer smoothly handles mobility during communication without interrupting the applications. This is achieved through a transparent translation mechanism at the gateway node that bridges an IoT domain and the core network. In the core network, we leverage MobilityFirst functionalities in providing efficient mobility support for billions of mobile devices through long, persistent IDs, while in the local IoT domain, we use short, local IDs for energy efficiency. By seamlessly translating between the two types of IDs, the gateway organically stitches these two parts of the network.

To prove the feasibility of the design, we implemented MF-IoT in RIOT and deployed it on a representative IoT test board (Atmel SAM R21 Xplained Pro). Our demo "Motion-Triggered Surveillance Camera using MF-IoT" received best demo award in ACM/IEEE IoTDI'17.

Through large scale simulation studies, we show that MF-IoT is able to achieve the four features we envisioned for an IoT system, with performance optimizations in reducing network traffic load, avoiding congestion, and ensuring fast and timely packet delivery.

Content retrieval has become the dominant usage of the Internet. To optimize the user experience (in terms of response latency), server load (including DDoS attack prevention), and ISP cost (in terms of inter-domain traffic), third-party Content-Delivery Networks (CDNs) have been deployed in the network, which can be seen as large caches that are placed closer to data consumers. It has been shown that content popularity usually follows a Zipf distribution, and therefore, it is feasible for CDNs to store only a small portion of the content files (compared to all the content files in the network) but achieve a decent cache hit ratio. For example, CDN services provided by AT&T, Akamai, etc., are widely used by the content pro-viders like Facebook YouTube, etc. Some content providers (e.g., Netflix) even build their own CDN ser-vices to further reduce the cost of content (video) delivery.

Satellite CDN (S-CDN) leverages satellite multicast for distribution of contents to edge-network caches. The benefits of the solution include:

• Potential for significant reduction in wired Internet traffic (and hence operator cost) generated by video streaming services;
• Capable for distributing delay-tolerant, high bandwidth content across a wide geographic area simultaneously; and
• Caching of content at the edge also improves user Quality-of-Experience (QoE) due to lower access latency and consistent bandwidth.

Studies has confirmed that the cost and performance gains of S-CDN compared to terrestrial unicast solutions in terms of network traffic and scalability. S-CDN has potential as a product aimed at CATV and cellular operators seeking to reduce Internet backhaul costs. It is also an enabler for services like Video-on-Demand (VoD) in the areas with weak or no backhaul support.

MobilityFirst is a clean-slate future Internet architecture having information-centricity in the basic design. It grants each piece of content a routable Globally Unique Identifier (GUID). On receiving a query (with a GUID) from the consumer, the MF network would forward it towards the best source (content originator, providers and caches) based on the latency, throughput and policy. The solution has the potential to improve the performance of an application-layer CDN overlay design, especially when the satellite is taken into consideration. The useful functionalities supported in MF includes: in-network cache, native anycast, efficient multicast, late-binding (for user mobility), and data integrity.

With the popularity of Massively Multiplayer Online Games (MMOGs) and Virtual Reality (VR) technologies, VR-MMOGs are developing quickly, demanding ever faster gaming interactions and image rendering. In this project, we identify three main challenges of VR-MMOGs:

• a stringent latency requirement for frequent local view change responses,
• a high bandwidth requirement for constant refreshing, and
• a large scale requirement for a large number of simultaneous players.

Understanding that a cloud-centric gaming architecture may struggle to deliver the latency/bandwidth requirements, the game development community is attempting to leverage edge cloud computing. However, one problem remains unsolved: how to distribute the work among the user device, the edge clouds, and the center cloud to meet all three requirements especially when users are mobile.

In this project, we design and implement a hybrid gaming architecture that achieves clever work distribution. It places local view change updates on edge clouds for immediate responses, frame rendering on edge clouds for high bandwidth, and global game state updates on the center cloud for user scalability.

In addition, we design an efficient service placement algorithm based on a Markov Decision Process (MDP). This algorithm dynamically places a user's gaming service on edge clouds while the user moves through different access points. It also co-places multiple users to facilitate game world sharing and reduce the overall migration overhead. We derive optimal solutions and devise efficient heuristic approaches. We also study different algorithm implementations to speed up the runtime. Through detailed simulation studies, we validate our placement algorithms and also show that our architecture has the potential to meet all three requirements of VR-MMOGs.

Networks are becoming increasingly complex and service providers incorporate additional functionality in the network to protect, manage and improve service performance. Software Defined Networking (SDN) seeks to manage the network with the help of a (logically) centralized control plane. We observe that current SDN solutions pre-translate policy (what) into forwarding rules at specific switches (where). We argue that this choice limits the dynamicity, flexibility and reliability that a software based network could provide.

Information Centric Networking (ICN) shifts the focus of networks away from being predominantly location oriented communication environments. We believe ICN can significantly improve the flexibility for network management.

In this project, we focus on one of the problems of network management — service chaining — the steering of flows through the different network functions needed, before it is delivered to the destination. We propose Function-Centric Service Chaining (FCSC), a novel approach that decouples the functions a flow needs from the location of network function instances (and thus routing) via a naming layer. Such a decoupling facilitates the dynamic modification of the functions needed by a flow on the controller or the middleboxes (e.g., DPI, load balancer). This also enables switches to dynamically detect the load (popularity) of a certain function and accordingly instantiate/dispose of network function instances (co-resident with the switch or on some other node). The enroute function-based routing allows more dynamic use of the newly created instances and faster recovery from node/link failures. FCSC intrinsically supports the presence of multiple instances for the same functionality and can perform network-layer load-balancing among these nodes at any time. By placing the flow state in the packet header, FCSC helps to reduce the amount of state stored in the network and results in much better scalability compared to the per-flow state solutions like SDN. FCSC is therefore able to provide a highly dynamic and adaptive Service Chaining capability and effectively exploit the promise of NFV in the software-based network of the future.

We use a real-world topology to compare the performance of FCSC and a more "traditional" SDN solution. We show that FCSC reacts to failures with fewer packet drops, adapts to new middleboxes more quickly, and maintains less state in the network.

Information Centric Networking (ICN) is a new paradigm where the network provides users with named content, instead of communication channels between hosts. Research on ICN is at an early stage, with many key issues still open, including naming, routing, resource control, security, privacy and a migration path from the current Internet. Also missing for efficient information dissemination is seamless support of content-based publish/subscribe. Further, and importantly, current proposals do not sufficiently address energy efficiency. GreenICN aims to bridge this gap, addressing how the ICN network and devices can operate in a highly scalable and energy-efficient way.

The project exploits the designed infrastructure to support two exemplary application scenarios:

1. The aftermath of a disaster e.g. hurricane or tsunami, when energy and communication resources are at a premium and it is critical to efficiently distribute disaster notification and critical rescue information. Key to this is the ability to exploit fragmented networks with only intermittent connectivity;
2. Scalable, efficient pub/sub video delivery, a key requirement in both normal and disaster situations.

GreenICN also exposes a functionality-rich API to spur the creation of new applications and services to drive EU and Japanese industry and consumers into ICN adoption. Our team comprising researchers with diverse expertise, system and network equipment manufacturers, device vendors, a startup, and mobile telecommunications operators, is very well positioned to design, prototype and deploy GreenICN technology, and validate usability and performance of real-world GreenICN applications, contributing to create a new, low-energy, Information-Centric Internet. Our expertise and experience in standardization enables us to make major contributions to standards bodies. Our efforts foster continued close cooperation between both industrial and research communities of Europe and Japan.

This project includes 6 EU partners (University of Göttingen, NEC Europe, CEDEO, Telekomunikacja Polska, University College London, and CNIT) and 6 Japan partners (KDDI, NEC Japan, Panasonic, University of TOkyo, Waseda University, and Osaka University). The EU teams received a €3M grant from EU-Japan FP7 ICTs program for GreenICN.

Please visit our project website for more information.

Content-Centric Networks (CCN) provide substantial flexibility for users to obtain information without regard to the source of the information or its current location. Publish/subscribe (pub/sub) systems have gained popularity in society to provide the convenience of removing the temporal dependency of the user having to indicate an interest each time he or she wants to receive a particular piece of related information. Currently, on the Internet, such pub/sub systems have been built on top of an IP-based network with the additional responsibility placed on the end-systems and servers to do the work of getting a piece of information to interested recipients. We propose Content-Oriented Pub/Sub System (COPSS) to achieve an efficient pub/sub capability for CCN. COPSS enhances the heretofore inherently pull-based CCN architectures proposed by integrating a push based multicast capability at the content-centric layer.

The architecture also includes the following components:

• A gaming application taking advantage of the efficient multicast (G-COPSS).
• A notification application for efficient communication in disasters (CNS).
• A congestion control protocol for efficient and network-friendly multicast (SAID).
• An object-resolution service that maps different features (e.g., keywords, audio clips) to names (ORICE).
• A routing algorithm for efficient request forwarding with concept of "virtual domains" (VDR).
• A mechanism allowing ICNs to coexist with each other and IP (COEXIST, COIN).