Alternative Futures of Right in Pashukanis, Kojève, and Bloch

Alternative futures analysis (AFA) is used to evaluate and rank nine alternative land use futures for pro-environment and pro-development interest groups in Flathead County, Montana, using a fuzzy multiple attribute evaluation method. The nine alternative futures consisting of combinations of low, moderate, and high economic growth scenarios and current, moderately restrictive, and highly restrictive land use policies for the period 2000–2024 were simulated using the Ecosystem Landscape Modeling System. Alternative futures were ranked based on the total output of goods and services in the county estimated using the IMPLAN model, the developable county area available for development, and the total area developed in 8-km buffer areas for five protected areas in the county. Results indicate that although the rankings of the alternative futures differ for the two interest groups, the alternative future having a moderate growth rate with the current land use policy is the highest ranked alternative future for both groups.

Parameterized Time Warp (PTW): An Integrated Adaptive Solution to Optimistic PDES

Fine-Grained Parallel and Distributed Spatial Stochastic Simulation of Biological Reactions

We investigated how future alternative designs for exurban residential subdivision development in agricultural landscapes might affect aquatic ecosystems and public perceptions, and we asked whether better aquatic ecological quality would correspond with public perceptions of greater landscape attractiveness. The alternative exurban futures we compared were: ecologically beneficial subdivisions, conventional subdivisions, and conventional agriculture. To judge their aquatic ecology effects we measured the chemistry and biota of six first-order streams within our study area, the Huron and Raisin River watersheds in the Detroit CMSA. We chose two stream catchments that exhibited land cover to represent the same proportions as each of three types of alternative exurban futures. Streams in catchments representing ecologically beneficial subdivision designs had the most total macroinvertebrate taxa, the most sensitive macroinvertebrate taxa, lowest nitrates, lowest total phosphorus, and lowest total suspended materials. Nutrient concentrations were highest in agricultural catchments, and suspended sediments were highest in conventional subdivision catchments. To compare public perceptions of the alternative futures, we surveyed 336 suburban and exurban adult residents of the upper Midwest. All respondents viewed digital imaging simulations of each of the futures and rated their attractiveness as if they were seen from the window of a home in the area. Ecologically beneficial futures were perceived as most attractive. Comparing the alternative futures, rankings of aquatic ecological quality were consistent with public perceptions of attractiveness.

As suggested in the previous section, if we are to consider alternative societal futures we need to arrive at some understanding of the alternative power relations between social groups and individuals which could arise in Europe 2000. These power relations will determine the goal structures and dominant values of society. The goal structure of any particular institutional area of society will be derived from the central values. This can be seen as a problem of understanding the prevailing definitions of the situation 1 of an institutional sphere which indicates the general pattern of forces at work in that institutional area and is derived from the value system of those exercising influence over it. The roles and norms influencing individuals in this particular sphere will also be derived from these dominant goals and values. The roles of cultural institutions in alternative futures, will be affected by the definition of the sphere of cultural agencies in alternative societal futures manifesting different values and goals.

We introduce, in this paper, Clustered Time Warp (CTW), an algorithm for the parallel simulation of discrete event models on a general purpose distributed memory architecture. CTW has its roots in the problem of distributed logic simulation. It is a hybrid algorithm which makes use of Time Warp between clusters of LPs and a sequential algorithm within the clusters whereas Time Warp is traditionally implemented between individual LPs.We also develop a family of three checkpointing algorithms for use with CTW, each of which occupies a different point in the spectrum of possible trade‐offs between memory usage and execution time. The algorithms were implemented and tested on several digital logic circuits and their speed, number of states saved and maximal memory consumption were compared to Time Warp. Our results showed that one of the algorithms saved an average of 40% of the maximal memory consumed by Time Warp while the other two decreased the maximal usage by 15 and 22%, respectively. The latter two algorithms exhibited a speed comparable to Time Warp, while the first algorithm was 60% slower.We investigated the scalability of CTW using 3 different queuing models and different service‐time distributions and showed that the algorithm acts to limit the explosion of rollbacks exhibited by Time Warp. Furthermore, we showed that the memory requirements for CTW are three times smaller than that of Time Warp for one model and half as large for the two other models.

MITRE's future generation computer architectures program

