Efficient Transformations of Obstruction-Free Algorithms into Non-blocking Algorithms

This paper focuses on Dynamic Implementation using Array and Linked list. In the data structure concept, the list plays a major role in the allocation of data where it is a general overview of creating a node in a linked list using an array with the initialization of size. The node contains data and is interconnected to the next node in the sequence via their links which perform the search operation where the space and time complexity are not wasted in these analyses. Linked lists are a great way to store a theoretically infinite amount of data with a small and versatile amount of code. The amount of data stored increases linearly with the number of nodes in the list (space-o(n)) where linked lists are more efficient than arrays. It is observed that considering the time complexity when there is a variation in data set linked array is almost reaches close to array whenever dataset is high also linked array has better time complexity than linked list when the searching element is in middle and last. Considering the space complexity linked array is almost 2 times and 4 times less space is needed than array and linked list respectively.

WITHDRAWN: Spearman rank correlation based bagging ensemble bayes optimal classification for genomic predictive pattern analytics

Between the two extremes, lock-based algorithms, which involve “a lot of waiting”, and wait-free algorithms, which are “free of locking and waiting”, there is an interesting spectrum of different levels of waiting. This unexplored spectrum is formally defined and its properties are investigated. New progress conditions, called k-waiting, for \(k\ge 0\), which are intended to capture the “amount of waiting” of processes in asynchronous concurrent algorithms, are introduced. To illustrate the utility of the new conditions, they are used to derive new lower and upper bounds, and impossibility results for well-known basic problems such as consensus, election, renaming and mutual exclusion. Furthermore, the relation between waiting and fairness is explored.

The classic buffer insertion algorithm of van Ginneken has time and space complexity O(n/sup 2/), where n is the number of possible buffer positions. For more than a decade, van Ginneken's algorithm has been the foundation of buffer insertion. In this paper, we present a new algorithm that computes the same optimal buffer insertion, but runs much faster. For 2-pin nets, our time complexity is O(nlogn) and space complexity is O(n). For multipin nets, our time complexity is O(nlog/sup 2/n) and space complexity is O(nlogn). The speedup is achieved by four novel techniques: predictive pruning, candidate tree, fast redundancy check, and fast merging. On industrial test cases, the new algorithms is 2-80 times faster than van Ginneken's algorithm and uses 1/4-1/500 of the memory. Since van Ginneken's algorithm and its variations are used by most existing algorithms on buffer insertion and buffer sizing, our new algorithm significantly improves the performance of all these algorithms. The predictive pruning technique has been applied to buffer cost minimization (Shi et al., 2004), and significantly improved the running time.

A faster FPTAS for knapsack problem with cardinality constraint

This chapter is devoted to mutex-free implementations of concurrent objects. Mutex-freedom means that in no way (be it explicit or implicit) is the implementation of a concurrent object allowed to rely on critical sections (locks). The chapter consequently introduces new progress conditions suited to mutex-free object implementations, namely obstruction-freedom, non-blocking, and wait-freedom. It then presents mutex-free implementations of concurrent objects (splitter, queue, stack, etc.) that satisfy these progress conditions. Some of these implementations are based on read/write atomic registers only, while others use also more sophisticated registers that can be accessed by hardware-provided primitive operations such as compare&swap, swap, or fetch&add (which are stronger than base read/write operations). To conclude, this chapter presents an approach based on failure detectors that allows the construction of contention managers that permit a non-blocking or a wait-free implementation of a concurrent object to be obtained from an obstruction-free implementation of that object.

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

This paper proposes a novel learning algorithm- SVM based MLP neural network algorithm (SVMMLP), which based on the Maximal Margin (MM) principle and take into account the idea of support vectors. SVMMLP has time and space complexities O(N) while usual SVM training methods have time complexity O(N3) and space complexity O(N2), where N is the training-dataset size. Intrusion detection benchmark datasets – NSL-KDD used in experiments that enable a comparison with other state-of-the-art classifiers. The results provide evidence of the effectiveness of our methods regarding accuracy, AUC, and Balanced Error Rate (BER).KeywordsMLP neural networkconvergenceSVMMLPintrusion detection

Kernel ridge regression (KRR) is a powerful method for nonparametric regression. The time and space complexity of computing the KRR estimate directly are O(n3) and O(n2) , respectively, which are prohibitive for large-scale data sets, where n is the number of data. In this article, we propose a novel random sketch technique based on the circulant matrix that achieves savings in storage space and accelerates the solution of the KRR approximation. The circulant matrix has the following advantages: It can save time complexity by using the fast Fourier transform (FFT) to compute the product of matrix and vector, its space complexity is linear, and the circulant matrix, whose entries in the first column are independent of each other and obey the Gaussian distribution, is almost as effective as the i.i.d. Gaussian random matrix for approximating KRR. Combining the characteristics of the circulant matrix and our careful design, theoretical analysis and experimental results demonstrate that our proposed sketch method, making the estimate kernel methods scalable and practical for large-scale data problems, outperforms the state-of-the-art KRR estimates in time complexity while retaining similar accuracies. Meanwhile, our sketch method provides the theoretical bound that keeps the optimal convergence rate for approximating KRR.

Routing with multiple quality-of-services constraints: An approximation perspective

The precision and efficiency of the similarity computing of documents is the foundation and key of other documents processing. In this paper, the DF and TF-IDF algorithms are improved. First, DF's time complexity is linear which suits mass documents processing, but it has the fault that exceptional useful features may be deleted, so we make up that by adding the count of the words at the important places. Second, we rectify the weight of feature by the result of feature selection phase. In this way, we improve the precision of documents similarity without adding much time and space complexity.

In this paper a fast and space efficient method for simulating a d′-dimensional cellular automaton (CA) on a d-dimensional CA (d<d′) is introduced. For d′=2 and d=1 this method is optimal (under certain assumptions) with respect to time as well as space complexity. Let in this case t(n) be the time complexity and r(n) the side length of the smallest square enclosing all used cells. Then the simulation does not need more than O(r 2) cells and has a running time of d′ = d+1 a version with the time and space complexity of O(t 2) will be presented. Finally it will be shown, how it is possible to simulate a 2d-dimensional CA on a d-dimensional CA in a similarly efficient way.KeywordsTime ComplexityCellular AutomatonSpace ComplexityQuiescent StateComputation StepThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Tree structure for distributive lattices and its applications

We consider three popular types of shared memory that support one of the following sets of operations: {CAS, read, write}, {LL, SC, VL, read, write}, or {RLL, RSC, read, write}. We present algorithms that, together with Moir's [Moi97], efficiently implement each shared memory above from any of the other two. Our implementations are wait-free and have constant time and space complexity. Thus, concurrent programs developed for one of the above memories can be ported to any other without incurring any increase in time complexity. Further, since our implementations are wait-free, a wait-free concurrent program remains wait-free even after porting.

Various Data Structures have been introduced till date that aim at either to improve them in terms of time or space complexity or they are particularly designed for some special applications. This work aims at developing a new data structure that takes the idea of plotting each digit to another dimension and thereby reducing the access time for keys stored in it. In order to make it practical to implement, a tree-based approach has been used to store it in the memory. The asymptotic time complexity is O(nu) for extracting the keys in sorted order where u is the size of universe. In practical testing, the procedure took much less time to complete as compared to Merge Sort which is the best Comparison based Sorting Technique in terms of worst-case time complexity. This work discusses the concept, implementation and algorithms associated with the data structure. Then it evaluates it against various test scenarios with other sorting techniques.