Home OALib Journal OALib PrePrints Submit Ranking News My Lib FAQ About Us Follow Us+
 Title Keywords Abstract Author All
Search Results: 1 - 10 of 100 matches for " "
 Page 1 /100 Display every page 5 10 20 Item
 Jeremy Kepner Computer Science , 2001, DOI: 10.1016/S0743-7315(02)00054-0 Abstract: 2D convolution is a staple of digital image processing. The advent of large format imagers makes it possible to literally pave'' with silicon the focal plane of an optical sensor, which results in very large images that can require a significant amount computation to process. Filtering of large images via 2D convolutions is often complicated by a variety of effects (e.g., non-uniformities found in wide field of view instruments). This paper describes a fast (FFT based) method for convolving images, which is also well suited to very large images. A parallel version of the method is implemented using a multi-threaded approach, which allows more efficient load balancing and a simpler software architecture. The method has been implemented within in a high level interpreted language (IDL), while also exploiting open standards vector libraries (VSIPL) and open standards parallel directives (OpenMP). The parallel approach and software architecture are generally applicable to a variety of algorithms and has the advantage of enabling users to obtain the convenience of an easy operating environment while also delivering high performance using a fully portable code.
 Computer Science , 2011, Abstract: Multi-threaded programs have many applications which are widely used such as operating systems. Analyzing multi-threaded programs differs from sequential ones; the main feature is that many threads execute at the same time. The effect of all other running threads must be taken in account. Partial redundancy elimination is among the most powerful compiler optimizations: it performs loop-invariant code motion and common subexpression elimination. We present a type system with optimization component which performs partial redundancy elimination for multi-threaded programs.
 Computer Science , 2012, Abstract: Nowadays, networks are almost ubiquitous. In the past decade, community detection received an increasing interest as a way to uncover the structure of networks by grouping nodes into communities more densely connected internally than externally. Yet most of the effective methods available do not consider the potential levels of organisation, or scales, a network may encompass and are therefore limited. In this paper we present a method compatible with global and local criteria that enables fast multi-scale community detection. The method is derived in two algorithms, one for each type of criterion, and implemented with 6 known criteria. Uncovering communities at various scales is a computationally expensive task. Therefore this work puts a strong emphasis on the reduction of computational complexity. Some heuristics are introduced for speed-up purposes. Experiments demonstrate the efficiency and accuracy of our method with respect to each algorithm and criterion by testing them against large generated multi-scale networks. This study also offers a comparison between criteria and between the global and local approaches.
 Computer Science , 2013, DOI: 10.4204/EPTCS.117.3 Abstract: Quantitative theories of information flow give us an approach to relax the absolute confidentiality properties that are difficult to satisfy for many practical programs. The classical information-theoretic approaches for sequential programs, where the program is modeled as a communication channel with only input and output, and the measure of leakage is based on the notions of initial uncertainty and remaining uncertainty after observing the final outcomes, are not suitable to multi-threaded programs. Besides, the information-theoretic approaches have been also shown to conflict with each other when comparing programs. Reasoning about the exposed information flow of multi-threaded programs is more complicated, since the outcomes of such programs depend on the scheduler policy, and the leakages in intermediate states also contribute to the overall leakage of the program. This paper proposes a novel model of quantitative analysis for multi-threaded programs that also takes into account the effect of observables in intermediate states along the trace. We define a notion of the leakage of a program trace. Given the fact that the execution of a multi-threaded program is typically described by a set of traces, the leakage of a program under a specific scheduler is computed as the expected value of the leakages of all possible traces. Examples are given to compare our approach with the existing approaches.
 Mohamed Anis Allouche International Journal of Business Research and Management , 2010, Abstract: This paper proposes a metaheuristic to solve the permutation flow shop scheduling problem where several criteria are to be considered, such as: the makespan, total flowtime and total tardiness of jobs. The proposed metaheuristic is based on tabu search algorithm. The Compromise Programming model and the concept of satisfaction functions are utilized to integrate explicitly the Manager’s preferences. The proposed approach has been tested through a computational experiment. This approach can be useful for large scale scheduling problems and the Manager can consider additional scheduling criteria.
 Computer Science , 2012, Abstract: We present the new multi-threaded version of the state-of-the-art answer set solver clasp. We detail its component and communication architecture and illustrate how they support the principal functionalities of clasp. Also, we provide some insights into the data representation used for different constraint types handled by clasp. All this is accompanied by an extensive experimental analysis of the major features related to multi-threading in clasp.
 Algorithms , 2013, DOI: 10.3390/a6020245 Abstract: This paper is motivated by, but not limited to, the task of scheduling jobs organized in workflows to a computational grid. Due to the dynamic nature of grid computing, more or less permanent replanning is required so that only very limited time is available to come up with a revised plan. To meet the requirements of both users and resource owners, a multi-objective optimization comprising execution time and costs is needed. This paper summarizes our work over the last six years in this field, and reports new results obtained by the combination of heuristics and evolutionary search in an adaptive Memetic Algorithm. We will show how different heuristics contribute to solving varying replanning scenarios and investigate the question of the maximum manageable work load for a grid of growing size starting with a load of 200 jobs and 20 resources up to 7000 jobs and 700 resources. Furthermore, the effect of four different local searchers incorporated into the evolutionary search is studied. We will also report briefly on approaches that failed within the short time frame given for planning.
 Computer Science , 2012, Abstract: We propose a type system to analyze the time consumed by multi-threaded imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demonstrate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regulates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based information flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
 Physics , 2014, DOI: 10.1088/2041-8205/795/1/L23 Abstract: A dominant constituent in the dynamic chromosphere are spicules. Spicules at the limb appear as relatively small and dynamic jets that are observed to everywhere stick out. Many papers emphasize the important role spicules might play in the energy and mass balance of the chromosphere and corona. However, many aspects of spicules remain a mystery. In this Letter we shed more light on the multi-threaded nature of spicules and their torsional component. We use high spatial, spectral and temporal resolution observations from the Swedish 1-m Solar Telescope in the H{\alpha} spectral line. The data targets the limb and we extract spectra from spicules far out from the limb to reduce the line-of-sight superposition effect. We discover that many spicules display very asymmetric spectra with some even showing multiple peaks. To quantify this asymmetry we use a double Gaussian fitting procedure and find an average velocity difference between the single Gaussian components to be between 20-30 km s$^{-1}$ for a sample of 57 spicules. We observe that spicules show significant sub-structure where one spicule consists of many 'threads'. We interpret the asymmetric spectra as line-of-sight superposition of threads in one spicule and therefore have a measure for a perpendicular flow inside spicules which will be important for future numerical model to reproduce. In addition we show examples of {\lambda}-x-slices perpendicular across spicules and find spectral tilts in individual threads providing further evidence for the complex dynamical nature of spicules.
 Computer Science , 2014, Abstract: Avoiding access conflicts is a major challenge in the design of multi-threaded programs. In the context of real-time systems, the absence of conflicts can be guaranteed by ensuring that no two potentially conflicting accesses are ever scheduled concurrently.In this paper, we analyze programs that carry time annotations specifying the time for executing each statement. We propose a technique for verifying that a multi-threaded program with time annotations is free of access conflicts. In particular, we generate constraints that reflect the possible schedules for executing the program and the required properties. We then invoke an SMT solver in order to verify that no execution gives rise to concurrent conflicting accesses. Otherwise, we obtain a trace that exhibits the access conflict.
 Page 1 /100 Display every page 5 10 20 Item