Advancing named data networking: a comprehensive survey on naming and packet lookup mechanisms

FIB-based approaches

The FIB data structure contains content names and their associated port numbers. In NDN, FIB lookup is performed using Longest Prefix Matching (LPM). For example, if a packet with the content name /cnn.com/news/snowstorm.avi/v7/s0 matches the second or third entry in the FIB, the content is forwarded through the corresponding interfaces. The comparative analysis of FIB-based packet lookup approaches in wired NDN is shown in Table 5 and in Table 6. This section discusses the various approaches used for content lookup within the FIB.

• Trie-Based Approaches: Parallel name lookup (PNL) is a FIB-based first name lookup approach proposed to handle forwarding in NDN (Wang et al., 2011). PNL names can be represented by the name prefix tier (NPT) or by the module granularity, rather than the bit granularity. It’s an allocation algorithm that assigns logically tree-based names to physical components with measured and less storage redundancy. As the update occurs more frequently, the approach is planned to be executed with low complexity. Whenever FIB collects data elements, it examines whether the first element corresponds to the root edge. If so, the transfer condition becomes true and is transmitted from the root to the node at the pointed level. This process is repeated iteratively. It stops when the transfer condition is false and the state reaches its leaf node. Then, the process terminates, returning the last port. In specific memories, the name of the content is matched when multiple inputs arrive concurrently. They store all memories and work simultaneously to achieve high-speed lookup. Although various nodes may be replicated during the allocation phase, this results in a burst of memory usage, which is directly proportional to the number of nodes. Name component encoding, using 32-bit to encode the names of components, is proposed in Wang et al. (2012b). It reduces the number of component codes and the length of the component code without compromising accuracy. It separates the encoding process from the LPM, making it possible to use parallel processing techniques to speed up name lookup. To execute this technique, two approaches are proposed: a code assignment approach to reduce the memory size for name components and to speed up the LPM, and an enhanced state transition array (STA). Once the name is encoded, the code is allocated to matching edges in the NPT, which yields a new Trie named the encoded name prefix Trie (ENPT), as shown in Fig. 11. Experimental results show a 30% increase in memory and achieve 1.3 million lookups per second. The first wire-speed mechanism based upon a hardware accelerator is proposed in Wang et al. (2013c) that utilized the vast dealing ability of the GPU. The multi-stream mechanism of the GPU-based structure is used to mitigate the lookup latency resulting from the GPU’s massive computational power. GPU-based schema operates as follows: Initially, the table of contents names are organized in a tree of characters. Furthermore, the tier of characters is reformed into multi-aligned transition arrays (MATA) that unite the finer of the two worlds. Then, it is further transformed into a GPU-based name lookup approach. It receives the data requested name as input and implements the name lookup operation using MATA. Whenever the operation of lookup is considered, the outcome is conveyed from the GPU to the CPU to obtain the evidence of the subsequent hop boundary. Results demonstrate that it controls the 63.53 MLPS and attains greater than 30 K plus 600 K for each instant deletion and insertion. In the NDN, the field-programmable gate array (FPGA) method for content lookup is proposed (Li et al., 2014b). However, handling name lookups using an FPGA is a challenging task. A possible collision could occur between transitions of a single tree level. To distribute through the names of the class, the authors proposed an algorithm that was implemented using hierarchical aligned transition arrays (HATA). The modifications are kept in aligned transition arrays, while there is only one possible transition through employing numerous candidates and corresponding verification techniques. The verification phase is handled similarly, as the transition array is stored in diverse memory, allowing for additional plotting. The consequences indicate that the suggested approach utilizes approximately 95% of the GPU storage. Furthermore, it reduces latency to 3%, and its lookup performance is 2.4 times. HATA attains 125 MLPS on average. Figure 12 shows the generic Trie based implementation of FIB. The tokenized Patricia-constructed content lookup approach is suggested in Song et al. (2015) as an effective data structure for storing billions of names, as shown in Fig. 13. This approach combines routers containing only one node with their parents to decrease cost and memory burden. Consider an appropriate approach to support subsequent purposes. Initially, it employs a dual approach, utilizing NameTrie to compress the distributed portion into names. Second, any naming system handles the names as a bit string. Third, direct names are stored and used for lookup, eliminating the need for parsing. To improve the lookup, a speculative technique is also presented that transmits the packets using leaf prefix count (LPC) instead of LPM. If a match exists, LPC behaves similarly to LPM and sends the Data packet to the next router. If no correspondence exists, forward the packet to the next router rather than releasing it. To support forwarding, they employed a dual Patricia with LPC. Instead of storing the whole name of packets, it simply stores the dissimilarity between the components. Hence, the memory overhead is visibly reduced. Results are evaluated using an SRAM-based scheme that achieves 142 MLPS with an estimated 16M names; DRAM is more suitable for extensive content and achieves 20 MLPS. Content lookup rapidity is increased by decreasing the number of contrasts with the assistance of the port number in the node Trie. This concept presents the P-Trie approach in Dagang, Junmao & Zheng (2016). In this approach, nodes are categorized into three types: Accepted (which retains the final character of the names), Evolved (where every prefix has the same outgoing port, while no parent has dissimilar information), and Midway (which retains the previous packets). Whenever a packet arrives through any evolved packet, the node sends it instantly. On the other hand, if a mismatch occurs at some node, the packets are resumed due to the port information. It is executed in MATA to enhance memory efficiency. Results show that it is quicker than ATA and MATA and a ternary search by 15 times, respectively. A name-based forwarding approach called N-FIB is suggested in Saxena & Raychoudhury (2016a) and constructed upon Patricia Trie. It consists of two stages: FIB lookup and aggregation. The previous component gathers various entries into a single entry. Moreover, it provides the deletion and insertion procedure for NDN forwarding. The final component searches for LPM in an aggregated component or aggregated FIB. The difficulty of the FIB combination is O(N/K), where K means the depth of the Trie and N means the number of names. It is evaluated against the Bloom filter to show the memory and time efficiency budget. It reduces router computation and memory overhead, ensuring the correctness of forwarding. In Saxena et al. (2016a), a scalable and practical memory-based Radix Trie Component Encoding Approach (RaCE) is proposed. RadixTrie decreases memory overhead and provides reliability for the NDN router. First, the received component name and name prefix are divided into components. Afterward, unique tokens are created for every single component, where the same components share the same encoding. Results show that it consumes less memory than the original NCE for 29 million datasets. Name Trie-based data structures are proposed in Ghasemi et al. (2018) to index and keep forwarding table records. Nodes are kept compact, enhancing the packet speedup and cache efficiency for processing. Edges are executed using a hash table, enabling fast name updates and lookups. Within Nametrie, a new approach controls information without consuming extra memory for Trie granularity. Extensive experimental results demonstrate that it achieves fast updates while consuming a small portion of memory, resulting in 35% less memory usage and faster performance in name lookup and updates. This (Ghasemi et al., 2019) is the first article to address the influence of granularity and establishes a comprehensive association between the third Trie-constructed content lookup structure and updates (at the character, bit, and component levels). A new tool named NameGen generates a collection of large datasets with diverse characteristics of names. It’s essential to examine name structure from three different perspectives. Initially, it allows end-users to modify the characteristics of the name, which plays a crucial role in performance. Secondly, it eliminates the need to trust a small dataset. Lastly, it delivers the uniformity of the dataset for upcoming research. Results explicitly highlight the limitations and strengths of every single Trie-constructed approach and describe a supposition upon the selection of granularity.

