Ideal For: This training is targeted primarily at software professionals - tech leads, system programmers / developers, maintainers and testers - who would like to delve much deeper into the internal functioning of the Linux operating system.

Post course benefits: Lifetime access to online repository, Mock interview support, project support

Recruitment support: eAgeIT will propose candidates of this program for any open opportunities with its client portfolio. We do not guarantee placement. This will be purely merit based support.

• Good working knowledge of and experience programming using the 'C'
  
• Successfully attended the "LINUX Fundamentals for Software Developers" training program -or-have the equivalent knowledge / skill
  
• Successfully attended the "Advanced LINUX Programming" training program -or-have the equivalent knowledge / skill Implies knowledge / skill sets of: POSIX library and system call API set, process management, IPC mechanisms, etc.
  
• Extensive user-space development experience on a POSIX
  

Course Content

• Linux OS : Fundamental Prerequisites
• OS Architecture
• Processor Protection Levels
• Architecture Layers
• Monolithic / Microkernel / Hybrid OS Architectures
• Tracking Linux kernel changes.
• Practical Guide to Writing Kernel Code with LKMs
• Introduction to Loadable Kernel Modules (LKMs)
• Setting up your Test System
• The Hello World Module
• Compiling, the Makefile, Insertion and Removal
• Lab Assignment.
• Passing Parameters
• Kernel API and ABI.
• Lab Assignment.
• Kernel Architecture and the Process Descriptor
• Timer Interrupt and the Tick Rate (HZ)
• Kernel Architecture in Brief
• Kernel Mapping of Processes and Threads
• Multiple Stacks
• Process Descriptor
• Task List
• Accessing the current task with 'current'
• The task_struct.
• Lab Assignments.
• Linux Memory Management - Essentials
• Introduction
• What is VM; Hardware Paging
• Linux VM Architecture
• (n-Level) Arch-independent Paging on Linux
• 64-bit VM Layout
• Memory (De)Allocation API
• GFP flags and action modifiers
• vmalloc
• Slab Cache API interfaces
• Which API to Use When
• Lab Assignments
• Test the kmalloc limits
• Verify the internal fragmentation (wastage).
• Kernel Segment: Kernel Memory Map on the Linux OS
•  Examining the Kernel Segment - kernel Virtual Address Space.
• Process Virtual Memory Mapping
• The mm_struct
• Memory Regions and VMAs
• Viewing VMAs
• VMAs on 64-bit
• proc: maps, pmap(1), smaps
• smem, smemcap.
• Low-Level API
• Freeing Pages
• kmalloc, kfree
• GFP flags and action modifier
• vmalloc
• Slab Cache API interfaces
• Which API to Use When
• TheLinuxKernelScheduler
• Introduction
• Linux Process State Machine
• Real-Time and Linux
• POSIX Scheduling Policies
• Realtime Policies
• Priority Range
• Pthreads soft-RT example
• taskset
• chrt
• Linux as an RTOS: a mention of the PREEMPT_RT patch.
• Control Groups
• The Need
• Cgroup Model
• Configuration
• Cgroups example for allocating cpu bandwidth.
• Handling Concurrency in the Kernel
• The Need for Atomicity
• Causes of Concurrency in the kernel
• Deadlock Prevention
• Important Guidelines
• Concurrency in the Kernel
• Spinlocks and Mutexes
• The Need
• Understanding when to use which
• The Semaphore Interface
• A note on Spinlock Implementation
• Specialized Locking
• Atomic Operators
• Reader-Writer Locks
• Memory Barriers

Cost: 499 USD

Duration: Upto 16 Hours

Ideal For: The course is intermediate to advanced in proficiency. It is suitable for the following:

• Programmers new in the area of Software Engineering that uses C++
  
• Developers embarking on projects using C++based techniques for their projects
  
• Professionals looking forward to upgrade the knowledge to apply skills
  

Post course benefits: Lifetime access to online repository, Mock interview support, project support

Recruitment support: eAgeIT will propose candidates of this program for any open opportunities with its client portfolio. We do not guarantee placement. This will be purely merit based support.

Course Objectives:

• To understand C++ internals with proven examples
  
• Would be able to apply C++ skills to construct code for their project
  
• Get an insight to develop C++ software in a systematic manner
  
• Would be able to user C++ 11 & 14 & 17 extensions in software
  
• Would be able to write secured code that cannot be easily exploited
  
• Get an understanding of robust software design in C++
  

Pre-Requisites:

• Delegates are desired to be aware of OOPS principals but it is not a mandatory
  

Detailed Coverage:

C++ Introduction Timeline

