Abdel Aziz Farrag

Using semantic knowledge of transactions to increase concurrency

When the only information available about transactions is syntactic information, serializability is the main correctness criterion for concurrency control. Serializability requires that the execution of each transaction must appear to every other transaction as a single atomic step (i.e., the execution of the transaction cannot be interrupted by other transactions). Many researchers, however, have realized that this requirement is unnecessarily strong for many applications and can significantly increase transaction response time. To overcome this problem, a new approach for controlling concurrency that exploits the semantic information available about transactions to allow controlled nonserializable interleavings has recently been proposed. This approach is useful when the cost of producing only serializable interleavings is unacceptably high. The main drawback of the approach is the extra overhead incurred by utilizing the semantic information. We examine this new approach in this paper and discuss its strengths and weaknesses. We introduce a new formalization for the concurrency control problem when semantic information is available about the transactions. This semantic information takes the form of transaction types, transaction steps, and transaction break-points. We define a new class of “safe” schedules called relatively consistent (RC) schedules. This class contains serializable as well as nonserializable schedules. We prove that the execution of an RC schedule cannot violate consistency and propose a new concurrency control mechanism that produces only RC schedules. Our mechanism assumes fewer restrictions on the interleavings among transactions than previously introduced semantic-based mechanisms.

Designing optimal fault-tolerant star networks

The advance in VLSI technology and the continuing decline in the cost of computer hardware have made the construction of complex networks with many processors economically feasible. Due to the complexity of such systems, reliability has become a major issue. In some applications, it is critical that the system must be able to operate correctly despite the presence of certain faults. Multiprocessor networks with such capability are called fault-tolerant networks. These networks increase reliability by replicating some of the basic components, i.e., by including spare processors and interconnection links. The problem that arises naturally is that of minimizing the spare components that are needed to tolerate failure. In this paper, we consider this problem when the network under consideration is organized in the form of a star. The paper describes how to design optimal m-FT (m-fault-tolerant) graphs with respect to the star configuration, for all values of m ≥ 0.

Algorithm for constructing fault-tolerant solutions of the circulant graph configuration

Recently, a general method was developed to design a k-fault-tolerant solution for any given circulant graph, where k is the number of faulty nodes to be tolerated. In this paper, a new algorithm is proposed which, (unlike the earlier method), constructs a family of k-fault-tolerant solutions, for any given circulant graph. These solutions can then be compared to select the one with the least cost. The algorithm is efficient to implement as it requires only a polynomial time (to generate and search the solutions). The proposed method is also useful to other architectures, as demonstrated in the paper. We shall examine the application of the method to the problem of designing k-fault-tolerant extensions of (2 and 3 dimensional) meshes, and show that the solutions obtained are very efficient.<<ETX>>

Tolerating faulty edges in a multi-dimensional mesh

Abstract We examine the problem of tolerating faulty edges in the multi-dimensional mesh architecture. This problem can be briefly defined as follows. Given a mesh M , find a mesh G which satisfies the following conditions: (1) G and M have the same number of nodes, (2) for any subset of k edges in G , there is a submesh in G isomorphic to M which excludes these k edges, and (3) G has the least possible number of edges. The mesh G which satisfies these conditions is called a symmetrically optimal k -edge-fault-tolerant ( k -eft) extension of M . We show that, even for k = 1, finding such a mesh G is a very difficult problem. We develop necessary and sufficient conditions for characterizing the class of symmetrically optimal 1-eft extensions of any given mesh. We propose two new methods for finding a symmetrically optimal, or symmetrically near-optimal, 1-eft extension. The first method finds an optimal solution, and is useful when the number of dimensions in the given mesh M is not very large. The second method finds a near-optimal solution by decomposing the given mesh M into several meshes (with a fewer number of dimensions) that can be solved by the first method.

Performance Comparison of Four Rule Sets: An Example for Encrypted Traffic Classification