• Bloom-Filter Based Approaches: A Bloom filter remains a rapid and memory-efficient structure that indicates whether an element is present in a set. Using a bloom filter for FIB name lookup can help speed up the name lookup process. Inappropriately, it cannot be used directly. A name filter based on a two-stage bloom filter mechanism is proposed in Wang et al. (2013b). In the first phase, prefixes are mapped to a single memory control, and the interval between the names is verified. In the binary phase, content lookup is performed within a simple group of combined Bloom filters that are applied at the initial stage. The consequences demonstrate that it achieves a high throughput of 37 MLPS with a low storage cost, which is directly equivalent to 12 times faster than the character tier speed, and are illustrated in Fig. 14. A two-stage Bloom filter structure, executing the Level-Priority Trie (LPT), is proposed in Byun & Lim (2019). It consists of two operational Bloom filters, one for returning an identical or similar level and the other for returning an output face. The number of components encoded in the bloom filter is minimized by using an LPT. Hence, it is sufficiently small to be kept in on-chip memory. Its performance is significantly enhanced by only querying the bloom filter, without retrieving the off-chip hash table. The off-chip hash table is only retrieved for this case whenever indeterminable results are obtained at the second stage. Simulation results display that 99% of the input is obtained only by searching the on-chip bloom filter. An efficient technique that merges routing connectivity with a bloom filter is proposed in Mun & Lim (2019) to reduce memory and traffic requirements for creating FIB tables. The routing connectivity information is shared as a summary bloom filter (S-BF). Nodes gather the summary and create a forwarding bloom filter (F-BF). Interest packets are distributed by searching the F-BFs. An auxiliary FIB table is also proposed to mitigate the extra traffic generated by false positives. Simulation results show that it can attain optimal performance compared to link-state algorithms and substantially reduce the memory needed. It does not require any prior information about the system’s topology and operates entirely distributively. FIB-based approaches for wired NDN, such as Trie and Bloom filter-based approaches, are extensively elaborated in Table 7.

