Multicore Scheduling for Lightweight Communicating Processes

Process-oriented programming is a design methodology in which software applications are constructed from communicating concurrent processes. A process-oriented design is typically composed of a large number of small isolated concurrent components. These components allow for the scalable parallel execution of the resulting application on both shared-memory and distributed-memory architectures. In this paper we present a runtime designed to support process-oriented programming by providing lightweight processes and communication primitives. Our run-time scheduler, implemented using lock-free algorithms, automatically executes concurrent components in parallel on multicore systems. Run-time heuristics dynamically group processes into cache-affine work units based on communication patterns. Work units are then distributed via wait-free work-stealing. Initial performance analysis shows that, using the algorithms presented in this paper, process-oriented software can execute with an efficiency approaching that of optimised sequential and coarse-grain threaded designs

The certification and privatization of indigenous lands in Mexico

Reforms to Mexico's rural sector that allow ejido and other communal lands to be privatized have been widely criticized. However, the national certification program that facilitates this process, called PROCEDE, has received little attention. We describe how the program was implemented, based on field research in eleven indigenous communities and analysis of archival, cadastral, and statistical information. We explain the surveying methods and the varied ways in which indigenous communities participated in the program. One major achievement of PROCEDE has been to replace thousands of old, inaccurate property maps with a modern cadastral framework based on the delimitation of communal territories with the direct involvement of local people. Many land conflicts were resolved as part of the certification process, although errors in the delimitation will likely generate new ones. However, while the ostensible goals of certification are laudable, there are serious concerns about its consequences for indigenous peoples, including the erosion of community institutions, increased socioeconomic differentiation, accelerated deforestation, and threats to their cultural survival

An adaptive technique for constructing robust and high-throughput shared objects

Abstract. Shared counters are the key to solving a variety of coordination problems on multiprocessor machines, such as barrier synchronization and index distribution. It is desired that they, like shared objects in general, be robust, linearizable and scalable. We present the first linearizable and wait-free shared counter algorithm that achieves high throughput without a-priori knowledge about the system’s level of asynchrony. Our algorithm can be easily adapted to any other combinable objects as well, such as stacks and queues. In particular, in an N-process execution E, our algorithm achieves high N throughput of Ω(), where φE is E’s level of asynchrony. φ2 E log2 φE log N Moreover, our algorithm stands any constant number of faults. If E contains a constant number of faults, then our algorithm still achieves high N throughput of Ω( φ ′2 E log2 φ ′ E log N), where φ ′ E bounds the relative speeds of any two processes, at a time that both of them participated in E and none of them failed. Our algorithm can be viewed as an adaptive version of the Bounded-Wait-Combining (BWC) prior art algorithm. BWC receives as an input an argument φ as a (supposed) upper bound of φE, and achieves optimal throughput if φ = φE. However, if the given φ happens to be lower than the actual φE, or much greater than φE, then the throughput of BWC degraded significantly. Moreover, whereas BWC is only lock-free, our algorithm is more robust, since it is wait-free. To achieve high throughput and wait-freedom, we present a method that guarantees (for some common kind of procedures) the procedure’s successful termination in a bounded time, regardless of shared memory contention. This method may prove useful by itself, for other problems.