doc: Update top layer README to FISim

Author: myk12

README.md

@@ -1,122 +1,40 @@
-# The Network Simulator, Version 3
+# FISim: Future Internet Architecture Simulator
 
 ## Table of Contents
 
-1) [An overview](#an-open-source-project)
-2) [Building ns-3](#building-ns-3)
-3) [Running ns-3](#running-ns-3)
-4) [Getting access to the ns-3 documentation](#getting-access-to-the-ns-3-documentation)
-5) [Working with the development version of ns-3](#working-with-the-development-version-of-ns-3)
+1) [Overview](#overview)
+2) [Build Network](#build-network)
+3) [Run FISim](#running-fisim)
+4) [Cybertwin Network](#cybertwin-network)
+5) [Content Centric Network](#content-centric-network)
 
-> **NOTE**: Much more substantial information about ns-3 can be found at
-<https://www.nsnam.org>
+## Overview
 
-## An Open Source project
+FISim is an open-source network simulator dedicated to FIA (Future Internet Architecture), based on [NS-3](https://www.nsnam.org).
 
-ns-3 is a free open source project aiming to build a discrete-event
-network simulator targeted for simulation research and education.
-This is a collaborative project; we hope that
-the missing pieces of the models we have not yet implemented
-will be contributed by the community in an open collaboration
-process.
+## Build Network
 
-The process of contributing to the ns-3 project varies with
-the people involved, the amount of time they can invest
-and the type of model they want to work on, but the current
-process that the project tries to follow is described here:
-<https://www.nsnam.org/developers/contributing-code/>
+FISim utilizes YAML-based configuration files to construct network topologies, thereby greatly simplifying the work of researchers and practitioners.
 
-This README excerpts some details from a more extensive
-tutorial that is maintained at:
-<https://www.nsnam.org/documentation/latest/>
+## Running FISim
 
-## Building ns-3
+Running FISim is quite straightforward; once you have defined the network topology, system configuration, and applications, you can easily use the commands provided by FISim to compile and run your simulation.
 
-The code for the framework and the default models provided
-by ns-3 is built as a set of libraries. User simulations
-are expected to be written as simple programs that make
-use of these ns-3 libraries.
+## Cybertwin Network
 
-To build the set of default libraries and the example
-programs included in this package, you need to use the
-tool 'ns3'. Detailed information on how to use ns3 is
-included in the file doc/build.txt
+In cloud computing, the Internet is shifting from end-to-end to cloud-to-end connections. Concurrently, the rapid advancement of the Internet of Everything (IoE) and its applications is increasing mobile Internet traffic and services, challenging the existing end-to-end network architecture in terms of mobility, security, and availability. To address these challenges, the Cybertwin network architecture has been proposed. The Cybertwin network introduces the Cybertwin
 
-However, the real quick and dirty way to get started is to
-type the command
+>Cybertwin is a digital representation of humans or things in virtual cyberspace, created for functions such as communication assistance, network data logging, and digital asset ownership. It aims to replace the traditional end-to-end communication model with a cybertwin-based approach.
 
-```shell
-./ns3 configure --enable-examples
-```
+concept into networking and presents a new communication model. Additionally, it introduces a novel cloud network operating system and cloud operator to manage network resources. Key concepts of the Cybertwin network include infrastructure, the Cybertwin based communication model, the cloud network operating system, and the cloud operator. For more details, see~\cite{Cybertwin,cybertwin2}
 
-followed by
+## Content Centric Network
 
-```shell
-./ns3
-```
+Content-Centric Networking (CCN) is an innovative approach to network architecture that is designed to make content the primary focus of the network, rather than the traditional host-centric model where communication is based on the location of the host . In CCN, data is named and addressed, and the network is responsible for delivering that data to the requester, regardless of where the data is located. This is achieved through a publish/subscribe model where consumers request data by name, and the network delivers the data from the nearest node that has it available, which can improve efficiency, especially for popular content that can be cached close to the consumer.
 
-in the directory which contains this README file. The files
-built will be copied in the build/ directory.
+CCN includes features such as in-network caching, which allows for the storage of content at various points throughout the network, reducing the need to retrieve content from its original source each time it is requested. This can lead to significant improvements in latency and bandwidth usage. Additionally, CCN is designed to be more resilient and secure, as content can be verified and authenticated through digital signatures before it is processed by routers or consumers .
 
-The current codebase is expected to build and run on the
-set of platforms listed in the [release notes](RELEASE_NOTES.md)
-file.
+The architecture of CCN is such that it can naturally support scalability, efficiency, and security. It does this by decoupling content from its location, allowing networks to handle increased traffic by caching popular content closer to users, reducing the distance data must travel and balancing loads more effectively across the network . Security in CCN is inherently content-centric, with data packets including cryptographic signatures that ensure content integrity and authenticity, regardless of where the content is stored or how it is transmitted.
 
-Other platforms may or may not work: we welcome patches to
-improve the portability of the code to these other platforms.
+CCN has the potential to greatly enhance the way content is delivered over the internet, making it more suitable for modern applications such as streaming media, content delivery networks, and mobile applications where users frequently change locations . It represents a significant shift from traditional host-centric network architectures towards a more flexible, efficient, and secure content-centric networking approach .
 
-## Running ns-3
-
-On recent Linux systems, once you have built ns-3 (with examples
-enabled), it should be easy to run the sample programs with the
-following command, such as:
-
-```shell
-./ns3 run simple-global-routing
-```
-
-That program should generate a `simple-global-routing.tr` text
-trace file and a set of `simple-global-routing-xx-xx.pcap` binary
-pcap trace files, which can be read by `tcpdump -tt -r filename.pcap`
-The program source can be found in the examples/routing directory.
-
-## Getting access to the ns-3 documentation
-
-Once you have verified that your build of ns-3 works by running
-the simple-point-to-point example as outlined in 3) above, it is
-quite likely that you will want to get started on reading
-some ns-3 documentation.
-
-All of that documentation should always be available from
-the ns-3 website: <https://www.nsnam.org/documentation/>.
-
-This documentation includes:
-
-- a tutorial
-- a reference manual
-- models in the ns-3 model library
-- a wiki for user-contributed tips: <https://www.nsnam.org/wiki/>
-- API documentation generated using doxygen: this is
-  a reference manual, most likely not very well suited
-  as introductory text:
-  <https://www.nsnam.org/doxygen/index.html>
-
-## Working with the development version of ns-3
-
-If you want to download and use the development version of ns-3, you
-need to use the tool `git`. A quick and dirty cheat sheet is included
-in the manual, but reading through the git
-tutorials found in the Internet is usually a good idea if you are not
-familiar with it.
-
-If you have successfully installed git, you can get
-a copy of the development version with the following command:
-
-```shell
-git clone https://gitlab.com/nsnam/ns-3-dev.git
-```
-
-However, we recommend to follow the Gitlab guidelines for starters,
-that includes creating a Gitlab account, forking the ns-3-dev project
-under the new account's name, and then cloning the forked repository.
-You can find more information in the [manual](https://www.nsnam.org/docs/manual/html/working-with-git.html).