• Hash Table Based Approaches: In FIB, LPM restricts the name lookup to a Hash table. To overcome these limitations, a greedy name lookup approach known as Hungry-SPHT remains, which is combined using a sequence of hash tables. The hungry approach enhances the tracking of content names in router tables. Moreover, a drawback of hash tables is that they are often implemented using string-oriented perfect hash tables (PHT) to speed up name lookup and reduce memory overhead. It retains only the value of the content name in the catalogue, rather than the content name itself. Motivated through the provision of name modules, the author enhances the lookup implementation by reordering the examination sequence of name prefixes constructed by allocating their components. It is compared with CCN-PHT and simple greedy-PHT to assess its performance. Experiments with 3-M or 10-M table entries illustrate that it achieves high-speed lookup as compared to others while occupying less memory as well (Wang et al., 2014). Longest name prefix matching (LNPM) (Yuan & Crowley, 2015) that unites a hash table with the dual examination of one billion entries. Encrypted tables are constructed for the prefixes of names using K components, corresponding to the number of components in the name. A binary search is performed for every node in the hash table of K components. If a prefix match is an exit, it transmits to the right subtree to check whether or not the other names are appropriate. If no match exists after that, it transmits to the leftward subtree for a lookup of whether a prefix exists or not. It ends when it reaches the leaf node or the bottom of the binary search tree. To reduce the number of memory accesses, the fingerprint-based hash table is used wherever the fingerprint is the hash value of keys in the name prefix table. Results show that 6MLPS can be achieved with one billion entries in a seven-component name table. Hash-based and hybrid methods are elaborated in Table 8 in terms of their approach, naming scheme, contributions, and limitations.

