This work presents the evaluation of the two classic workstealing algorithms (FIFO and LIFO) together with a new proposed implementation based on the priority of tasks calculated using the longest path as a metric
Kernel Recipes 2018 - A year of fixing Coverity issues all over the Linux ker...Anne Nicolas
Coverity is a static analyzer that scans the kernel code and reports issues that can hide coding mistakes and vulnerabilities. Currently, it reports around 5,000 outstanding defects in the Linux kernel. I’m dedicated to fixing those defects and, this talk is a status report of the work I have been doing over the course of a year. Lessons learned, as well as the most common types of issues reported, will also be presented.
Kernel Recipes 2018 - Live (Kernel) Patching: status quo and status futurus -...Anne Nicolas
The purpose of this talk is to provide a short overview of the current live patching facility inside the linux kernel (with a brief history excursion), describe the features it currently provides, and most importantly things that still need to be implemented / designed.
like our page for more updates:
https://www.facebook.com/Technogroovyindia
With Best Regard's
Technogroovy Systems India Pvt. Ltd.
www.technogroovy.com
Call- +91-9582888121
Whatsapp- +91-8800718323
Imagine you're tackling one of these evasive performance issues in the field, and your go-to monitoring checklist doesn't seem to cut it. There are plenty of suspects, but they are moving around rapidly and you need more logs, more data, more in-depth information to make a diagnosis. Maybe you've heard about DTrace, or even used it, and are yearning for a similar toolkit, which can plug dynamic tracing into a system that wasn't prepared or instrumented in any way.
Hopefully, you won't have to yearn for a lot longer. eBPF (extended Berkeley Packet Filters) is a kernel technology that enables a plethora of diagnostic scenarios by introducing dynamic, safe, low-overhead, efficient programs that run in the context of your live kernel. Sure, BPF programs can attach to sockets; but more interestingly, they can attach to kprobes and uprobes, static kernel tracepoints, and even user-mode static probes. And modern BPF programs have access to a wide set of instructions and data structures, which means you can collect valuable information and analyze it on-the-fly, without spilling it to huge files and reading them from user space.
In this talk, we will introduce BCC, the BPF Compiler Collection, which is an open set of tools and libraries for dynamic tracing on Linux. Some tools are easy and ready to use, such as execsnoop, fileslower, and memleak. Other tools such as trace and argdist require more sophistication and can be used as a Swiss Army knife for a variety of scenarios. We will spend most of the time demonstrating the power of modern dynamic tracing -- from memory leaks to static probes in Ruby, Node, and Java programs, from slow file I/O to monitoring network traffic. Finally, we will discuss building our own tools using the Python and Lua bindings to BCC, and its LLVM backend.
Kernel Recipes 2018 - A year of fixing Coverity issues all over the Linux ker...Anne Nicolas
Coverity is a static analyzer that scans the kernel code and reports issues that can hide coding mistakes and vulnerabilities. Currently, it reports around 5,000 outstanding defects in the Linux kernel. I’m dedicated to fixing those defects and, this talk is a status report of the work I have been doing over the course of a year. Lessons learned, as well as the most common types of issues reported, will also be presented.
Kernel Recipes 2018 - Live (Kernel) Patching: status quo and status futurus -...Anne Nicolas
The purpose of this talk is to provide a short overview of the current live patching facility inside the linux kernel (with a brief history excursion), describe the features it currently provides, and most importantly things that still need to be implemented / designed.
like our page for more updates:
https://www.facebook.com/Technogroovyindia
With Best Regard's
Technogroovy Systems India Pvt. Ltd.
www.technogroovy.com
Call- +91-9582888121
Whatsapp- +91-8800718323
Imagine you're tackling one of these evasive performance issues in the field, and your go-to monitoring checklist doesn't seem to cut it. There are plenty of suspects, but they are moving around rapidly and you need more logs, more data, more in-depth information to make a diagnosis. Maybe you've heard about DTrace, or even used it, and are yearning for a similar toolkit, which can plug dynamic tracing into a system that wasn't prepared or instrumented in any way.
Hopefully, you won't have to yearn for a lot longer. eBPF (extended Berkeley Packet Filters) is a kernel technology that enables a plethora of diagnostic scenarios by introducing dynamic, safe, low-overhead, efficient programs that run in the context of your live kernel. Sure, BPF programs can attach to sockets; but more interestingly, they can attach to kprobes and uprobes, static kernel tracepoints, and even user-mode static probes. And modern BPF programs have access to a wide set of instructions and data structures, which means you can collect valuable information and analyze it on-the-fly, without spilling it to huge files and reading them from user space.
In this talk, we will introduce BCC, the BPF Compiler Collection, which is an open set of tools and libraries for dynamic tracing on Linux. Some tools are easy and ready to use, such as execsnoop, fileslower, and memleak. Other tools such as trace and argdist require more sophistication and can be used as a Swiss Army knife for a variety of scenarios. We will spend most of the time demonstrating the power of modern dynamic tracing -- from memory leaks to static probes in Ruby, Node, and Java programs, from slow file I/O to monitoring network traffic. Finally, we will discuss building our own tools using the Python and Lua bindings to BCC, and its LLVM backend.
BKK16-503 Undefined Behavior and Compiler Optimizations – Why Your Program St...Linaro
Compilers such as GCC may use undefined behaviour in language specifications to generate efficient code (especially newer recent versions). The rules for undefined behaviour can be subtle and programming mistakes can lead to correctness and/or security issues. This presentation will examine issues resulting from undefined behavior in applications. It will also discuss the position of the relevant language standards and address what compilers can do to exploit the standard in order to generate optimized code. We will also look at tools that can help us in detecting undefined behaviours so that these correctness issues can be prevented.
This talk is all about the Berkeley Packet Filters (BPF) and their uses in Linux.
Agenda:
* What is a BPF and why do we need it?
* Writing custom BPFs
* Notes on BPF implementation in the kernel
* Usage examples: SOCKET_FILTER & seccomp
Speaker:
Kfir Gollan, senior embedded software developer, Linux kernel hacker and software team leader.
NYAN Conference: Debugging asynchronous scenarios in .netAlexandra Hayere
Times have changed. Multi-core CPUs have become the norm and multi-threading has been replaced by asynchronous programming. You think you know everything about async/await... until something goes wrong. While debugging synchronous code can be straightforward, investigating an asynchronous deadlock or race condition proves to be surprisingly tricky.
In this talk, follow us through real-life examples and investigations to cover the main asynchronous code patterns that can go wrong. You will tumble on deadlock and understand the reasons behind ThreadPool thread starvation.
In addition to WinDbg magic to follow async/await chains, Visual Studio goodies won't be forgotten to quickly analyze hundreds of call stacks or tasks status.
“p4alu” is a P4 program who would parse UDP packet with payload in "p4alu header format" and apply calculation.
This program is tested using BMv2 simple_switch P4 target.
Specializing the Data Path - Hooking into the Linux Network StackKernel TLV
Ever needed to add your custom logic into the network stack?
Ever hacked the network stack but wasn't certain you're doing it right?
Shmulik Ladkani talks about various mechanisms for customizing packet processing logic to the network stack's data path.
He covers covering topics such as packet sockets, netfilter hooks, traffic control actions and ebpf. We will discuss their applicable use-cases, advantages and disadvantages.
Shmulik Ladkani is a Tech Lead at Ravello Systems.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
51966 coffees and billions of forwarded packets later, with millions of homes running his software, Shmulik left his position as Jungo’s lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud service. He's now focused around virtualization systems, network virtualization and SDN.
Andrea Righi - Spying on the Linux kernel for fun and profitlinuxlab_conf
Do you ever wonder what the kernel is doing while your code is running? This talk will explore some methodologies and techniques (eBPF, ftrace, etc.) to look under the hood of the Linux kernel and understand what it’s actually doing behind the scenes.
This talk explores methodologies that allow to take a look “live” at kernel internal operations, from a network perspective, to I/O paths, CPU usage, memory allocations, etc., using in-kernel technologies, like eBPF and ftrace. Understanding such kernel internals can be really helpful to track down performance bottlenecks, debug system failures and it can be also a very effective way to approach to kernel development.
Description of the status of design and developing activities of the data analysis software of SuperAGILE instrument of the AGILE Space Mission, one year before the launch.
BKK16-302: Android Optimizing Compiler: New Member Assimilation GuideLinaro
A tour of essential topics for working on the Android Optimizing Compiler, with a special emphasis on helping new engineers integrate and hit the ground running. Learn how to work on intrinsics, instruction simplification, platform specific optimizations, how to submit good patches, write Checker tests, analyse IR, take boot.oat measurements, and debug performance and execution issues with Streamline and GDB.
Using Kafka in your python application - Python fwdays 2020Oleksandr Tarasenko
To date, Kafka is one of the most in-demand products in large distributed systems and projects. In my talk, I would like to present a few real cases of using the stack of the python and Kafka that helped us get things done. Also, I am to reveal problems occurred while integrating the new tool.
Oleksandr Tarasenko
Python fwdays 2020
Oleksandr Tarasenko "Using Kafka in your python applications"Fwdays
To date, Kafka is one of the most in-demand products in large distributed systems and projects. In my talk, I would like to present a few real cases of using the stack of the python and Kafka that helped us get things done. Also, I am to reveal problems that occurred while integrating the new tool.
BKK16-503 Undefined Behavior and Compiler Optimizations – Why Your Program St...Linaro
Compilers such as GCC may use undefined behaviour in language specifications to generate efficient code (especially newer recent versions). The rules for undefined behaviour can be subtle and programming mistakes can lead to correctness and/or security issues. This presentation will examine issues resulting from undefined behavior in applications. It will also discuss the position of the relevant language standards and address what compilers can do to exploit the standard in order to generate optimized code. We will also look at tools that can help us in detecting undefined behaviours so that these correctness issues can be prevented.
This talk is all about the Berkeley Packet Filters (BPF) and their uses in Linux.
Agenda:
* What is a BPF and why do we need it?
* Writing custom BPFs
* Notes on BPF implementation in the kernel
* Usage examples: SOCKET_FILTER & seccomp
Speaker:
Kfir Gollan, senior embedded software developer, Linux kernel hacker and software team leader.
NYAN Conference: Debugging asynchronous scenarios in .netAlexandra Hayere
Times have changed. Multi-core CPUs have become the norm and multi-threading has been replaced by asynchronous programming. You think you know everything about async/await... until something goes wrong. While debugging synchronous code can be straightforward, investigating an asynchronous deadlock or race condition proves to be surprisingly tricky.
In this talk, follow us through real-life examples and investigations to cover the main asynchronous code patterns that can go wrong. You will tumble on deadlock and understand the reasons behind ThreadPool thread starvation.
In addition to WinDbg magic to follow async/await chains, Visual Studio goodies won't be forgotten to quickly analyze hundreds of call stacks or tasks status.
“p4alu” is a P4 program who would parse UDP packet with payload in "p4alu header format" and apply calculation.
This program is tested using BMv2 simple_switch P4 target.
Specializing the Data Path - Hooking into the Linux Network StackKernel TLV
Ever needed to add your custom logic into the network stack?
Ever hacked the network stack but wasn't certain you're doing it right?
Shmulik Ladkani talks about various mechanisms for customizing packet processing logic to the network stack's data path.
He covers covering topics such as packet sockets, netfilter hooks, traffic control actions and ebpf. We will discuss their applicable use-cases, advantages and disadvantages.
Shmulik Ladkani is a Tech Lead at Ravello Systems.
Shmulik started his career at Jungo (acquired by NDS/Cisco) implementing residential gateway software, focusing on embedded Linux, Linux kernel, networking and hardware/software integration.
51966 coffees and billions of forwarded packets later, with millions of homes running his software, Shmulik left his position as Jungo’s lead architect and joined Ravello Systems (acquired by Oracle) as tech lead, developing a virtual data center as a cloud service. He's now focused around virtualization systems, network virtualization and SDN.
Andrea Righi - Spying on the Linux kernel for fun and profitlinuxlab_conf
Do you ever wonder what the kernel is doing while your code is running? This talk will explore some methodologies and techniques (eBPF, ftrace, etc.) to look under the hood of the Linux kernel and understand what it’s actually doing behind the scenes.
This talk explores methodologies that allow to take a look “live” at kernel internal operations, from a network perspective, to I/O paths, CPU usage, memory allocations, etc., using in-kernel technologies, like eBPF and ftrace. Understanding such kernel internals can be really helpful to track down performance bottlenecks, debug system failures and it can be also a very effective way to approach to kernel development.
Description of the status of design and developing activities of the data analysis software of SuperAGILE instrument of the AGILE Space Mission, one year before the launch.
BKK16-302: Android Optimizing Compiler: New Member Assimilation GuideLinaro
A tour of essential topics for working on the Android Optimizing Compiler, with a special emphasis on helping new engineers integrate and hit the ground running. Learn how to work on intrinsics, instruction simplification, platform specific optimizations, how to submit good patches, write Checker tests, analyse IR, take boot.oat measurements, and debug performance and execution issues with Streamline and GDB.
Using Kafka in your python application - Python fwdays 2020Oleksandr Tarasenko
To date, Kafka is one of the most in-demand products in large distributed systems and projects. In my talk, I would like to present a few real cases of using the stack of the python and Kafka that helped us get things done. Also, I am to reveal problems occurred while integrating the new tool.
Oleksandr Tarasenko
Python fwdays 2020
Oleksandr Tarasenko "Using Kafka in your python applications"Fwdays
To date, Kafka is one of the most in-demand products in large distributed systems and projects. In my talk, I would like to present a few real cases of using the stack of the python and Kafka that helped us get things done. Also, I am to reveal problems that occurred while integrating the new tool.
LinuxLabs 2017 talk: Container monitoring challengesXavier Vello
A technical talk about some challenges we had to solve with our containerized agent:
- handling memory limits
- retrieving host network metrics
- enabling easier discovery via unix domain sockets
- securing our access to the Docker socket
Braxton McKee, Founder & CEO, Ufora at MLconf SF - 11/13/15MLconf
Is Machine Learning Code for 100 Rows or a Billion the Same?: We have built an automatically distributed, implicitly parallel data science platform for running large scale machine learning applications. By abstracting away the computer science required to scale machine learning models, The Ufora platform lets data scientists focus on building data science models in simple scripting code, without having to worry about building large-scale distributed systems, their race conditions, fault-tolerance, etc. This automatic approach requires solving some interesting challenges, like optimal data layout for different ML models. For example, when a data scientist says “do a linear regression on this 100GB dataset”, Ufora needs to figure out how to automatically distribute and lay out that data across a cluster of machines in the cluster in order to minimize travel over the wire. Running a GBM against the same dataset might require a completely different layout of that data. This talk will cover how the platform works, in terms of data and thread distribution, how it generates parallel processes out of single-threaded programs, and more.
Apache Flink(tm) - A Next-Generation Stream ProcessorAljoscha Krettek
In diesem Vortrag wird es zunächst einen kurzen Überblick über den aktuellen Stand im Bereich der Streaming-Datenanalyse geben. Danach wird es mit einer kleinen Einführung in das Apache-Flink-System zur Echtzeit-Datenanalyse weitergehen, bevor wir tiefer in einige der interessanten Eigenschaften eintauchen werden, die Flink von den anderen Spielern in diesem Bereich unterscheidet. Dazu werden wir beispielhafte Anwendungsfälle betrachten, die entweder direkt von Nutzern stammen oder auf unserer Erfahrung mit Nutzern basieren. Spezielle Eigenschaften, die wir betrachten werden, sind beispielsweise die Unterstützung für die Zerlegung von Events in einzelnen Sessions basierend auf der Zeit, zu der ein Ereignis passierte (event-time), Bestimmung von Zeitpunkten zum jeweiligen Speichern des Zustands eines Streaming-Programms für spätere Neustarts, die effiziente Abwicklung bei sehr großen zustandsorientierten Streaming-Berechnungen und die Zugänglichkeit des Zustandes von außerhalb.
Serverless on OpenStack with Docker Swarm, Mistral, and StackStormDmitri Zimine
Intro to Serverless, 101 demo with StackStorm, and real world application of serverless solution.
Slides for OpenStack Summit Boston 2017 talk:
https://www.openstack.org/summit/boston-2017/summit-schedule/events/18325
Most of the talk was a demo, please stay tuned for recording.
Serverless, devops, automation, operations, faas, @Stack_Storm.
Docker on a local machine and Docker in production — are two big differences. It's easy to play with technology but it's hard to do something real for many customers.
Half a year ago inside of AlfaLab (division of Alfa-Bank) we've started building architecture with microservices approach for few our pilot projects. We've almost completely changed a stack of the used technologies on a frontend and significantly changed it on a middle layer. For package and distribution we have choosen Docker. Two months ago we've deployed project to production and have opened service for clients.
In the report the following topics will be covered:
- reasons of a choice Docker;
- why Docker without other tools is not enough for a production;
- what stack of technologies we used in our solution;
- what advantages we've got;
- what problems have been faced and how we've solved them.
Automating with NX-OS: Let's Get Started!Cisco DevNet
A session in the DevNet Zone at Cisco Live, Berlin. Cisco's flagship data center platform, the Nexus series of switches, has a variety of programming protocols to offer. This session will provide participants with an overview and code examples on various protocols: * NX-API * XMPP * Netconf
When creating iOS apps with RubyMotion, a good working knowledge of Objective-C and the iOS/OSX APIs is still required in order to build production-ready apps. In this presentation we take a look at some external libraries however that aim to bridge the gap, making app development more accessible to Ruby developers and much faster/easier for everyone, irrespective of past development experience.
XCon 2014 => http://xcon.xfocus.org/
In the past was quite common to exploit heap / pool manager vulnerabilities attacking its internal linked structures. However current memory management improve a lot and at current date it is quite ineffective to attack heap in this way. But still those techniques come into hand when we start to looking at linked structures widespread throughout kernel that are unfortunately not hardened enough.
In this presentation we will examine power of these vulnerabilities by famous example “CVE – 2013 - 3660”. Showing bypass on ‘lazy’ assertions of _LIST_ENTRY, present exploitation after party and teleport to kernel.
An expressive and modular layer activation mechanism for Context-Oriented Pro...Universidad de los Andes
Abstract: Context. There is a trend in the software industry towards building systems that dynamically adapt their behavior in response to their surrounding environment, given the proliferation of various technological devices, such as notebooks, smartphones, and wearables, capable of capturing their execution context. Context-oriented Programming (COP) allows developers to use layer abstractions to adapt software behavior to the context. A layer is associated with a context and can be dynamically activated in direct response to gathered information from its surrounding execution environment. However, most existing layer activation mechanisms have been tailored specifically to address a particular concern; implying that developers need to tweak layer definitions in contortive ways or create new specialized activation mechanisms altogether if their specific needs are not supported. Objective. Complementing ideas to expressively declare activation mechanism models with interfaces that define conditionals of activation mechanisms modularly, this paper proposes an Expressive and Modular Activation mechanism, named EMA. Method. To propose EMA, we analyze existing activation mechanisms in COP regarding activation features and scope strategies. After, we propose the design of EMA and validate it with a case study discussion. Results. Using a concrete JavaScript implementation of EMA, named EMAjs, we can implement two Web applications: a smartphone application as an example to illustrate EMAjs in action, and an application of home automation to discuss and compare our proposal. Conclusion. Our proposed mechanism allows developers to instantiate different activation scope strategies and interfaces to decouple the declaration of activation mechanism conditionals from the base code.
Paper presentation: https://youtu.be/76RgVB6JihQ?si=-uylVc4Xnqnh4zbl
Paper presented at the 2023 Formal Techniques for Java-like Programs.
Abstract: Static analyses, as points-to analysis, are useful to determine and assure different properties about a program, such as security or type safety. While existing analyses are effective in programs restricted to static features, precision declines in the presence of dynamic language features, and even further when the system behavior changes dynamically. As a consequence, improved points-to sets algorithms taking into account such language features and uses are required. In this paper, we present and extension of the point-to sets analysis to incorporate the language abstractions introduced by context-oriented programming adding the capability for programs to adapt their behavior dynamically to the system’s execution context. To do this, we extend WALA to detect the context-oriented language abstractions, and their representation within the system, to capture the dynamic behavior, in the particular case of the Context Traits JavaScript language extension. To prove the effectiveness of our extension, we evaluate the precision of the points-to set analysis with respect to the state of the art, over four context-oriented programs taken from the literature.
[JIST] Programming language implementations for context-oriented self-adaptiv...Universidad de los Andes
Context
The context-oriented programming paradigm is designed to enable self-adaptation, or dynamic behavior modification of software systems, in response to changes in their surrounding environment. Contextoriented programming offers an adaptation model, from a programming language perspective, that maintains a clean modularisation between the application and adaptation logic, as well as between the components providing adaptations.
Objective
We use three implementation techniques for context-oriented programming languages to assess their appropriateness to foster self-adaptive systems. These approaches take advantage of the capabilities offered by the host programming language to realize self-adaptation as proposed by context-oriented languages.
Method
We evaluate each of these approaches by assessing their modularity and complexity when defining adaptations, and by comparing their run-time performance on a simple benchmark.
Results
Our results show a higher modularity than that for common architecture based self-adaptive systems, while maintaining comparable performance.
Conclusion
We conclude that context-oriented programming is an appropriate paradigm to realize self-adaptation.
Link to the paper: https://doi.org/10.1016/j.infsof.2021.106789
Reinforcement Learning (RL) is being increasingly used to learn and adapt application behavior in many domains, including large-scale and safety critical systems, as for example, autonomous driving. With the advent of plug-n-play RL libraries, its applicability has further increased, enabling integration of RL algorithms by users. We note, however, that the majority of such code is not developed by RL engineers, which as a consequence, may lead to poor program quality yielding bugs, suboptimal performance, maintainability, and evolution problems for RL-based projects. In this paper we begin the exploration of this hypothesis, specific to code utilizing RL, analyzing different projects found in the wild, to assess their quality from a software engineering perspective. Our study includes 24 popular RL-based Python projects, analyzed with standard software engineering metrics. Our results, aligned with similar analyses for ML code in general, show that popular and widely reused RL repositories contain many code smells (3.95% of the code base on average), significantly affecting the projects’ maintainability. The most common code smells detected are long method and long method chain, highlighting problems in the definition and interaction of agents. Detected code smells suggest problems in responsibility separation, and the appropriateness of current abstractions for the definition of RL algorithms.
paper preprint: https://arxiv.org/abs/2303.10236
Clon detection provides insight about replicated fragments in a code base. With the rise of multi-language code bases, new techniques addressing cross-language code clone detection enable the analysis of polyglot systems. Such techniques have not yet been applied to the mobile apps’ domain, which are naturally polyglot. Native mobile app developers must synchronize their code base in at least two different programming languages. App synchronization is a difficult and time-consuming maintenance task, as features can rapidly diverge between platforms, and feature identification must be performed manually. Our goal is to provide an analysis framework to reduce the impact of app synchronization. A first step in this direction consists on a structural algorithm for cross-language clone detection exploiting the idea behind enriched concrete syntax trees. Such trees are used as a common intermediate representation built from programming languages’ grammars, to detect similarities between app code bases. Our technique finds code similarities with 79% precision for controlled tests where Type 1-3 clones are manually injected for the analysis of both single- and cross-language cases for Kotlin and Dart. We evaluate our tool on a corpus of 52 mobile apps identifying code similarities with a precision of 65% to 84% for the full application logic.
recorrido sobre las características principales de LaTeX y lagunas librerías útiles para escribir documentos más fácilmente.
Temas tratados:
Estructura de documentos
Paquetes
Elementos básicos (secciones, listas)
Figuras
Tablas
Entornos matemáticos (ecuaciones anotadas https://github.com/synercys/annotated_latex_equations)
Fragmentos de código
Referencias
Acrónimos y comandos
[JPDC,JCC@LMN22] Ad hoc systems Management and specification with distributed...Universidad de los Andes
This presents the main ideas behind Distributed ad hoc Petri nets (DaPNs). A specification and run-time model to manage and reason about ad hoc distributed systems.
The presentation describes the main contributions of our work validated through a case study on vehicular ad hoc distributed networks.
This work is available at the Journal of Parallel and Distributed Computing, and was presented at the Lo Mejor de lo nuestro #LMN2022, at the Jornadas Chilenas de Computación 2022
Link to the paper: https://doi.org/10.1016/j.jpdc.2022.06.015
Generating Adaptations from the System Execution using Reinforcement Learning...Universidad de los Andes
Invited talk to the Context-oriented programming workshop co-located with ECOOP 2021.
This talk describes work in progress on generating adaptation dynamically with respect to the conditions of the system environment using reinforcement learning
Language Abstractions and Techniques for Developing Collective Adaptive Syste...Universidad de los Andes
Presentation at the 5th eCAS Workshop on Engineering Collective Adaptive Systems 2020, colocated with acsos.
Collective Adaptive Systems (CAS) are increasingly used as a model for building and managing large- scale cyber-physical systems, highlighting the need for a flexible approach for their definition and engineering. CAS consist of multiple individual context-aware self-adaptive systems, which need to adapt to their own environment, but also interact with each other, resulting in the global CAS behavior. Interactions can emerge as complementary or conflicting, and needs to be managed to assure a correct global behavior. Context-oriented Programming (COP) is one of the programming paradigms that has risen as a suitable approach to developing self-adaptive systems, due to the natural mapping of its programming constructs to self- adaptive systems taxonomy. Recently, multiple extensions to the COP model have been developed, which manage inter- actions between adaptive components (or systems), enabling its suitability for developing CAS as well. In this paper, we map out the COP language abstractions to the characteristics of CAS, demonstrating COP applicability, its formalization, verification tools, and adaptation composition techniques to foster CAS. Our discussion is illustrated using city-wide bus transport management system, as an example of a CAS.
Does Neuron Coverage Matter for Deep Reinforcement Learning? A preliminary studyUniversidad de los Andes
This work is presented at the 2020 Workshop on Testing for Deep Learning and Deep Learning for Testing (DeepTest) co-located with ICSE held virtually.
This work analyzes the possibility of using neuron coverage as a test adequacy metric for Deep Reinforcement Learning (DeepRL). This work spawns from the positive results in using neuron coverage to test (deep) neural networks. However, testing DeepRL systems, brings its own challenges. In the presentation, and associated paper, we discuss the characteristics of DeepRL that prevent promoting neuron coverage as an adequacy testing metric.
The paper is available at: https://deeptestconf.github.io/pdfs/2020-Trujillo-DeepTest.pdf
This work is presented at the 2020 Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS) co-located with ICSE held virtually.
In this work we present the early results of our ComInA technique to learn the way behavior adaptations interact with each other, and from there, offer the most appropriate composition of adaptations. Our technique uses a combination of Context-oriented programming and reinforcement learning to define and compose fine-grained modular adaptations, and learn their interaction respectively
Talk presented at the 2019 Context-oriented programming workshop colocated with ECOOP in london.
This work presents an extension to Context petri nets (CoPN) to enable the communication between different nodes, each defined using a CoPN. This extension demonstrates the interaction with different context dependency relations in face of unannounced connection and disconnection of nodes.
Talk presented at the 2018 Context-oriented programming workshop colocated with ECOOP in Amsterdam.
This work presents a small query language designed for the activation of context objects in response to information gathered from sensors. The objective of CQL is to enable the possibility to activate multiple contexts simultaneously, using a single query
Talk presented at the 2018 machine learning for programming languages workshop colocated with ECOOP in Amsterdam.
This work presents the use of reinforcement learning for the discovery of context objects to drive behavioral adaptations. Our technique uses information gathered from the systems environment to define context, associating the actions taken by the user in such situations to define and automate behavioral adaptations
Presentation for the bachelor thesis project at Universidad de los Andes 2020-10.
This thesis studies the use parallel programming techniques to speed-up the decomposition phase of the constraint solving problem. The technique is integrated with the Oscar-CP solver, and explores the exam assignment problem
Invited presentation at the university of Coimbra in 2016.
This presentation gives an overview of the programming language implementation effort at FLAGlab applied to dynamic adaptive software systems.
Talk presented at the 2017 Context-oriented programming workshop colocated with ECOOP in barcelona.
This work presents a reinforcement learning based solution to resolve conflicts between dynamic adaptations.
Talk presented at the 2016 Onward! conference colocated with splash in amsterdam.
This work presents a framework for the spontaneous interaction (composition) of service components by learning services APIs. Upon discovery of services with a known API the composition is seamless.
2024.06.01 Introducing a competency framework for languag learning materials ...Sandy Millin
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar Kanvaria
Introduction to AI for Nonprofits with Tapp NetworkTechSoup
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...Levi Shapiro
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
A Survey of Techniques for Maximizing LLM Performance.pptx
[CCC'21] Evaluation of Work Stealing Algorithms
1. Juan Sebastián Numpaque - Nicolás Cardozo
@ncardoz
{js.numpaque10, n.cardozo}@uniandes.edu.co
CCC’21 - 15 Congreso Colombiano de Computación- 22 al 26 de noviembre - (Virtual)
Evaluation of Work Stealing Algorithms
4. v3 v2 v1
3
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
v7
v6
v5
v9 v10
v8
v12
v11
v4
v3
v2
v1 v13 v14
v15
P3
P2
P1 P4
Idle processors steal tasks from processors with tasks in their queue
5. v3 v2 v1
3
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
v7
v6
v5
v9 v10
v8
v12
v11
v4
v3
v2
v1 v13 v14
v15
P3
P2
P1 P4
Idle processors steal tasks from processors with tasks in their queue
v3
6. v3 v2 v1
3
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
v7
v6
v5
v9 v10
v8
v12
v11
v4
v3
v2
v1 v13 v14
v15
P3
P2
P1 P4
Idle processors steal tasks from processors with tasks in their queue
v3 v2
7. 4
Work stealing
Work stealing presents an improvement with respect to dynamic
scheduling with respect to:
Automated work balancing
Better Portability
Scalability to the number of processors
9. 6
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
V2
V3
V4
V5
Queue P1 Queue P2 Queue P3 Queue P4
P1 P2 P3 P4
V1
head
10. 6
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
V3
V4
V5
Queue P1 Queue P2 Queue P3 Queue P4
P1 P2 P3 P4
V1 V2
head
11. 6
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
V5
Queue P1 Queue P2 Queue P3 Queue P4
P1 P2 P3 P4
V1 V2
V3
V4
head
12. 6
Work stealing
[Blumofe et al. Scheduling multithreaded computations by workstealing. 1995]
V5
Queue P1 Queue P2 Queue P3 Queue P4
P1 P2 P3 P4
V1 V2
V3
V4
head
LIFO FIFO
13. 7
Work stealing algorithms
LIFO
FIFO
• A tasks’s children are enqueued at the back of the queue in the
processor that executed the parent task
• If the processor is idle, it takes the task at the queue’s head
• Tasks are stolen from another processor’s queue head
• A tasks’s children are enqueued at the head of the queue in the
processor that executed the parent task
• If the processor is idle, it takes the task at the queue’s head
• Tasks are stolen from the back of another processor’s queue
19. 9
Priority-based work stealing
Tasks further away from the end node (v14) should take priority
over tasks closer towards the end of the computation
• A tasks’s children are enqueued at the back of the queue ordered
by priority
• If the processor is idle, it takes the task at the queue’s head
• Tasks are stolen from another processor’s queue head
v7
v6
v5
v9 v10
v8
v12
v11
v4
v3
v2
v1 v13 v14
v15
20. • Performance of the algorithm depends on the
way tasks are chosen (avoid possible
bottlenecks!)
• Classic algorithms are not fare
21. 11
Evaluation
We evaluate the performance and fairness of existing work
stealing algorithms and our proposed approach
1. Generate a random computation DAGs
graph nodes variate in [50, 1600]
graph edges variate in density {0.2, 0.5, 0.8}
2.Scale the number of processors in the execution [1, 96]
3.Execute all the tasks in the DAG using each algorithm
22. 12
Performance results
https://flaglab.github.io/WorkStealingAlgorithms/
Execution
time
in
ms
0
15
30
45
60
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
1
2
3
4
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
3
7
10
13
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
18
35
53
70
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
8 processors
96 processors
32 processors
density = 0.2
23. 13
Performance results
https://flaglab.github.io/WorkStealingAlgorithms/
Execution
time
in
ms
0
13
25
38
50
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
2
3
5
6
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
3
7
10
13
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
30
60
90
120
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
8 processors
96 processors
32 processors
density = 0.5
24. 14
Performance results
https://flaglab.github.io/WorkStealingAlgorithms/
8 processors
96 processors
32 processors
Execution
time
in
ms
0
13
25
38
50
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
2
5
7
9
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
20
40
60
80
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
Execution
time
in
ms
0
225
450
675
900
No. of DAG nodes
50 100 200 400 800 1600
PRIO FIFO LIFO
density = 0.8
27. • FIFO falls short in the in both performance and
balance at scale
• LIFO scales better that other algorithms
• Priority has a good performance but it can
decay rapidly with many nodes, however it
presents the best balance
@ncardoz n.cardozo@uniandes.edu.co
Conclusion
https://flaglab.github.io
28. • FIFO falls short in the in both performance and
balance at scale
• LIFO scales better that other algorithms
• Priority has a good performance but it can
decay rapidly with many nodes, however it
presents the best balance
@ncardoz n.cardozo@uniandes.edu.co
Questions?
Conclusion
https://flaglab.github.io