Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Software Performance Engineering and Multicore Programming
Rating: 1.0 out of 5(1 rating)
33 students

Software Performance Engineering and Multicore Programming

Deep-dive into Performance Engineering & Multicore Computing. Learn about cache management, virtual machines, hypervisor
Created byUplatz Training
Last updated 9/2025
English

What you'll learn

  • Define Software Performance Engineering
  • Learn Multicore Computing & Multicore Programming
  • Understand Parallelization and Cache Complexity
  • Take a deep-dive into Memory Hierarchy Optimization
  • Understand Virtual Machines and how they work
  • Learn Hypervisor Architecture
  • Define Montgomery's Trick and its application

Course content

22 sections26 lectures11h 3m total length
  • Software Performance Engineering28:10

    Explore software performance engineering for multicore systems, covering cache hierarchies, memory access patterns, immutability vs mutability, and performance optimization techniques from profiling to compiler optimizations.

Requirements

  • Enthusiasm and determination to make your mark on the world!

Description

A warm welcome to the Software Performance Engineering and Multicore Programming course by Uplatz.


Software Performance Engineering (SPE) is a systematic approach to designing, analyzing, and optimizing software systems to meet performance objectives such as speed, scalability, and responsiveness. It ensures that software applications perform efficiently under various workloads. It is a systematic, quantitative approach to the cost-effective development of software systems to meet performance requirements. SPE is a software-oriented approach that focuses on architecture, design, and implementation choices. SPE gives you the information you need to build software that meets performance requirements on time and within budget.

SPE uses quantitative analysis techniques to predict and evaluate performance implications of design and implementation decisions. The process begins early in the software lifecycle and uses quantitative methods to identify satisfactory combinations of requirements and designs, and to eliminate those that are likely to have unacceptable performance, before developers begin implementation. SPE continues through the detailed design, coding, and testing stages to predict and manage the performance of the evolving software, and to monitor and report actual performance against specifications and predictions. SPE methods cover performance data collection, quantitative analysis techniques, prediction strategies, management of uncertainties, data presentation and tracking, model verification and validation, critical success factors, and performance design principles.

SPE provides an engineering approach to performance, eliminating the issues of performance-driven development and fix-it-later. SPE uses model predictions to evaluate trade-offs in software functions versus hardware costs. The models assist developers in controlling resource requirements by selecting architecture and design alternatives with acceptable performance characteristics. They aid in tracking performance throughout the development process and prevent problems from surfacing late in the life cycle (typically during performance and stress testing).


Key Aspects of SPE


  1. Performance Modeling – Predicting system behavior using analytical models.

  2. Capacity Planning – Ensuring the software can handle expected workloads.

  3. Load & Stress Testing – Evaluating system performance under heavy usage.

  4. Code Optimization – Improving algorithms and resource utilization.

  5. Profiling & Monitoring – Identifying performance bottlenecks.

  6. Scalability Analysis – Ensuring the system can handle increasing demands.

  7. Concurrency & Parallelism – Optimizing execution for multi-threaded environments.


Tools Used in SPE

  • Load Testing - JMeter, LoadRunner, Gatling

  • Profiling - New Relic, Dynatrace, YourKit

  • Monitoring - Prometheus, Grafana, AWS CloudWatch

  • Code Optimization - Intel VTune, Perf, Flamegraphs


Multicore Programming refers to the approach of creating concurrent systems for deployment on multicore processor and multiprocessor systems. A multicore processor system is a single processor with multiple execution cores in one chip. By contrast, a multiprocessor system has multiple processors on the motherboard or chip. Multicore programming involves writing software that takes advantage of multiple CPU cores to execute tasks in parallel. Instead of sequential execution, it splits workloads across multiple threads or processes to enhance performance.

Multicore programming focuses on the following key elements:


Key Concepts in Multicore Programming

  1. Threading & Concurrency – Using multiple threads to execute tasks simultaneously.

  2. Parallelism – Breaking down computations into independent subtasks.

  3. Synchronization – Managing access to shared resources to avoid race conditions.

  4. Load Balancing – Distributing tasks efficiently among cores.

  5. Lock-Free & Wait-Free Programming – Avoiding bottlenecks due to locks.

Programming Models for Multicore

  • Thread-Based - POSIX Threads (pthreads), Java Threads, C++ std::thread

  • Task-Based - OpenMP, Intel TBB

  • Message Passing - MPI (Message Passing Interface)

  • GPU Programming - CUDA, OpenCL

Multicore Performance Optimization Techniques

  • Data Locality – Optimizing cache usage to reduce memory latency.

  • Thread Affinity – Binding threads to specific cores for efficient execution.

  • Lock-Free Algorithms – Using atomic operations to avoid contention.

  • Efficient Synchronization – Using spinlocks, read-write locks, or transactional memory.


Software Performance Engineering and Multicore Programming - Course Curriculum


  1. Software Performance Engineering

  2. Introduction to Multicore Programming

  3. Multithreaded parallelism and Performance Measures

  4. Analysis of Multithreaded Algorithms

  5. Issues in Parallelization

  6. Synchronizing without locks and concurrent data structures

  7. Cache Complexity

  8. Montgomery Trick

  9. Space Vs Time Cache Vs Memory

  10. Experience in coding high performance numeric libraries

  11. FFT Based Polynomial Arithmetic on Multicore

  12. Parallel Programming for Many high-performance Architectures

  13. Memory Hierarchy Optimization-I

  14. Memory Hierarchy Optimization-II

  15. Writing Correct Programs

  16. Floating Point

  17. Applications

  18. Dynamic Scheduling Sorting

  19. Virtual Machines

  20. Hypervisor

  21. Multicore Computing

  22. Multicore Programming-I

  23. Multicore Programming-II

  24. Multicore Programming-III

  25. Multicore Programming-IV

  26. Multicore Programming-V

Who this course is for:

  • System Performance Engineers
  • Software Engineers
  • Newbies & Beginners in the field of Performance Engineering
  • Anyone aspiring for a career in Software and Performance Engineering
  • System Engineers & Analysts
  • System Administrators
  • Cloud Architects & Engineers
  • Senior Software Performance Analysis Engineers
  • Performance Engineers
  • Software Testers
  • Embedded Engineers
  • Safety Performance Engineers
  • Quality Assurance Leads
  • Operational Performance Engineers
  • Electronics & Communication Engineers
  • Software Developers & Programmers