Threads, Critical Sections, and Termination

•

0 likes•160 views

The document discusses techniques for safely sharing state between threads in the presence of termination, including using semaphores, valueUninterruptably:, and valueUnpreemptively:. It evaluates the performance of these different approaches and finds that using ensure: directly has the best performance of around 15ns while still providing termination safety when modifying shared state.

Software

Martin is getting
the projector
to work with
his laptop.

Threads,
Critical Sections,
and Termination
Martin McClure

ClientMap
• Identity Dictionary
•~2M keys
•~100K updates/s
•~(1-10)×100K lookups/s

"Premature
optimization is the
root of all evil."
--Donald Knuth

Time microsecondsToRun:
[1000000 timesRepeat: []]

Time microsecondsToRun:
[1000000 timesRepeat: []]
3ns-4ns

[sem critical:
[dict
delegateAtClient: key]]

[sem critical:
[dict
delegateAtClient: key]]
~130ns

Hash Bucket Lookup
index := linear search for key.
^index == 0
ifTrue: [nil]
ifFalse:
[value := self basicAt: index.
(keys at: index) == key
ifTrue: [value] ifFalse: [nil]]

Hash Bucket Add
index := freeHead.
[] ensure:
[freeHead := keys at: freeHead.
self basicAt: index put: value.
keys at: index put: key.
size := size + 1].

[“empty block”] ensure:
[“non-empty block”].

Semaphore
critical: mutuallyExcludedBlock
self waitIfCurtailedSignal.
^mutuallyExcludedBlock
ensure: [self signal]

testTerminateInEnsure
| process count random delay |
random := Random new.
10 timesRepeat:
[process :=
[count := 0.
[] ensure:
[10 timesRepeat:
[count := count + 1.
1000000 timesRepeat: [12 factorial]].
count := count + 1]]
forkAt: Processor activeProcess priority - 1.
delay := (random next * 100) asInteger + 10. "avoid 0-ms delay"
(Delay forMilliseconds: delay) wait.
self assert: process isTerminated not.
process terminate.
process priority: Processor activeProcess priority + 1.
self
assert: process isTerminated;
assert: count equals: 11]

Other Ways
• Semaphore
•#valueUninterruptably
•#valueUnpreemptively

Semaphore
•No termination
protection
•70ns

This document discusses optimizations for deep neural network (DNN) hardware architectures. It describes common DNN layers like convolutional and recurrent layers. It evaluates DNN architectures based on metrics like accuracy, throughput, latency, energy efficiency and hardware cost. It introduces the roofline model for analyzing computational intensity and performance bottlenecks. Different techniques are proposed to optimize the multiply-accumulate (MAC) operations at the core of DNNs, like leveraging parallel processing elements, quantization, pruning and rearranging computations. The MIT Eyeriss architecture is highlighted as an example of an optimized hardware design that maps DNN computations efficiently onto a configurable array of processing elements.

Pfii u mich

Daniel Wheeler

The document summarizes the results of using the PRISMS-PF matrix-free finite element code to solve two test cases from the CHiMaD benchmark problems. For problem 1 (spinodal decomposition), the code performed well and captured the expected morphology evolution. For problem 2, the solution did not converge to the expected values. Overall, the authors were pleased with the code's performance but want to revisit problem 2 with future improvements.

Network Simulation

lohch3

NS-3 is a discrete event network simulator written in C++ to simulate Internet systems. The document discusses using NS-3 to simulate and compare direct mapping and dynamic mapping in IPv6 address resolution. It generates results using network tools like Wireshark and tracing files to show that direct mapping improves IPv6 packet transmission time over dynamic mapping by extracting the MAC address directly from the IPv6 address rather than using neighbor discovery protocols. It concludes direct mapping is more efficient and suggests future works could add routers, more network traffic, and multicast to the simulation topology.

Optimizing Parallel Reduction in CUDA : NOTES

Subhajit Sahu

Introduction to ns2

Pradeep Kumar TS

This document provides an introduction to using NS2 (Network Simulator 2) for network simulation. It recommends using Linux over Windows for NS2 as support has been stopped for Windows beyond a certain version. It outlines some basic Linux commands needed for working with NS2 and describes NS2's architecture which uses C++ for implementation and OTCL for the user interface with TclCL providing the interface between them. It also gives a brief overview of NS2's capabilities for simulating protocols and networking entities and describes OTCL with examples of defining classes and objects.

Python Programming - IX. On Randomness

Ranel Padon

%w(map reduce).first - A Tale About Rabbits, Latency, and Slim Crontabs