• Hybrid Approaches: Multiple techniques are considered for executing FIB, which may involve merging more than one structure and employing other approaches, such as using a GPU. A packet corresponding to the name is sent at a similar interval to the subsequent router that runs towards the delay in DRAM storage. Influenced by this performance, a new scheme based on a non-aggregatable name prefix for FIB is suggested in Fukushima, Tagami & Hasegawa (2013). The prefix length is added to the packet forwarded to the next router to prevent the same prefix length from being looked for again. When an Interest packet reaches FIB, it is handled in the following phases: the leaf prefix count table (LPCT) filters prefixes based on their length and number. If no prefix exists, the Bloom filter prevents redundant probing that would occur with hash tables. A hash table is employed through one access to DRAM memory to search for prefix entries. If the match prefix entry is found and contains no child, then it is LPM. On the other hand, if the name is taken instead of prefixes and the LPM is looked up, then the next router and length of the name are returned. It is executed on both hardware and software-based FIBs. The hardware-based approach achieves 66 MLPS with under 50 million names, whereas the throughput of software-based approaches is high. The NCE approach is employed by utilizing the massive parallel computing power of GPUs (Wang et al., 2013a). Using code allocation and evolution selection, NCE consumes only a particular entrance memory among the transitions occurring among the NDN routers. Pipeline and multi-stream CUDA techniques are implemented in the GPU to improve name lookup performance and reduce delay. The FIB content index is organized using a module Trie and is encrypted into integers to arrange the module’s encryption. Afterward, it is remodeled using a single array dimension, for which the change among the nodes is accumulated through a particular memory access. A distinct code assignment technique exists to decrease the storage burden of ENCT. It reduces memory overhead and speeds up name lookup compared to NCE for a dataset of over 10 million. The adaptive content name constructed lookup filter is introduced in Quan et al. (2014). In this approach, every content name is categorized into B-prefix and T-suffixes. B-content refers to the Bloom filter and is restricted in the distance handled by counting the Bloom filter (CBF). B-prefix is utilized with a hash table to validate the location of resultant T-suffices. T-suffice length is smaller than its full name and is executed using the tree structure. Using the Trie, a similar procedure continues till the corresponding LPM is found. The lengths of both B-prefixes and T-suffixes can be organized through recognition to accelerate the lookup. For T-suffices, a similar procedure runs for multiple repeated storage accesses. Therefore, the size of the B prefix can be adjusted to conform to the acceptance of the prefix. It is directly proportional to length. If their exit is strongly popular, then the length would be higher, and so on. Compared to other approaches, it achieves a higher speed of lookup while, in terms of memory cost, it shows an average usage of resources. The content router-based name lookup approach, Caesar, is proposed in Perino et al. (2014). A unique prefix bloom filter (PBF) is merged to achieve optimistic wired speed with a hash table, which utilizes a GPU for the provision. Later, it employs the hash table lookup to retrieve information about the next hope and eliminate false positives. Experimental outcomes demonstrate that Caesar supports a line card of 95 MLPS, utilizing a packet size and index size of 10 million. In Tan & Zhu (2015), authors utilize the MATA data structure, which was introduced in Wang et al. (2013c). Initially, an encrypted operation is employed to signify the content of NDN using an integer string. Secondly, the split name character exploits this integer as a state transition array to construct a character Trie. Lastly, the character Trie employs a novel structure known as MATA-CH, which differs from the MATA in two ways: it’s more variable, as it’s neither extended nor restricted through progress. The amount of state decreases as each module is updated through single changes. Motivated by the divided model lookup, SNT is employed to improve the number of name lookups. The names are distributed to the slightly sub-levels. As other content names are reached, they are divided into dual segments to execute independent lookups. It reduces the memory cost by employing component hash and splitting them into Tries, which are shown in Fig. 15. A fast LPM framework using a hybrid Trie and hash array structure is proposed in Saxena et al. (2016a). It consists of two lookup strategies: a quick and a slow path. Previously, when the packet reaches the NDN router, a size decrease of the content name scheme is requested to change the content name to a human-comprehensible name. Afterward, the converted name is added and isolated as of FIB using a double-encrypted operation. Whenever the packet arrives at the router node, the same size reduction name scheme is not employed. In its place, a key production scheme is used through the content name to construct the group of formless solutions. Outcomes show that it can achieve high throughput on both CPU and GPU platforms. The hybrid construction of Patricia Trie and the hash table is proposed in Yuan, Crowley & Song (2017) to improve the name lookup speed using fingerprint-based methods. Based on hypothetical forwarding string matching, different issues are planned. There is no consistent name prefix exit in the router table. By reducing the Trie size, the Patricia Trie minimizes the delay for lookups by utilizing the Patricia Trie method. Considering the memory overhead issue, the fingerprint-based hash table only keeps fingerprint names. The proposed algorithm implementation demonstrates that the Patricia Trie-based approach reduces lookup latency while consuming only 3.2 GB of memory to store the names of 1 billion, as shown in Fig. 15. Content- and shape-based frameworks with static random access memory and ternary addressable memories are proposed in Huang & Wang (2018) to achieve low memory costs and high-speed lookups. Shrink the minor load scheme to group many name prefixes of shapes in a small content memory. The form of the content name is an arrangement of its constituent letters. To enhance the performance of content search, a two-model-based fingerprint scheme with a hash table is used in static RAM. Experiment results illustrate that it outperforms in attaining high throughput and low memory cost. To provision LPM in hash tables, random search is used to enhance lookup speed by updating the FIB and optimizing the search path. A composite structure for random search is proposed in Hu & Li (2019) by integrating the Trie and the encrypted table. It is presented to preserve the association between content names by avoiding backtracking and discarding memory, thus improving lookup efficiency. Results indicate that introducing a Trie structure restricts the influence of examining speed and memory utilization. The implementation of examinations is facilitated through the use of longer names in the packet and smaller terms in the FIB table. An effective name splitting mechanism named as split name into the basis and suffixes (SNBF) (Wu et al., 2019). In this approach, we decompose B-suffices into multiple components. Every component is kept in a counting bloom filter (CBF). The correlation verification method is also proposed to confirm the inherent relation of the components of all bases. On the other hand, suffixes are handled by Tree bitmaps. Simulation results demonstrate that it enhances the lookup rate and reduces the probability of false-positive results.

