Bulk Synchronous Parallelism (BSP) is a parallel programming model that abstracts from low-level program structures in favour of supersteps. A superstep consists of a set of independent local computations, followed by a global communication phase and a barrier synchronisation. Structuring programs in this way enables their costs to be accurately determined from a few simple architectural parameters, namely the permeability of the communication network to uniformly-random traffic and the time to synchronise. Although permutation routing and barrier synchronisations are widely regarded as inherently expensive, this is not the case. As a result, the structure imposed by BSP does not reduce performance, while bringing considerable benefits for application building. This paper answers the most common questions we are asked about BSP and justifies its claim to be a major step forward in parallel programming. Why Is Another Model Needed?In the 1980s, a large number of different types of parallel architectures were developed. This variety may have been necessary to thoroughly explore the design space but, in retrospect, it had a negative effect on the commercial development of parallel applications software. To achieve acceptable performance, software had to be carefully tailored to the specific architectural properties of each computer, making portability almost impossible. Each new generation of processors appeared in strikingly-different parallel architectural frameworks, forcing performancedriven software developers to redesign their applications from the ground up. Understandably, few were keen to join this process.Today, the number of parallel computation models and languages probably exceeds the number of different architectures with which parallel programmers had to contend ten years ago. Most make it hard to achieve portability, hard to achieve performance, or both. The two largest classes of models are based on message passing, and on shared memory. Those based on message passing are inadequate for three reasons. First, messages require paired actions at the sender and receiver, which it is difficult to ensure are correctly matched. Second, messages blend communication and synchronisation so that sender and receiver must be in appropriately-consistent states when the communication takes place. This is appallingly difficult to ensure in most models, and programs are prone to deadlock as a result. Third, the performance of such programs is impossible to predict because the interaction of large numbers of individual messages in the interconnection mechanism makes the variance in their delivery times large.The argument for shared-memory models is that they are easier to program because they provide the abstraction of a single, shared address space. A whole class of placement decisions are avoided. This is true, but is only half of the issue. When memory is shared, simultaneous access to the same location must be prevented. This requires either PRAM-style discipline by the programmer, or expensive lock mana...
We develop a data‐generated tool for distinguishing between fraudulent and truthful reports based on the language used in the management discussion and analysis section of annual and interim reports. Using this method, we are able to assign a probability of truth to each report which is then shown to be an effective indicator of fraud. Our work goes beyond the development of a tool alone, however, by conducting an extensive comparison of our probability‐of‐truth measure with eight alternative detection tools representing both quantitative and language‐based approaches. Comparisons are made across a variety of samples and show that our language‐based approach can be effective in both cross‐sectional and time‐series settings. It is useful both in distinguishing between fraudulent and truthful firms and in identifying fraudulent reports from a series of reports issued by a single firm. This second setting is one in which accounting‐based detection tools have frequently struggled. We establish that, not only is our probability‐of‐truth measure significantly associated with fraud, so too is the change in this measure from a firm's previous reports. Prior reports may serve an important benchmarking role in using language‐based tools to identify fraud.
We survey parallel programming models and languages using six criteria to assess their suitability for realistic portable parallel programming. We argue that an ideal model should by easy to program, should have a software development methodology, should be architecture-independent, should be easy to understand, should guarantee performance, and should provide accurate information about the cost of programs. These criteria reflect our belief that developments in parallelism must be driven by a parallel software industry based on portability and efficiency. We consider programming models in six categories, depending on the level of abstraction they provide. Those that are very abstract conceal even the presence of parallelism at the software level. Such models make software easy to build and port, but efficient and predictable performance is usually hard to achieve. At the other end of the spectrum, low-level models make all of the messy issues of parallel programming explicit (how many threads, how to place them, how to express communication, and how to schedule communication), so that software is hard to build and not very portable, but is usually efficient. Most recent models are near the center of this spectrum, exploring the best tradeoffs between expressiveness and performance. A few models have achieved both abstractness and efficiency. Both kinds of models raise the possibility of parallelism as part of the mainstream of computing.
The major reason for the lack of use of parallel computing is the mismatch between the complexity and variety of parallel hardware, and the software development tools to program it. The cost of developing software needs to be amortised over decades, but the platforms on which it executes change every few years, requiring complete rewrites. The evident cost-effectiveness of parallel computation has not been realized because of this mismatch. This book presents an integrated approach to parallel software development by addressing both software and performance issues together. It presents a methodology for software construction that produces architecture-independent and intellectually abstract software. The software can execute efficiently on a range of existing and potential hardware configurations. The approach is based on the construction of categorical data types, a generalization of abstract data types, and of objects. Categorical data types abstract both from the representation of a data type, and also from the detailed control flow necessary to perform operations on it. They thus impose a strong separation between the semantics, on which programs can depend, and the implementation, which is therefore free to hide the parallel machine properties that are used.
We investigate the structures present in the Enron email dataset using singular value decomposition and semidiscrete decomposition. Using word frequency profiles, we show that messages fall into two distinct groups, whose extrema are characterized by short messages and rare words versus long messages and common words. It is surprising that length of message and word use pattern should be related in this way. We also investigate relationships among individuals based on their patterns of word use in email. We show that word use is correlated to function within the organization, as expected. Lastly, we show that relative changes to individuals' word usage over time can be used to identify key players in major company events.
Recent research addresses the problem of data-stream mining to deal with applications that require processing huge amounts of data such as sensor data analysis and financial applications. Data-stream mining algorithms incorporate special provisions to meet the requirements of stream-management systems, that is stream algorithms must be online and incremental, processing each data record only once (or few times); adaptive to distribution changes; and fast enough to accommodate high arrival rates. We consider the problem of data-stream classification, introducing an online and incremental stream-classification ensemble algorithm, Streaming Random Forests, an extension of the Random Forests algorithm by Breiman, which is a standard classification algorithm. Our algorithm is designed to handle multi-class classification problems. It is able to deal with data streams having an evolving nature and a random arrival rate of training/test data records. The algorithm, in addition, automatically adjusts its parameters based on the data seen so far. Experimental results on real and synthetic data demonstrate that the algorithm gives a successful behavior. Without losing classification accuracy, our algorithm is able to handle multi-class problems for which the underlying class boundaries drift, and handle the case when blocks of training records are not big enough to build/update the classification model.
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.