Paolo Negri

By Víctor Jáquez. SysLink is a multi-core Inter-Processor Communication (IPC) software stack, pushed by Texas Instrument, where the developers could take advantage of asymmetric multiprocessing with several heterogeneous processors running different instances of operating system, whether Linux or any other flavor of RT OS. In the realm of the multimedia processing, this mechanism offloads the CPU-intensive (de)codification tasks from the host processor, enhancing the user experience, particularly in embedded devices, where specialized processing units could be stored on SoCs. This talk will describe the main SysLink components (Linux kernel API, RCM modules, etc.) and how we could map those concepts into GStreamer elements, providing hardware accelerated multimedia, but without the burden of OpenMAX. The target SoC is the OMAP4 using a panda-board.

Performance and scalability for machine learning

Arnaud Rachez

This document discusses performance, parallelism, and scalability for machine learning. It begins by showing how optimizing stochastic gradient descent (SGD) using Python, Numba, NumPy, and Cython can speed it up versus pure Python. It also discusses optimizing for memory layout and caching. A case study shows optimizing Gensim's word2vec by rewriting it in Cython and leveraging BLAS for further speedups. The document discusses how hardware trends have increased parallelism through more cores. It describes parallelizing word2vec training using threads, achieving near linear speedup. Finally, it mentions experimenting with an asynchronous, lock-free implementation of SAG in Julia.

MobileNet - PR044

Jinwon Lee

Deathstar

armstrtw

deathstar is a tool for seamlessly running R code across local and cloud computing nodes. It uses ZeroMQ to distribute data and code across nodes. The deathstar daemon runs on each node and listens for work. The R package exposes a zmq.cluster.lapply function similar to regular lapply to distribute jobs. Examples show using deathstar to estimate pi across nodes and calculate stock betas in a distributed manner. deathstar allows scaling R code to multiple cores locally or launching EC2 instances on AWS for more capacity.

LMAX Disruptor as real-life example

Guy Nir

The document discusses the Disruptor, an ultrafast communication framework. It describes the problems with traditional concurrent queues, such as lock contention. The Disruptor uses a novel ring buffer approach with barriers to allow producers to add events and consumers to process them in parallel without synchronization overhead. This architecture enables it to achieve throughput of over 6 million transactions per second. The Disruptor exploits hardware characteristics to achieve extremely low latency communication between threads.

Mininet: Moving Forward

ON.Lab

The document discusses Mininet, an open source network emulator used for testing SDN ideas. It provides an overview of Mininet 1.0 and its functional fidelity before describing plans for Mininet 2.0 to improve performance fidelity through techniques like resource isolation, network invariants, and reproducible experiments. The document uses the example of DCTCP traffic to demonstrate how network invariants can validate emulator results.

Keynote: Machine Learning for Design Automation at DAC 2018

Manish Pandey

Manish Pandey gave a keynote talk on transforming EDA with machine learning and discussed opportunities and challenges. He described how machine learning can be applied across different design abstraction levels from formal verification to silicon engineering. Pandey also discussed using machine learning techniques like reinforcement learning and word embeddings to optimize formal verification, simulation, and mask synthesis. Finally, he outlined challenges with data availability and model development for machine learning in EDA.

Reactive mistakes - ScalaDays Chicago 2017

Petr Zapletal

Reactive applications are becoming a de-facto industry standard and, if employed correctly, toolkits like Lightbend Reactive Platform make the implementation easier than ever. But design of these systems might be challenging as it requires particular mindset shift to tackle problems we might not be used to. In this talk we’re going to discuss the most common things I’ve seen in the field that prevented applications to work as expected. I’d like to talk about typical pitfalls that might cause troubles, about trade-offs that might not be fully understood or important choices that might be overlooked including persistent actors pitfalls, tackling of network partitions, proper implementations of graceful shutdown or distributed transactions, trade-offs of micro-services or actors and more. This talk should be interesting for anyone who is thinking about, implementing, or have already deployed reactive application. My goal is to provide a comprehensive explanation of common problems to be sure they won’t be repeated by fellow developers. The talk is a little bit more focused on Lightbend platform but understanding of the concepts we are going to talk about should be beneficial for everyone interested in this field.

Multicore programmingandtpl(.net day)

Yan Drugalya

This document discusses multicore programming and the move toward parallelism. It covers the current state of affairs including why Moore's law is no longer increasing processor speed alone. It then discusses multithreaded algorithms and provides an example of matrix multiplication. Finally, it outlines the key building blocks of the Task Parallel Library for .NET including tasks, collections, phases, partitioning, and exception handling.