MITRE — through its Future Generation Computer Architectures program — has conducted research in parallel computing since 1983 [2-5.7]. Our research is currently directed toward operating systems for massive distributed-memory MIMDs running general-purpose, object-oriented programs. Scalability and reliability are central concerns in our research. To us, scalability means that a system can be expanded incrementally, and the addition of processors always increases the processing power of the system. Reliability means that application programs continue to run, and run correctly, in spite of isolated hardware failures. For our research, we assume a message-passing system with no shared memory and no broadcast facility. We also assume the network changes with time because processors fail and because processors are added to the running system. The system must be able to recognize failed processors and avoid them. It must also be able to recognize new processors and make them useful members of the working community while the system is running. The only kind of failure we consider is catastrophic processor failure. We assume that conventional error-detecting and correcting techniques are used to ensure that processors that function do so in a fault-free manner and that communication between processors is reliable. Our research has taught us that the constraints imposed by a massive message-passing architecture, with even the narrow fault tolerance goals we have described, demand a view that emphasizes control at the local level, coordination at the global level, and the ability to tolerate inexact information. The foremost lesson we have learned about such systems is that they are nonintuitive: algorithms that work well with few processors may not scale well to systems with many processors — in general, you must do things differently to keep overhead from overwhelming the system. We have observed algorithms perform well in simulated systems of 256 processors and break down in systems of 1024. (We look forward to seeing what happens when we can simulate systems of substantially greater size.) Another lesson we have learned is that the cost of implementing a fault-tolerant algorithm can be very high and depends a great deal on the nature of the algorithm — the degree to which it employs local control and can tolerate inexact information. Our model of computation is object-oriented programming; for us, objects represent the independent computational units that can enable parallelism within a program. We have not yet committed to a particular object-oriented language; instead, we have concentrated on operating system issues we feel are common to supporting many distributed object-oriented programming systems. Our research specifically concerns distributed techniques for resource management, object addressing, garbage collection, and computation management. We constrain ourselves to techniques that do not require centralized control or global information, and can be made tolerant of hardware failures. We expect that objects are dynamically created and discarded as a program executes. We think of objects as representing units of work assigned to processors. Memory management must provide a means of finding processors with sufficient free memory to store new objects. Processor management must provide a means of dynamically balancing the load on processors by distributing objects in a relatively equitable manner. We have developed a resource management strategy that meets these requirements. One feature of the scheme is that objects are distributed among processors in an equitable manner when they are created; another feature is that objects are redistributed among processors dynamically to maintain a relatively equitable distribution. The scheme is based on the use of resource agents — operating system servers distributed throughout the system. Each agent manages memory allocation for the processors in its local communication neighborhood. A processor sends allocation requests to its local agent; that agent assigns each request to whichever processor in its neighborhood it deems most appropriate. If there is none, the agent forwards the request to a super agent — another operating system server that overseas activity in several agents' neighborhoods. If the superagent has another Time Warp [6] to ensure that messages are processed in the correct order by each object. Time Warp was proposed to synchronize the execution of discrete-event simulations on multiprocessors. While our approach is based on Time Warp, it extends the mechanism to facilitate general-purpose programming. In Time Warp, an object processes messages as they arrive, but before processing each message, it saves its state. If a message arrives with a simulation time earlier than a message already processed, the object rolls back to a state at or before the time of the new message, processes that message at the correct simulation time, and reprocesses messages over which it rolled back. There are two kinds of messages that can be sent in Time Warp — event messages and query messages. A query message cannot cause side effects, and always returns a reply message to the sender. An event message can cause side effects, and never returns a reply message. In general-purpose computation, it is common for a method to send a message and use the result that is returned. If that message is an event message, Time Warp forces the programmer to actually write two methods — the event message is sent in the first and the result is used in the second. A second event message must be introduced to signal the availability of the result and trigger the execution of the second method. It is up to the programmer to make sure that the second event message is processed correctly if other messages can be received before it. These restrictions may be natural in the context of simulations of real-world situations; however, they force a programmer to structure general-purpose programs in an unnatural way that is by no means trivial. Time Warp places another restriction on the programmer. A cycle of recursive query messages can be processed at the same simulation time; however, a cycle of recursive event messages cannot. The purpose of this restriction is to avoid Time Warp's equivalent of deadlock — infinite rollback. However, it makes side-effecting recursion difficult to accomplish. It requires the programmer to manage the timing of events so that no intervening messages are processed while the recursion is in progress. This is not an easy task, since it may be hard to predict (until execution time) the depth of a recursion and, hence, the number of messages involved. In our model, a sending object can use the result of a side-effecting message it sent later in the same method, and side-effecting recursion is fully supported. There are two reasons for this. First, our model of execution controls time in a manner that is completely transparent to the programmer. Our computation time dynamically and automatically attains as fine a granularity as is necessary to support replies from side-effecting messages and side-effecting recursion. Second, our model allows method execution to be rolled back so that side-effecting recursion can be handled correctly. We currently have code for a computation manager that embodies our model of execution and runs compiled programs on a multiprocessor simulator. The compiler takes object-oriented programs written in a subset of Common Lisp using Flavors and produces programs in which each object class is combined with an executive class that implements the operations of the model of execution. The compiler generates compiled methods in which each pseudo-instruction is a piece of Lisp code; method execution consists of stepping through these instructions, saving state information as appropriate. Our next goal is to implement a fault-tolerant version of our computation manager on a multiprocessor. Our objective this year was to design a model of execution for distributed, general-purpose, object-oriented computation to support concurrency in a manner transparent to the programmer. The mechanisms we have described involve considerable overhead; a major goal for the future is to develop techniques for reducing overhead sufficiently to make this approach practical. We also plan to add computation management to an existing simulation that includes fault-tolerant resource management as described above. We will also implement one of the object-addressing schemes and one of the garbage-collection schemes we have described. The integrated simulation will be used to observe the functioning of the operating system as a whole and will itself be implemented on a multiproc