The objective of this work is the classification of encrypted traffic where SSH is taken as an example application. To this end, four learning algorithms AdaBoost, RIPPER, C4.5 and Rough Set are evaluated using flow based features to extract the minimum features/rules set required to classify SSH traffic. Results indicate that C4.5 based classifier performs better than the other three. However, we have also identified 15 features that are important to classify encrypted traffic, namely SSH.

The fault-tolerant extension problem for complete multipartite networks

We develop a characterization for m-fault-tolerant extensions, and for optimal m-fault-tolerant extensions, of a complete multipartite graph. Our formulation shows that this problem is equivalent to an interesting combinatorial problem on the partitioning of integers. This characterization leads to a new procedure for constructing an optimal m-fault-tolerant extension of any complete multipartite graph, for any m/spl ges/0. The proposed procedure is mainly useful when the size of the graph is relatively small, because the search time required is exponential. This exponential search, however, is not always necessary. We prove several necessary conditions that help us, in several cases, to identify some optimal m-fault-tolerant extensions without performing any search. >

New algorithm for constructing fault-tolerant solutions of the circulant graph configuration

Abstract The circulant graph configuration has been used to model several important parallel architectures (such as rings and meshes; for examples). Recently, a new method was developed to construct a k-fault-tolerant solution for any given circulant graph, where k is the number of faulty nodes to be tolerated. A generalization of this method is presented in this paper. We propose a new algorithm which (unlike the earlier method) constructs a large family of k-fault-tolerant solutions, for any given circulant graph (and any value of k). These solutions will then be compared to select the one with the least node-degree. Our algorithm is very efficient to implement, since it requires only a polynomial time to generate and search the solutions. Moreover, our method has useful applications to other parallel architectures, as demonstrated in the paper. We shall examine the application of the method to the problem of designing k-fault-tolerant extensions of (2- and 3-dimensional) meshes; and show that the solutions obtained are very efficient.

Fault-tolerant extensions of star networks

Advances in computer technology have made the construction of complex networks with many processors economically feasible. Because of the complexity of such networks, reliability has become a major concern. In some applications, it is critical that the system must be able to operate correctly despite the presence of certain faults. To achieve this fault-tolerance capability, some spare processors and interconnection links need to be added. In this case, when some of the basic components of the network fail, their tasks can be dynamically transferred to the spare components and the network can continue to operate. The three main criteria that it is desirable to minimize in a fault-tolerant design are the number of nodes (processors), the number of edges (links), and the maximum number of connections to a node. Minimizing these attributes is important in practice, as it is unlikely that unbounded increase in the number of nodes, edges, or connections per node would be acceptable in a real design. In this paper, we shall consider this optimization problem when the (nonredundant) network under consideration is organized as a star. We study all possible variations of the problem under the assumption that minimizing nodes has the highest priority.

Fault-tolerant extensions of complete multipartite networks

The authors studied the design of a fault-tolerant extension for a graph G which can survive at most m node failures, and which contains the minimum number of nodes and the fewest possible edges when the nonredundant graph (G) is a complete multipartite graph. After developing a characterization for m-fault-tolerant extensions and for optimal m-fault-tolerant extensions of a complete multipartite graph, this characterization is used to develop a procedure to construct an optimal m-fault-tolerant extension of any complete multipartite graph, for any m>or=0. The procedure is only useful when the size of the graph is relatively small, since the search time required is exponential. Several necessary conditions on any (optimal) m-fault-tolerant extension of a complete multipartite graph are proved. These conditions allow identification of some optimal m-fault-tolerant extensions of several special cases of a complete multipartite graph without performing any search.<<ETX>>

Developing fault-tolerant distributed loops

Distributed loops are highly regular structures that have been applied to the design of many locally distributed systems. This family of networks includes many important configurations such as rings and circulant graphs, for examples. In this paper, we examine the problem of extending a distributed loop so as to tolerate any number of node failures. We study this problem when the parameters that define the loop are given numerically as constants, or symbolically as variables. Our results indicate that the (fault-tolerant) solutions obtained are efficient.