Multicore programmingandtpl

Yan Drugalya

The document discusses multicore programming and summarizes three parts: 1) the current state of affairs where Moore's Law is no longer increasing CPU speed due to power and physical limitations, necessitating the shift to multicore processors; 2) multithreaded algorithms including dynamic parallelism, work/span models, and examples like matrix multiplication; 3) .NET's Task Parallel Library which provides primitives for data and task parallelism including collections, tasks, and thread pools.

Spark Streaming with Cassandra

Jacek Lewandowski

Spark streaming can be used for near-real-time data analysis of data streams. It processes data in micro-batches and provides windowing operations. Stateful operations like updateStateByKey allow tracking state across batches. Data can be obtained from sources like Kafka, Flume, HDFS and processed using transformations before being saved to destinations like Cassandra. Fault tolerance is provided by replicating batches, but some data may be lost depending on how receivers collect data.

Spca2014 advanced share point troubleshooting hessing

NCCOMMS

This document provides an overview of advanced SharePoint troubleshooting techniques presented by Donald Hessing, a principal consultant and Microsoft Certified Master in SharePoint. It discusses tools and techniques for investigating performance issues such as Fiddler, LogParser, and analyzing IIS logs, Windows event logs, and performance counters on SharePoint servers and SQL servers. It also provides guidance on validating server hardware configurations including disks, network bandwidth, and virtualization settings.

Flink Forward Berlin 2017: Robert Metzger - Keep it going - How to reliably a...

Flink Forward

Let’s be honest: Running a distributed stateful stream processor that is able to handle terabytes of state and tens of gigabytes of data per second while being highly available and correct (in an exactly-once sense) does not work without any planning, configuration and monitoring. While the Flink developer community tries to make everything as simple as possible, it is still important to be aware of all the requirements and implications In this talk, we will provide some insights into the greatest operations mysteries of Flink from a high-level perspective: - Capacity and resource planning: Understand the theoretical limits. - Memory and CPU configuration: Distribute resources according to your needs. - Setting up High Availability: Planning for failures. - Checkpointing and State Backends: Ensure correctness and fast recovery For each of the listed topics, we will introduce the concepts of Flink and provide some best practices we have learned over the past years supporting Flink users in production.

Evolution of deployment tooling @ Chronosphere - CraftConf 2023

Mary Fesenko

Yufeng Guo - Tensor Processing Units: how TPUs enable the next generation of ...

Codemotion

4th European Lisp Symposium: Jobim: an Actors Library for the Clojure Program...

Antonio Garrote Hernández

This document introduces Jobim, an actor library for Clojure that enables building distributed, concurrent applications. It describes actors as named channels that receive and send messages. Jobim provides protocols for messaging, coordination, and serialization that can be extended with plugins. It also includes behaviors like supervisor, server, and finite state machine patterns to help reuse distributed logic. The library aims to integrate well with Clojure while providing solutions for distribution challenges like coordination and serialization.

Optimizing Terascale Machine Learning Pipelines with Keystone ML

Spark Summit

The document describes KeystoneML, an open source software framework for building scalable machine learning pipelines on Apache Spark. It discusses standard machine learning pipelines and examples of more complex pipelines for image classification, text classification, and recommender systems. It covers features of KeystoneML like transformers, estimators, and chaining estimators and transformers. It also discusses optimizing pipelines by choosing solvers, caching intermediate data, and operator selection. Benchmark results show KeystoneML achieves state-of-the-art accuracy on large datasets faster than other systems through end-to-end pipeline optimizations.

Tales of Linux micro-benchmarks

Matt Fleming

The document discusses Linux micro-benchmarks, which measure small portions of a system's performance rather than modeling a real workload. While micro-benchmarks can be misused, they are valid when used correctly to understand bottlenecks by profiling workloads. Several case studies are presented, showing how micro-benchmarks can reveal unexpected behaviors when systems calls are measured, such as a benchmark that actually measured page faults in addition to forks. Micro-benchmarks are most useful when profiling to identify bottlenecks, when they are kept very simple, and when they have been thoroughly tested.

Our Puppet Story – Patterns and Learnings (sage@guug, March 2014)

DECK36

Workshop: Identifying concept inventories in agile programming

Threads, Critical Sections, and Termination

Recommended

Recommended

More Related Content

Similar to Threads, Critical Sections, and Termination

Similar to Threads, Critical Sections, and Termination (20)

More from ESUG

More from ESUG (20)

Recently uploaded

Recently uploaded (20)

Threads, Critical Sections, and Termination