Sherenaz W. Al-Haj Baddar

Designing Sorting Networks

Designing Sorting Networks: A New Paradigm provides an in-depth guide to maximizing the efficiency of sorting networks, and uses 0/1 cases, partially ordered sets and Haase diagrams to closely analyze their behavior in an easy, intuitive manner. This book also outlines new ideas and techniques for designing faster sorting networks using Sortnet, and illustrates how these techniques were used to design faster 12-key and 18-key sorting networks through a series of case studies.

An 11-Step Sorting Network for 18 Elements

Sorting networks are cost-effective multistage interconnection networks with sorting capabilities. These networks theoretically consume Θ(NlogN) comparisons. However, the fastest implementable sorting networks built so far consume Θ(Nlog2N) comparisons, and generally, use the Merge-sorting strategy to sort the input. An 18-element network using the Merge-sorting strategy needs at least 12 steps — here we show a network that sorts 18 elements in only 11 steps.

Bitonic sort on a chained-cubic tree interconnection network

Bitonic sort is one of the fastest oblivious parallel sorting algorithms known so far. Due to its high modularity, bitonic sort can be mapped to different interconnection networks. In this paper, the bitonic sort algorithm is mapped to the chained-cubic tree (CCT) interconnection network. It is shown that the computation time of the bitonic sort on a CCT (BSCCT) algorithm is O ( ( n / p ) ? log ( n p ) ) and that the communication cost is O ( p log 2 p ) , assuming that n keys are evenly distributed among p processors that comprise a given CCT network. Simulation is implemented and used to assess the performance of the BSCCT algorithm in terms of computation time, communication cost, message delay, and key comparisons. Simulation results showed that the BSCCT algorithm achieves a speedup that is almost 12-fold relative to a bitonic sort on a single processor, when 1024 processors were used to sort 32M keys. We map bitonic sort to a chained-cubic tree interconnection network, calling the result BSCCT.BSCCTs computation time is O ( ( n / p ) ? log ( n p ) ) , for input size n and p processors.BSCCT costs O ( p log 2 p ) communication steps, for input size n and p processors.BSCCTs relative speedup is 12-fold with p = 1024 processors and n = 32 M keys.BSCCTs communication cost is less than the tree and metacube networks costs.

Reducing the Impact of Traffic Sanitization on Latency Sensitive Applications

In our modern society the reliance on fast and reliable delivery of large amounts of data is steadily growing as more and more companies and public bodies use data analytics to support their decision processes. At the same time, the rise of the Internet of Things introduces into the public cyberspace a multitude of devices that are often ill-suited to implement strong security measures. For this reason, it is of paramount importance that the whole Internet traffic is fully sanitized from any malicious packet before it is delivered to the destination. Past work has proved that this compelling security requirement may be leveraged to implement an aggressive intrusion detection that may lead to energy savings in the network; however it may also negatively impact latency sensitive applications as the need to scrutinize all the packets may cause latency sensitive traffic to incur unwanted delays beyond the time needed to analyze it for security sake. In this paper, we describe a methodology that, while guaranteeing a full sanitization of the Internet traffic, allows reducing its impact on the delay introduced in latency sensitive traffic.

Saving energy in aggressive intrusion detection through dynamic latency sensitivity recognition

Abstract In an always connected world, cyber-attacks and computer security breaches can produce significant financial damages as well as introduce new risks and menaces in everydays life. As a consequence, more and more sophisticated packet screening/filtering solutions are deployed everywhere, typically on network border devices, in order to sanitize Internet traffic. Despite the obvious benefits associated to the proactive detection of security threats, these devices, by performing deep packet inspection and inline analysis, may both affect latency-sensitive traffic introducing non-negligible delays, and increase the energy demand at the network element level. Starting from these considerations, we present a selective routing and intrusion detection technique based on dynamic statistical analysis. Our technique separates latency-sensitive traffic from latency-insensitive one and adaptively organizes the intrusion detection activities over multiple nodes. This allows suppressing directly at the network ingress, when possible, all the undesired components of latency-insensitive traffic and distributing on the innermost nodes the security check for latency sensitive flows, prioritizing routing activities over security scanning ones. Our final goal is demonstrating that selective intrusion detection can result in significant energy savings without adversely affecting latency-sensitive traffic by introducing unacceptable processing delays.