PIT-based approaches

PIT is equally significant in place of FIB and CS due to the regular modification of the operation. Every PIT entry comprises a nonce, content name, expiration time, and both incoming and outgoing interface addresses. Nonce and content names are used to identify packets and prevent the transmission of duplicate packets. Inward and outward interfaces signify the starting and ending nodes of the selected packet. The packet lifetime is linked to the packet’s entry whenever it transmits. If it does not return until the lifetime expires, the subsequent entry is deleted (Saxena & Raychoudhury, 2016b). Table 9 presents all PIT-based approaches in terms of their naming scheme, contributions, and limitations. The comparative analysis of PIT-based packet lookup approaches in wired NDN is shown in Table 10. Some operations are also implemented upon PIT, such as addition, deletion, and update. Whenever a new data request is received at the NDN router, it examines whether the request is already present in the router. If the data entry is not present, the corresponding entry is inserted by constructing a new one. The renew function is executed to avoid data replication if the packet is still alive. When the subsequent data arrives or expires, the delete operation is implemented. Such an operation consists of one lookup and deletion depending on the data structure (Dai et al., 2012).

• Trie-Based Approaches: The first comprehensive article examining the size of PIT storage was presented in Dai et al. (2012). For the creation and building of tables in NDN, a further flexible and encrypted scheme is proposed in Wang et al. (2012b), which is employed to speed up the access operations and reduce the PIT size. Whenever the packet reaches the PIT, its content name component is determined, along with the allocation of a code production using NCE. After that, the data sequence is inserted into ENPT, which is then used to remove, update, and search for the content name in PIT. Using NCE, only the memory size of the PIT tables can be reduced, and the PIT shows good scalability. Regarding the retrieve function, the outcomes illustrate that the lookup functions for PIT deletion and insertion speed are 1.4 and 0.9, respectively.

  An efficient name encoding technique known as radient is proposed in Ghasemi et al. (2019) and is demonstrated in Fig. 16, wherein a single named module is substituted through an exclusive program that is similar to modules that allocate matching programs. This method comprises a dual-module Trie, along with the encrypted content NameTrie. It includes the dual segment, plus the accessible symbol heap, which keeps a record of symbols that are recently inserted or removed, along with a recurrent symbol that keeps a record of each module inserted into the table entry. When the request for the latest packet is added to the table entry, the named module is divided into multiple segments, for which every search is examined in the CRT. Suppose the module is present within the CRT; after that, the assigned program is reverted. If no correspondence exists, the module is inserted into the heap, producing an original program. In advance, the occurrence of the inward packet is improved by utilizing a symbol occurrence chart. Next, the content name encoding is forwarded to the NRT for the PIT update. A lazy deletion method is adopted for deletion. The memory needed for the 29M dataset to execute the radient approach is 140.10 MB.

• Hash Table Based Approaches: In Varvello, Perino & Linguaglossa (2013), the primary focus is on planning and executing a table to maintain the cable’s speed. The assignment of PIT and structure can affect the execution. LHT and d-left hash tables are presented in place of the structure using a lookup in the router tables. According to Dai et al. (2012), the position of PIT is limited to the output, input, and third-party methods. Outcomes demonstrate that the last method is highly effective, as it enables the examination of all table functions. This procedure takes the names of 10 Gbps and keeps the data of 1 million entries. In Yuan & Crowley (2014), a method is proposed for PIT among encrypted tables, based on the concepts of fundamental and boundary routers in TCP/IP network systems. This strategy aims to utilize a constant segment of the 16-bit fingerprint for fundamental routers. On the other hand, boundary routers typically use IP addresses instead of string names. However, collisions of fingerprints and the inability to differentiate such collisions arise from identical Interests. The problem of overlapping fingerprints is alleviated by reducing the Interest combination characteristics of fundamental routers. Packets are transmitted when they reach the router’s foundation. After the execution of fingerprint duplication, most Interest combinations occur at boundary nodes, and CS is employed to prevent duplicate request information. Simulation outcomes demonstrate that this approach reduces storage space for fundamental routers and can be utilized to support names at speeds of up to 100 GBPS. Platform execution through an improved open challenge hash table for the routers is proposed in Li et al. (2014c) and illustrated in Fig. 17. They delivered a model to implement maximum and average PIT sizes constantly. The results demonstrate which dimension size is less than the system settings, with no optimal bandwidth and caching. In Mahmoudi & Ahmadi (2022), the authors use Cuckoo filters to implement the PIT in NDN as a distributed data structure. To minimize the memory required and the time to accomplish PIT, look up the least proposed approach to divide the PIT into sub-tables, one for each router interface. A sub-table will eliminate redundancy from the global table to form part of the complete global table. As evidenced by the results, implementing these techniques yields an overall 36% increase in lookup time and consumes 68% less memory than a standard hash table lookup. To this end, this work establishes how distributed data structures can be used to enhance PIT design in wired NDN.