• Features of C++ (Revision)
• Goals for C++ and TR11/14/17

• Monolithic build, scope, and translations to executables
• Std 11/14/17 switchs and __cplusplus
• Separately Translated Program and monolithic builds

• Procedural Programming
• Object-Oriented Programming
• MDD, UML view, OOAD, SOLID
• Relationships and Responsibility in OOPS
• ;Introduction to C++ Specific Features
• Data Declaration and scope, Functions in C++: inline
• default argument, Overloading, References, Namespaces
• Inbuilt support for object oriented features
• RTTI, exception handling, templates
• Large-Scale Projects Are More Susceptible to Name Clashes
• Koenig Lookup
• Namespace Aliases
• Namespace Utilization Policy in Large-Scale Projects
• Namespaces and Version Control
• Scope Resolution Operator Should Not Be Used to Designate Global Names
• Standard Headers Names
• Restrictions on Namespaces
• Namespace std Can Not Be Modified
• User-Defined new and delete Cannot Be Declared in a Namespace.

• Representing Objects in C++

• The initializations in C++ using constructor
• OAD: C++ Object Implementation
• How a compiler interprets Object
• Special member functions
• Constructors,Destructors
• Copy and move Constructor
• Assignment move in Operator
• Blocking Object Copying
• Designing a class around mutable, logical const

• Compiler Synthesized Constructor & Destructor
• Deep copy v/s Shallow copy
• explicit constructor
• Copy Constructor v/s Assignment operator
• Initialization v/s Assignment
• Order of Initialization
• Aggregate initialization

• Static data
• Static methods
• Object instance control and sharing
• A minimal pattern study: singleton and its variance
• lmitations, and extensions

• Types of Storage
• POD (Plain Old Data) and non-POD Objects
• The Lifetime of a POD Object
• The Lifetime of a non-POD Object
• malloc() and free() Versus new and delete
• new and delete
• Allocating and Deallocating Arrays Using new[] anddelete[]

• Friend and classes
• Object communication
• Friend functions, Friend classes
• Const objects and const member functions
• Object composition & destruction mechanism
• Boundary classes & object interfaces

• The operator function and its interpretation object expressions
• Using member functions & friend functions - when to use what
• Implicit/explicit overloading mechanism
• Returning objects & assignment operator
• Overloading new & delete operators

• operator == , operator [ ], operator ( ), operator ->, operator comma (,)

• CScope ,Cflow

• Example frameworks that are built on inheritance: QT, WX Widget
• Specialization and Derived Classes
• Generalization and Abstract class, interfaces
• Types of inheritance
• Single level, multi-level, multiple, hierarchical, hybrid
• Inheritance - is it allocation or accessibility
• The protected access specifier
• Inheritance in private, protected & public mode
• Constructors & destructors in a derived class
• Multiple inheritance
• Virtual Base class Invoking base class constructors
• Why a constructor is not inherited

• Nested classes & Containership

• Pointers to Class Members
• Base class pointers & derived class objects
• Virtual functions & base class pointers
• Virtual functions & base class reference
• Dynamic Binding v/s Early Binding
• Pure virtual functions
• Virtual destructors
• Abstract classes & applications

• Runtime Polymorphism & RTTI
• typeid & type_info
• dynamic_cast, const_cast, static_cast, reinterpret_cast

• Implicit instantiation
• Explicit instantiation
• Specialization: complete and partial
• Function Templates
• Class Templates
• Declaration of a Class Template
• Instantiation and Specialization
• Explicit Specialization of a Class Template
• Specializations of Class Template Functions
• Template Arguments
• Default Type Arguments
• Static Data Members
• Friendship
• Function Templates
• Performance Considerations
• Type Equivalence
• Avoiding Unnecessary Instantiations
• Explicit Template Instantiation
• Interaction with Other Language Feature

• Containers, Algorithms, and iterators
• Using STL/STD Containers
• Using Algorithm and iterators with STD
• Exploring various containers, iterators and algorithms
• Vector, List, Map, Set
• Array, tuple, unordered_map, unordered_set

• Initialization, Initializer lists
• Uniform initialization
• Move Semantics
• Lambda
• Auto, decltype, trailing return type, auto vs. decltype
• Range-based for loop ,static_assert, constexpr functions/data, Inline namespaces

• STD Threads Passing, arguments to threads
• Data lifetime considerations, Synchronization with mutexes and locking
• Acquiring multiple locks, mutex types
• Returning values from threads using futures and async, Launch policies
• Condition variables, Thread-local storage

Cost: 499 USD

Duration: Upto 24 Hours