The Effect of Memory Capacity on Time Warp Performance

Given two time series, possibly of different lengths, time warping is a method to construct an optimal alignment obtained by stretching or contracting time intervals. Unlike pairwise alignment of amino acid sequences, classical time warping, originally introduced for speech recognition, is not symmetric in the sense that the time warping distance between two time series is not necessarily equal to the time warping distance of the reversal of the time series. Here we design a new symmetric version of time warping, and present a formal proof of symmetry for our algorithm as well as for one of the variants of Aach and Church [1]. We additionally design quadratic time dynamic programming algorithms to compute both the forward and backward Boltzmann partition functions for symmetric time warping, and hence compute the Boltzmann probability that any two time series points are aligned. In the future, with the availability of increasingly long and accurate time series gene expression data, our algorithm can provide a sense of biological significance for aligned time points - e.g. our algorithm could be used to provide evidence that expression values of two genes have higher Boltzmann probability (say) in the G1 and S phase than in G2 and M phases. Algorithms, source code and web interface, developed by the first author, are made publicly available via the Boltzmann Time Warping web server at bioinformatics.bc.edu/clotelab/.

The behavior of n interacting processes synchronized by the “Time Warp” rollback mechanism is analyzed under the constraint that the total amount of memory to execute the program is limited. In Time Warp, a protocol called “cancelback” has been proposed to reclaim storage when the system runs out of memory. A discrete state, continuous time Markov chain model for Time Warp augmented with the cancelback protocol is developed for a shared memory system with n homogeneous processors and homogeneous workload. The model allows one to predict speedup as the amount of available memory is varied. To our knowledge, this is the first model to achieve this result. The performance predicted by the model is validated through direct performance measurements on an operational Time Warp system executing on a shared-memory multiprocessor using a workload similar to that in the model. It is observed that Time Warp with only a few additional message buffers per processor over that required in the corresponding sequential execution can achieve approximately the same or even greater performance than Time Warp with unlimited memory, if GVT computation and fossil collection can be efficiently implemented.

The behavior of n interacting processes synchronized by the “Time Warp” rollback mechanism is analyzed under the constraint that the total amount of memory to execute the program is limited. In Time Warp, a protocol called “cancelback” has been proposed to reclaim storage when the system runs out of memory. A discrete state, continuous time Markov chain model for Time Warp augmented with the cancelback protocol is developed for a shared memory system with n homogeneous processors and homogeneous workload. The model allows one to predict speedup as the amount of available memory is varied. To our knowledge, this is the first model to achieve this result. The performance predicted by the model is validated through direct performance measurements on an operational Time Warp system executing on a shared-memory multiprocessor using a workload similar to that in the model. It is observed that Time Warp with only a few additional message buffers per processor over that required in the corresponding sequential execution can achieve approximately the same or even greater performance than Time Warp with unlimited memory, if GVT computation and fossil collection can be efficiently implemented.

House price increases have been steady over much of the last 40 years, but there have been occasional declines, most notably in the recent housing bust that started around 2007, on the heels of the preceding housing bubble. We introduce a novel growth model that is motivated by time-warping models in functional data analysis and includes a nonmonotone time-warping component that allows the inclusion and description of boom-bust cycles and facilitates insights into the dynamics of asset bubbles. The underlying idea is to model longitudinal growth trajectories for house prices and other phenomena, where temporal setbacks and deflation may be encountered, by decomposing such trajectories into two components. A first component corresponds to underlying steady growth driven by inflation that anchors the observed trajectories on a simple first order linear differential equation, while a second boom-bust component is implemented as time warping. Time warping is a commonly encountered phenomenon and reflects random variation along the time axis. Our approach to time warping is more general than previous approaches by admitting the inclusion of nonmonotone warping functions. The anchoring of the trajectories on an underlying linear dynamic system also makes the time-warping component identifiable and enables straightforward estimation procedures for all model components. The application to the dynamics of housing prices as observed for 19 metropolitan areas in the U.S. from December 1998 to July 2013 reveals that the time setbacks corresponding to nonmonotone time warping vary substantially across markets and we find indications that they are related to market-specific growth rates.

Efficient processing of similarity search under time warping in sequence databases: an index-based approach

This paper discusses effective processing of subsequence matching under time warping in time-series databases. Time warping is a transformation that enables finding of sequences with similar patterns even when they are of different lengths. Through a preliminary experiment, we first point out that Naive-Scan, a basic method for processing of subsequence matching under time warping, has its performance bottleneck in the CPU processing step. For optimizing this step, in this paper, we propose a novel method that eliminates all possible redundant calculations. It is verified that this method is not only an optimal one for processing Naive-Scan, but also does not incur any false dismissals. Our experimental results showed that the proposed method can make great improvement in performance of subsequence matching under time warping. Especially, Naive-Scan, which has been known to show the worst performance, performs much better than LB-Scan as well as ST-Filter in all the cases by employing the proposed method for CPU processing. This result is interesting and valuable in that the performance inversion among Naive-Scan, LB-Scan, and ST-Filter has occurred by optimizing the CPU processing step, which is their common performance bottleneck.