• Bloom Filter Based Approaches: A distributed PIT-based data structure design is proposed in You et al. (2012) by employing a minimal amount of storage allocated to each boundary constructed on CBF. Router tables are distributed within associate tables known as PITi. It is implemented in a manner that, using the Bloom filter, keeps the tables within the related boundaries. It could not trust the naming approach, both flat and hierarchical. Evaluated using a hash table, it reduces memory usage and achieves a higher lookup data rate. United Bloom Filter (UBF) to compress the PIT efficiently is proposed in Li et al. (2012) and is shown in Fig. 18. Using the UBF prevents false negatives and counter leaks when counting the Bloom filter. UBF includes both current and non-current Bloom filters. The time for each PIT entry is split into periods. The Bloom filter non-current is set to a constant value at the start of every period. If the unknown content name is added to the table after that, this addition is constructed upon Bloom filters. On the other hand, the content lookup is executed simply on the present Bloom filter. At the end of each period, dual Bloom filters exchange their value. The Bloom filter displays the packets received in the current and previous periods. Afterward, all the names are inserted into the Bloom filter and disconnected from the last or the next period. Reduction in CBF occurs at the memory (10%) and error possibility (0.1). While UBF can reduce storage by 40%, the chance is decreased by nearly 0.027%. A mapping bloom filter-based design (MaPIT) is proposed in Li et al. (2014c), comprising a packet store and an index table. The index table shall consist of two structures of array bits: a usual Bloom filter and a 30-bit mapping array to map bits. A Bloom filter is used to check whether the entry exists in the MBF. The value of MA is utilized to approach the packet store. The initial state of the new incoming and its resultant bit in MA is assumed to be zero. Whenever the entries are added to MBF, a few bits are changed to 1s according to the subsequent hash value in the Bloom filter. The index table utilizes on-chip memory, while packet storage utilizes off-chip memory. In the MaPIT, the name of the content is encrypted using SHA1 or MD5. The performance of MaPIT is compared and evaluated with that of the hash table and NCE. It has a lower probability and memory consumption than a hash table and NCE. A half-stateless forwarding approach for the router tables is proposed in Tsilopoulos, Xylomenos & Thomas (2014). The request of Interest is discovered at a particular hop, in contrast to each hop. Afterwards, the demand is gathered in the opposite direction, and the information at intermediate nodes is used to deliver a response between the routers using the Bloom filter. During this scheme, the price of sending effectively decreased to 40%, and the distribution of unicast and multicast data decreased from 30% to 60%.

• Hybrid Based Approaches: Linear-chained hash table and Bloom filter are proposed by co-designing software and hardware in Carofiglio et al. (2015). The operations of PIT are combined into a single demand. The packet’s name is divided into two segments: the data name and the segment number. Using the function, the flexible length requested data name is established utilizing a bit name. The Table ID is incorporated to maintain diverse IDs in the tables of the NDN router. If content previously exists in the table, the router explores the FIB to transmit packets of Interest. Limited on-chip block RAM is utilized for the lookup table, while the whole table is stored in SRAM. Using a hash function, a Key is mapped to the bucket. This approach was implemented on an FPGA, and its entire handling rate was equal to 60 MLPS. For PIT, a dimensional filter is adopted in Shubbar & Ahmadi (2019b) that outperforms other filters. It has improved performance in terms of low memory requirements, throughput, and false positives, making it very suitable for execution in PIT. It is based on a bit vector (quotient filter), which means that the bit vector has replaced the standard PIT. The number of the bit-vectors displays the number of faces in the corresponding NDN node, as shown in Fig. 19. Results show it fulfills the requirements for building an efficient PIB.

