programming literacy is crucial for current and future generations of young learners, irrespective of their career paths. programming education is thus essential, making teaching methods and tools to be tailored to th...
详细信息
ISBN:
(纸本)9798400712166
programming literacy is crucial for current and future generations of young learners, irrespective of their career paths. programming education is thus essential, making teaching methods and tools to be tailored to the target audience. In this context, contemporary visual programming environments, particularly block-basedprogramming, have become instrumental in introducing programming concepts to young learners. Educational theories such as Constructionism advocate an approach centered on the learner to deepen and motivate learning. In computer science, these theories can be applied by providing hands-on experiences that connect computer science to real-life situations through the manipulation or construction of physical and tangible computational devices. This study explores the impact of creating a smart object for a smart home using block-basedprogramming on young learners' attitudes and perceptions toward programming and their programming skills acquisition. An introductory programmingworkshop involved 28 8(th) grade students from a secondary school constructing and programming a smart-lighting object in a smart home setting. Performance, attitude, and perception trajectories were assessed through repeated questionnaires. Our results indicate that constructing and programming a real-life smart object enhances learners' confidence and programming skills. This paper contributes to programming education literature by demonstrating the potential of block-basedprogramming, specifically in the context of state-of-the-art smart technologies, to foster programming skills and develop positive attitudes and perceptions among learners.
Epoch based memory reclamation (EBR) is one of the most popular techniques for reclaiming memory in lock-free and optimistic locking data structures, due to its ease of use and good performance in practice. However, E...
详细信息
ISBN:
(纸本)9798400704352
Epoch based memory reclamation (EBR) is one of the most popular techniques for reclaiming memory in lock-free and optimistic locking data structures, due to its ease of use and good performance in practice. However, EBR is known to be sensitive to thread delays, which can result in performance degradation. Moreover, the exact mechanism for this performance degradation is not well understood. This paper illustrates this performance degradation in a popular data structure benchmark, and does a deep dive to uncover its root cause-a subtle interaction between EBR and state of the art memory allocators. In essence, modern allocators attempt to reduce the overhead of freeing by maintaining bounded thread caches of objects for local reuse, actually freeing them (a very high latency operation) only when thread caches become too large. EBR immediately bypasses these mechanisms whenever a particularly large batch of objects is freed, substantially increasing overheads and latencies. Beyond EBR, many memory reclamation algorithms, and data structures, that reclaim objects in large batches suffer similar deleterious interactions with popular allocators. We propose a simple algorithmic fix for such algorithms to amortize the freeing of large object batches over time, and apply this technique to ten existing memory reclamation algorithms, observing performance improvements for nine out of ten, and over 50% improvement for six out of ten in experiments on a high performance lock-free ABtree. We also present an extremely simple token passing variant of EBR and show that, with our fix, it performs 1.5-2.6x faster than the fastest known memory reclamation algorithm, and 1.2-1.5x faster than not reclaiming at all, on a 192 thread four socket Intel system.
How concurrent compacting collectors store and manage forwarding information is crucial for their performance. In this paper, we propose CFW, a representation technique for forwarding information that guarantees that ...
详细信息
ISBN:
(纸本)9781450396967
How concurrent compacting collectors store and manage forwarding information is crucial for their performance. In this paper, we propose CFW, a representation technique for forwarding information that guarantees that forwarding information for an entire heap can be stored in at most 3.14% of its size. By providing such a guarantee, we simplify the task of deploying programs with respect to memory needs. This is important given how memory is typically the dominating factor in the cost model for cloud-based deployments. We explore the design space of our technique through a prototype implementation on-top of ZGC. A rigorous performance evaluation shows promising results.
The proceedings contain 3 papers. The topics discussed include: resolving synchronization conflicts in role-based multimodel-synchronization environments;first-class concepts: reifying architectural knowledge beyond t...
ISBN:
(纸本)9781450385428
The proceedings contain 3 papers. The topics discussed include: resolving synchronization conflicts in role-based multimodel-synchronization environments;first-class concepts: reifying architectural knowledge beyond the dominant decomposition;and towards a framework for analyzing context-oriented programming languages.
The ability to collaboratively edit data in distributed environments is essential in our information-based industry. Typically users or systems concurrently access and modify data from different locations for differen...
详细信息
We present a family of safe memory reclamation schemes, Hyaline, which are fast, scalable, and transparent to the underlying lock-free data structures. Hyaline is based on reference counting - considered impractical f...
详细信息
ISBN:
(纸本)9781450383912
We present a family of safe memory reclamation schemes, Hyaline, which are fast, scalable, and transparent to the underlying lock-free data structures. Hyaline is based on reference counting - considered impractical for memory reclamation in the past due to high overheads. Hyaline uses reference counters only during reclamation, but not while accessing individual objects, which reduces overheads for object accesses. Since with reference counters, an arbitrary thread ends up freeing memory, Hyaline's reclamation workload is (almost) balanced across all threads, unlike most prior reclamation schemes such as epoch-based reclamation (EBR) or hazard pointers (HP). Hyaline often yields (excellent) EBR-grade performance with (good) HP-grade memory efficiency, which is a challenging trade-off with all existing schemes. Hyaline schemes offer: (i) high performance;(ii) good memory efficiency;(iii) robustness: bounding memory usage even in the presence of stalled threads, a well-known problem with EBR;(iv) transparency: supporting virtually unbounded number of threads (or concurrent entities) that can be created and deleted dynamically, and effortlessly join existent workload;(v) autonomy: avoiding special OS mechanisms and being non-intrusive to runtime or compiler environments;(vi) simplicity: enabling easy integration into unmanaged C/C++ code;and (vii) generality: supporting many data structures. All existing schemes lack one or more properties. We have implemented and tested Hyaline on x86(-64), ARM32/64, PowerPC, and MIPS. The general approach requires LL/SC or double-width CAS, while a specialized version also works with single-width CAS. Our evaluation reveals that Hyaline's throughput is very high - it steadily outperforms EBR by 10% in one test and yields 2x gains in oversubscribed scenarios. Hyaline's superior memory efficiency is especially evident in read-dominated workloads.
Efficient ordered in-memory key-value (KV-)maps are paramount for the scalability of modern data platforms. In managed languages like Java, KV-maps face unique challenges due to the high overhead of garbage collection...
详细信息
ISBN:
(纸本)9781450368186
Efficient ordered in-memory key-value (KV-)maps are paramount for the scalability of modern data platforms. In managed languages like Java, KV-maps face unique challenges due to the high overhead of garbage collection (GC). We present Oak, a scalable concurrent KV-map for environments with managed memory. Oak offloads data from the managed heap, thereby reducing GC overheads and improving memory utilization. An important consideration in this context is the programming model since a standard object-based API entails moving data between the on- and off-heap spaces. In order to avoid the cost associated with such movement, we introduce a novel zero-copy (ZC) API. It provides atomic get, put, remove, and various conditional put operations such as compute (in-situ update). We have released an open-source Java version of Oak. We further present a prototype Oak-based implementation of the internal multidimensional index in Apache Druid. Our experiments show that Oak is often 2x faster than Java's state-of-the-art concurrent skiplist.
For decades, fuzzy spatial relations have demonstrated their utility and effectiveness for visual reasoning, including semantic annotation and object recognition. However, a major issue is that they often involve fuzz...
详细信息
The actor paradigm supports the natural expression of concurrency. It has inspired the development of several actor-based languages, whose adoption depends, to a large extent, on the runtime characteristics (i.e., the...
详细信息
ISBN:
(纸本)9781450369824
The actor paradigm supports the natural expression of concurrency. It has inspired the development of several actor-based languages, whose adoption depends, to a large extent, on the runtime characteristics (i.e., the performance and scaling behaviour) of programs written in these languages. This paper investigates the relative runtime characteristics of Akka, CAF and Pony, based on the Savina benchmarks. We observe that the scaling of many of the Savina benchmarks does not reflect their categorization (into essentially sequential, concurrent and parallel), that many programs have similar runtime characteristics, and that their runtime behaviour may drastically change nature (e.g., go from essentially sequential to parallel) by tweaking some parameters. These observations lead to our proposal of a single benchmark program which we designed so that through tweaking of some knobs (we hope) we can simulate most of the programs of the Savina suite.
We implemented a feature-based context-oriented programming language, which clearly separates the notion of contexts from the notion of features. Contexts reify particular situations occurring in the surrounding envir...
详细信息
ISBN:
(纸本)9781450368636
We implemented a feature-based context-oriented programming language, which clearly separates the notion of contexts from the notion of features. Contexts reify particular situations occurring in the surrounding environment, to which a software system can adapt. Features reify the system's behaviour;they are the language components that describe the system's functionality at a fine-grained level. Contexts are mapped to features, such that, when certain contexts become active at run-time, the corresponding features get selected and activated, thus adapting the system's functionality to those particular contexts. In this paper we show the object-oriented architecture, design and implementation issues of such a feature-based context-oriented programming language, which we implemented on top of the Ruby programming language as an application framework for context-oriented programmers. An important part of our language design is the explicit representation of contexts and features in terms of hierarchical tree structures that capture the structural constraints to be maintained at runtime. We illustrate our language design with a small example of a feature-based context-oriented program written in this language.
暂无评论