How on Earth Could That Happen? An Analytical Study on Selected Mobile Data Breaches

Abstract The amount of digital data produced all over the world is unprecedented, and as it conveys almost all aspects of life it has become more vulnerable than ever. Mobile data security breaches have been making news headlines, from the security breaches suspected in the 2016 US presidency elections to Yahoos massive 1B account breaches, not to mention the massive security breaches big retailor stores sustained over the past few years. Although experts claim that solutions to combat such breaches are being developed, breaches continue to multiply. In this study, we analyze recent mobile data breaches and describe their major attack surfaces. Based on the insights we obtained from our study, we provide a set of recommendations to help prevent mobile data breaches from happening in the first place, rather than simply react to its aftermath, when it is already too late.

DAS: Distributed analytics system for Arabic search engines

In this paper, we introduce the fault-tolerant Distributed Analytics System (DAS) for analyzing big data collected from search engines in Arabic. This system consists of three main subsystems: Logging and Archiving Subsystem (LAS), Analytics Subsystem (AS), and a User Interface (UI). We used the data provided by opensooq.com, an online market with Arabic content, and compiled four datasets with sizes: 50 Million, 100 Million, 150 Million, and 200 Million events, in order to assess DAS. The experiments showed that DAS outperformed its sequential counterpart at datasets of 100 Million events and more, with the best speedup being 3.5 at 200 Million events. Additionally, DAS outperformed the well-known analytics system ElasticSearch (ES) in terms of response time for input sizes of 70 Million events and more, as the time per request achieved by DAS was 21% faster than ESs time. Moreover, DAS turned out to be more energy-efficient in terms of CPU utilization, as ESs CPU utilization was 2.4 times more than DASs utilization, on average.

Finding Better Networks

We say that a new network for N keys is better than all other known networks for N keys if: it is more efficient (uses less comparators than all other N-key networks); or it is faster (uses less steps than all other N-key networks). As for the number of comparators, we can’t do any better than the information-theoretic lower bound. An N-key sorting network must sort all N! permutations of N distinct keys. Thus, the number of comparators must be at least ceil (log2(N!)). As for the number of steps, If S(N) is the best lower bound on the number of comparators for an N-key network, then sorting cannot complete in less than ceil(S(N)/((N − 1)/2)) steps if N is odd and ceil(S(N)/(N/2)) steps if N is even. Inspecting Tables 9.1, 9.2 and 9.3, and 9.4 shows that there is a gap between the information theoretic lower bound and either the most efficient or the fastest networks discovered so far. Thus, either a higher information theoretic lower bound exists or either more efficient or faster networks exist.

Ideas for Faster Networks

We have already seen, in Chap. 9, that there is a gap in the number of steps between the fastest-known network and the information-theoretic lower bound. Thus, while trying to find a faster N-key sorting network , try to select a value for N for which this gap is the greatest. The initial steps of your network should combine all N keys into a single-segment poset. After that, apply the divide-and-conquer strategy described in Chap. 7 to split your keys into groups. As a consequence, the final steps of your network will contain a number of G-key sorting networks for some small, preferably even; G. The most difficult group will be the group in the middle. Thus, you may choose to place one group just below the mid-point and the other just above the mid-point. The other choice would be to place one group to straddle the mid-point with another group just below it and a third group just above it. Another approach to solving this problem would be using Sortnet commands. These commands help the designer select the comparators that: remove the most dashes from the Shmoo chart; affect the most cases; or a combination of both.

A 16-Key Sorting Network

We analyzed Van Voorhis 16-key network because it is faster than the merge-sorting networks for 16 keys (9 steps instead of 10 steps). To help better understand the behavior of this network, we used the relabeling technique. We re-labeled the network by exchanging K[3] with K[8] and by exchanging K[7] with K[12]. This, resulted in a more logical placement of the 14 keys in the three sets between K[0] and K[15] since it put: K[11] through K[14] in the top set; K[5] through K[10] in the middle set; and K[1] through K[4] in the bottom set. When we drew the Knuth diagram for the re-labeled network , we found that: the first six steps partition the keys into four 4-key groups with every key in each group less than or equal to every key in the next higher group; steps 5 through 8 sort the keys within each group; and step 9 finishes sorting all the remaining cases to complete the sort of all 16 keys. Thus, relabeling this network helped us realize that it uses the well-known divide-and-conquer strategy to sort the 16 input leys.