Entire router-based approaches

The original NDN proposal recommends leveraging the significant influence of TCAM to enhance the execution of name lookup for all NDN components. Notably, due to its limited memory, high power consumption, and high price, TCAM is unfeasible (Wang et al., 2013a). Some studies have proposed schemes to accelerate the lookup function within the router, without focusing on a particular component, by utilizing an encrypted table and Bloom filter approaches. Trie-based approaches are not functional due to their diverse class lookup functions in PIT or FIB. The Entire Router-based packet lookup approaches for wired NDN are shown in Table 11 and in Table 12. This section presents the works that comprise the overall scheme.

• Hash Table Based Approaches: A detailed study of the current CCNx implementation is presented in Yuan, Song & Crowley (2012). They confirmed that achieving scalable performance requires considerable effort and provided an appropriate description of a key issue in NDN: scalability. The transmitting function in CCNx and NDN will be available for group learning. Name lookup identified three main issues: most extended prefix matching, exact matching technique, and flow maintainer on a large scale. CCNx combines the PIT and FIB in a single encrypted table, and every piece of content in the table has an indicator that specifies the FIB and PIT. Suppose the arriving Data packet corresponds to the preceding data with identical contents before the indicator provides content names, thereby decreasing the number of needed contrasts aimed at LPM. The characteristics they proposed are that the LPM and EPM must select the module name so that a unit of matching can be performed, instead of just considering the component’s name. An additional feature is the delivery of component names in the URL, which enables exceptional performance. After examining multiple design forwarding engines for NDN routers constructed on the chained hash table, as introduced in So et al. (2012). 64-bit siphash generates a value at each hash table entry to reduce string comparison. The dual-phase LPM approach is utilized for the lookup function. In the initial phase, it begins as the most employed module level signified by M. It attempts to transfer to the subsequent, minor content name until the correspondence of the prefix occurs. If the correspondence of the prefix does not survive after that, it does not correspond in the FIB. When a match is found, the next phase is started and displays a possible match at the highest depth of the prefix. The lookup begins, and the search continues until a match is found. In the case of PIT and CS, they employed a complete exact matching technique for name lookup and were integrated into a single hash table. It accomplishes the overall processing of up to 8.82 MLPS. It encrypts the variable-length prefix of 32-bit length by executing the cyclic redundancy checksum (CRC) function, thereby reducing the name lookup in NDN routers (Hsu & Chang, 2014). Altogether, the encrypted module eliminates the slash symbol and is connected to the name content of a 32-bit. If the nodes of NDN obtain a novel data element, the content name is encrypted, and the data information is gathered on the CS. Whenever a novel data element reaches the nodes of NDN through varying distances, its name is encrypted earlier and conveyed to the CS, PIT, and FIB. Through the utilization of the CRC bit encrypted approach, the memory space is reduced to 26.29, and the speed of lookup is increased by 21.63 using evaluation of the single NDN technique.

• Hybrid Based Approaches: After discovering the deterministic finite-state automata (DFA) and hash table, it has been learned that the hash table is more efficient and effective than DFA due to the varying lengths of names in NDN (So et al., 2012). A linked list with a chained hash table is exploited to prevent additional comparisons and collisions. A hash table is also integrated with the Bloom filter to enhance the implementation of name lookup in PIT and CS. It accomplished 1.5 MLPS for the Interest and 2.14 for the Data packets. The United table is an encrypted table known as BFAST, consisting of NDN data structures (PIT, CS, and FIB) and a Bloom filter (Nurhayati et al., 2022). It is shown in Fig. 20. BFAST utilises the Bloom filter to assign the burden between the encrypted loads. To achieve a good execution of the look and to ensure functional control, a supplementary Bloom filter is employed, with the table for the minimum standby serving as the article renovation. Whenever this approach is used in PIT, CS, and FIB, the content name and its signature are computed through the encrypted function and stored in the table. The content is gathered in the area of the index entries, and the results demonstrate that it can acquire the lookup function and achieve a speed of 81.32 for the entire NDN structure. It performs much better than the NCE, CCNx, and Namefilter methods, but it consumes more memory than the others. The steerable name-lookup-based Bloom filter approach is presented in Huang et al. (2016) for NDN routers. The names in this approach are categorized according to the number of components and the name length to map them into a diverse Bloom filter. These mapped names are kept in the distinctive hash table. Every entry is assigned a specific memory size. Consequently, the memory access is reduced to one. Memory effective component steerable structure, known as the number of components, is constructed to optimize the number of components when executing matching. Results demonstrate that 2.5M names achieved improved lookup performance compared to BH and CCNx, but require more memory than the steerable lookup. A two-dimensional filter with a hash table is introduced in Shubbar & Ahmadi (2019a) to reduce memory overhead and accelerate lookup for FIB in NDN. The filter is used as a pre-searching process to decrease the redundant memory in the hash table. A hash table is built hierarchically to confirm the accuracy and speed of this approach. Moreover, the filter and hash table use the same value to reduce the hash calculation. Results show that it reduces the memory overhead and confirms the speed of lookup.

FIB-based approaches

A unique execution of FIB, known as MaFIB, is proposed in Li et al. (2017) that facilitates flexible and ordered name lookup in content name searching. For now, the employment of plotting filters along with multi-hierarchical memory further enhances the rapidity of lookup. It decreases the frequency of retrieving memory and understanding the meaningful decrease in memory utilization. Evaluation results show that it can reduce on-chip memory and speed up the lookup procedure in the memory. For the time to begin, the possibility of a false positive is below 1 in 2 million names. It enables the enhanced FIB to utilize the memory of the onboard chip and fulfills the requirements for the present system. The practical name prefix approach for mobile IoT is proposed in Lee & Lee (2016) to decrease the delay desirable for the content name throughout the MCS delivery. The suggested scheme is based on the TBR and pDND methods. It uses pre-allocated name prefixes and a naming collection structure to deliver uniform MCS association in mobile NDN. They keep the resource utilization of nodes up-to-date by reducing the routing scope. Moreover, it can maintain suitable resource consumption due to the low overhead of Interest messages compared to the fDND method. This characteristic is significant in CCN, as multiple contents are inherently found due to dynamic topology changes and a limited number of route combinations. In Khelifi et al. (2019), they target the identification characteristics in vehicular data networks and suggest a name translation to the hash encryption method. The approach involves securing every component of the name content individually to a permanent interval, and after that, an algorithm for the lookup process is executed. The previous procedure improves the NDN by utilizing fewer comparisons than ordered names, and the final procedure gives a quick speed lookup. The proposed algorithm is evaluated in contrast to dissimilar connected solutions using real domain datasets. Theoretical and experimental analysis show that it is more effective in terms of memory utilization and complexity than in terms of lookup time. Hierarchies and self-certifying constructed naming approaches, through an effective organization approach, are proposed in Mahmoudi & Ahmadi (2022) for vehicular systems.

It enables the optimal utilization of characteristics suggested by the hierarchies and self-certifying approaches, as shown in Fig. 21. Hierarchies involve information about their types, attributes, and subtypes, as well as content providers that provide shared content among different vehicles. The hash value is used in vehicular applications to identify content uniquely. It fulfills two main objectives; initially, it reduces the size of the node table by shortening the content names and combining them. Secondly, it involves temporal and spatial information and their varieties to discover and solve the content. This consists of managing prefixes in the FIB and PIT tables. It is comparatively simple, faster, and space-efficient, and has improved execution compared to existing naming solutions. Results demonstrate that the suggested scheme achieves faster prefix search and delete procedures than simple Trie and Bloom filter-based approaches. In Ma et al. (2024), the authors introduce ndnSieve, a congestion control approach that combines SDN with NDN to control packets’ flows in wireless NDN. The scheme separates congestion control from routing to facilitate the intervention of the SDN controller. It incorporates a path replacement strategy and Interest rate adjustments that involve real-time network states. The results demonstrate that the proposed ndnSieve improves throughput by 33.55%, offers better latency, and fairly balances multipath wireless environments. This approach is designed to overcome fundamental issues in complex, limited wireless NDN environments. Packet lookup approaches for Wireless NDN are shown in Table 13 and in Table 14.