Thursday, August 15, 2024

C++ Concurrent profiling using Helgrind - a tool of Valgrind

 On 15th August - my contribution to the learning community...

Concurrency profiling in C++ is essential for optimizing the performance of multi-threaded applications by identifying and addressing bottlenecks, inefficiencies, and issues like race conditions and deadlocks.

I am using the Helgrind tool of Valgrind in eclipse to do the experimentation on C++ data race condition in a multithreaded application.

A data race occurs in a multithreaded application when two or more threads access shared data concurrently, and at least one of these accesses is a write operation without proper synchronization (e.g., without locks). This can lead to unpredictable behavior, crashes, or incorrect program output.

Here is some information about Helgrind.

Helgrind:

- Detects data races, potential deadlocks, and lock-order violations.

- Useful for debugging multi-threaded applications where data consistency is crucial.

Data Race Detection: 

If Helgrind detects that two threads are accessing the same memory location concurrently without proper synchronization, and at least one of these accesses is a write, it flags this as a data race.

Please have a look at my video - it's all explained here.


Concurrency profiling in C++ is crucial for developing high-performance multi-threaded applications.

Valgrind is a versatile tool for detecting a wide range of memory-related issues in C++ applications. Tools like Memcheck, Helgrind, DRD, and Massif provide comprehensive coverage of memory leaks, invalid accesses, uninitialized memory usage, threading issues, and memory management inefficiencies.

Using Valgrind in the development cycle can significantly improve the stability and performance of your application by identifying and allowing you to fix these memory-related issues.

Another important task that Helgrind does is to check whether there is any deadlock in a multithreaded C++ application - like Cyclic dependency.

Cyclic dependency deadlock occurs when two or more locks are acquired in a different order in two task executions, potentially leading to a deadlock when the program's tasks execute in parallel.

A Lock order violation problem indicates the following timeline:

Task 1

Acquire lock A.

Acquire lock B.

Release lock B.

Release lock A.

Task 2

Acquire lock B.

Acquire lock A.

Release lock A.

Release lock B.

If these time lines are interleaved when the two tasks execute in parallel, a Deadlock occurs:

Task 1: Acquire lock A.

Task 2: Acquire lock B.

Task 1: Try to acquire lock B; wait until task 2 releases it.

Task 2: Try to acquire lock A; wait until task 1 releases it.

For example consider the following piece of code

//============================================================================

// Name : CyclicDependencyDeadLock.cpp

// Author : Som

// Version :

// Copyright : som-itsolutions

// Description : Hello World in C++, Ansi-style

//============================================================================


#include <iostream>

#include <thread>

#include <mutex>


using namespace std;


std::mutex lock1, lock2;


void threadA() {

int count = 0;

std::lock_guard<std::mutex> guard1(lock1);

for (int i = 0; i<100000; i++){

count++;

}

std::lock_guard<std::mutex> guard2(lock2);

//cout<<"Thread id " <<this_thread::get_id()<<" this is okay now because of correct lock order " <<count<<endl;

cout<<"Thread id " <<this_thread::get_id()<< " this will never be printed..."<<count<<endl;

}


void threadB() {

std::lock_guard<std::mutex> guard2(lock2);

int count = 0;

for (int i = 0; i<100000; i++){

count++;

}

std::lock_guard<std::mutex> guard1(lock1);

//cout<<"Thread id " <<this_thread::get_id()<<" this is okay now because of correct lock order " <<count<<endl;

cout<<"Thread id " <<this_thread::get_id()<< " this will never be printed..."<<count<<endl;

}


int main() {

std::thread t1(threadA);

std::thread t2(threadB);


t1.join();

t2.join();


return 0;

}



And if we profile the above piece of code using Helgrind, it will show

Thread #3: lock order "0x10E160 before 0x10E1A0" violated...

Please have a look at the following video...


To avoid the lock order violation we must go for consistent global order for all the threads.

That's all for today...

I hope this exploration will help the inquisitive minds of software engineers.

Jai Hind.... Jai Bharat...

Wednesday, August 14, 2024

Memory profiling of C++ using Valgrind...


On the eve of 15th August - my contribution to the learning community...

Profiling in C++ is a crucial step in optimizing the performance of your application. It involves analyzing various aspects of the code, such as CPU usage, memory consumption, and execution time, to identify bottlenecks and inefficiencies. 

Types of Profiling

CPU Profiling:

Focuses on the amount of time the CPU spends executing different parts of the program.

Identifies functions or code segments that take up most of the CPU time.

Tools: gprof, perf, Visual Studio Profiler.

Memory Profiling:

Monitors the application's memory usage, including allocations, deallocations, and memory leaks.

Helps in identifying memory-intensive operations and optimizing memory management.

Tools: valgrind, Massif, AddressSanitizer, Heaptrack.

I/O Profiling:

Analyzes input/output operations, such as disk access or network communication.

Useful for applications that are I/O bound.

Tools: strace, iotop.

Concurrency Profiling:

Monitors the behavior of multi-threaded programs to identify issues like thread contention, deadlocks, and inefficient parallelism.

Tools: Intel VTune, ThreadSanitizer, gprof.

Today I will discuss about memory profiling - especially memory leak in a C++ program using valgrind.

Please have a look at my video.

It's well-explained here.


Valgrind is a versatile tool for detecting a wide range of memory-related issues in C++ applications. Tools like Memcheck, Helgrind, DRD, and Massif provide comprehensive coverage of memory leaks, invalid accesses, uninitialized memory usage, threading issues, and memory management inefficiencies.

Using Valgrind in the development cycle can significantly improve the stability and performance of your application by identifying and allowing you to fix these memory-related issues.

Jai Hind.... Jai Bharat...

Thursday, August 8, 2024

CyclicBarrier in Java Concurrency package...

 A CyclicBarrier is a synchronization tool in Java that allows a group of threads to wait for each other to reach a common point before proceeding. Once all threads reach this point (the barrier), they are released simultaneously. The term "cyclic" implies that the barrier can be reused multiple times.

Key Features of CyclicBarrier

  1. Barrier Point: The point where all participating threads must wait before any of them can proceed. Once the last thread reaches this barrier, the barrier is broken, and all threads continue execution.

  2. Cyclic Nature: The barrier is "cyclic" because it can be reused after the waiting threads are released. This allows the same CyclicBarrier instance to be used for multiple cycles of synchronization.

  3. Optional Runnable Action: You can specify a Runnable action that will be executed once the last thread reaches the barrier. This action is executed before the threads are released.

Source Code:


Class StudentTask

package com.somitsolutions.java.cyclicbarrier; import java.time.LocalTime; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class StudentTask implements Runnable { private String name = ""; private int timeLapseBeforeStarting = 0; private CyclicBarrier cyclicBarrier = null; public StudentTask(String name, int timeLapseBeforeStarting, CyclicBarrier cyclicBarrier) { this.name = name; this.timeLapseBeforeStarting = timeLapseBeforeStarting; this.cyclicBarrier = cyclicBarrier; } @Override public void run() { // TODO Auto-generated method stub try { Thread.sleep(timeLapseBeforeStarting); System.out.println("Thread " + this.name + " has reached the barrier and will wait"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { this.cyclicBarrier.await(); LocalTime localTime = LocalTime.now(); System.out.println(this.name + " is starting at " + localTime .getHour() + " : " + localTime.getMinute() +" : " + localTime.getSecond()); } catch (InterruptedException | BrokenBarrierException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }


Class classEight:


package com.somitsolutions.java.cyclicbarrier;


import java.util.concurrent.CyclicBarrier;


public class ClassEight {

static final int NUMBER_OF_STUDENTS = 3;

static final CyclicBarrier cb = new CyclicBarrier(NUMBER_OF_STUDENTS, ()->{

System.out.println("All threads have reached the barrier. All of them will now proceed...");

});

Thread ridit = new Thread(new StudentTask("Ridit", 1000, cb));

Thread ishan = new Thread(new StudentTask("Ishan", 2000, cb));

Thread manav = new Thread(new StudentTask("Manav", 3000, cb));

public void giveTaskToStudent() {

ridit.start();

ishan.start();

manav.start();

}


}



class Main :


package com.somitsolutions.java.cyclicbarrier;


public class Main {


public static void main(String[] args) {

// TODO Auto-generated method stub

ClassEight etc = new ClassEight();

etc.giveTaskToStudent();


}


}

The Output:

Thread Ridit has reached the barrier and will wait

Thread Ishan has reached the barrier and will wait

Thread Manav has reached the barrier and will wait

All threads have reached the barrier. All of them will now proceed

Ishan is starting at 20 : 21 : 31

Manav is starting at 20 : 21 : 31

Ridit is starting at 20 : 21 : 31


Here's my discussion on Barrier in C++ 20.


Wednesday, August 7, 2024

Why is Turbo C++ still being used in Indian schools and colleges?

Have a look at the screenshot...



Wrote this post at Quora almost 6 years ago. 

Here's the link...

https://qr.ae/p2NPOl 

Today I asked ChatGPT about the latest status... 

and to my surprise, I got the above answer... 

Here is the full text...

I am a software professional having long years of experience. Now i train and coach others in different software technologies. Many of my students are from CBSE 10+2 and they use Turbo C++ at school. When i asked them why their school is still using it, they said probably CBSE board has asked the schools to do so. This is really a dangerous trend - training students with obsolete technologies. Turbo C++ is really prehistoric and it does not have the standard header files of modern C++ as well (like std :: string). I am not sure why CBSE has not banned Turbo C++ in school. While at my training institute, i use Eclipse with CDT plugin alongside Cygwin & GCC compiler and i install the same on my students’ computers, but this should be a normal way of dealing with software rather than an exception.

Not only this, few days back i was having a conversation with one of my friends who is a Professor of CS in a college. He said that most of the colleges in India use Oracle 10g for RDBMS programming. So he suggested that for this either the college authority has to pay an hefty price or use a pirated copy. So why not move to MySQL. But to his shock, he got the answer that when the students will go to other college for external LAB work in the exam, they will most probably get Oracle 10 g and they may not be able to work on it if they are exposed to MySQL in their own college. This is really pathetic.

I have another nightmare to share with you as a technical teacher. Very recently UGC will be coming out with a new Syllabus for college level CS. There they have included Android as one elective subject. Now when i saw the syllabus of that Android course, i was shocked. The colleges have been asked to teach Android using Eclipse with ADT plugin. Now you know, this is passe and most of the Android developers today use Android studio.

No wonder the Indian graduates mostly have half-baked knowledge and remain unemployable for a long time till they learn by rote learning about few historical facts and general knowledge and crack an equally boring Govt. job…


Babus in the Department of Education must be progressive.


It's time for a collective introspection - there is no shortcut to build skills - many night outs in front of a computer is the only answer. To clean up the swamp we must shake up the education system as practised in today's Bharat...


Is anybody listening?


Wake up, please - or else the news like the Rs. 20000 salary per month for a fresh engineering graduate which is even less than that of a driver or a house maid, will dominate the Indian corporate sectors.

Monday, July 29, 2024

C++ 20 multi threaded programming - the introduction of std::atomic...

Data races in C++ multithreaded applications occur when multiple threads try to access a single data without proper data locking tools like mutex.

Causes of Data Races

  1. Concurrent Reads and Writes: If one thread reads a variable while another writes to it without synchronization, a data race occurs.
  2. Concurrent Writes: If multiple threads write to the same variable concurrently without synchronization, it leads to a data race.
  3. Lack of Synchronization Primitives: Not using mutexes, atomic operations, or other synchronization mechanisms can result in data races.

Data race may cause unpredictable output and even crashes.

For example, look at the below C++ programs.

//============================================================================

// Name : C++20Atomic.cpp

// Author : Som

// Version :

// Copyright : som-itsolutions

// Description : Hello World in C++, Ansi-style

//============================================================================


#include <iostream>

#include <atomic>

#include <thread>


int counter = 0;



void incrementCounter() {

for (int i = 0; i < 10000; ++i) {

counter++;

}

}


int main() {

std::thread t1(incrementCounter);

std::thread t2(incrementCounter);


t1.join();

t2.join();


std::cout << "Final counter value: " << counter << std::endl;


return 0;

}

Here two threads are trying to access a single variable without a proper synchronization technique.

Here is the video in which the program is run in Eclipse.


You can see that as the counter increases, the output is incorrect. This is because we didn't use any thread-safe way to access the variable.

In C++ 20, with the introduction of atomic data, this can be easily handled.

So, now we have changed the simple variable into an atomic variable.

//============================================================================

// Name : C++20Atomic.cpp

// Author : Som

// Version :

// Copyright : som-itsolutions

// Description : Hello World in C++, Ansi-style

//============================================================================


#include <iostream>

#include <thread>

#include <atomic>


std::atomic<int> counter(0);


void incrementCounter() {

for (int i = 0; i < 10000000; ++i) {

counter++;

}

}


int main() {

std::thread t1(incrementCounter);

std::thread t2(incrementCounter);


t1.join();

t2.join();


std::cout << "Final counter value: " << counter << std::endl;


return 0;

}


And voila...

The output result is perfect...



C++ is gradually becoming powerful after a very long period of hibernation. 

Enjoy...

Monday, June 10, 2024

What is a 3D Software Engineer from the POV of career options - fatherhood rocks...

A 3D Software Engineer is a programmer who builds software applications specifically designed for 3D graphics and visualization. They essentially bridge the gap between the artistic world of 3D modelling and the technical world of computer science.

Here's a breakdown of their responsibilities:

Software Development: 

They write code and develop software applications that deal with 3D graphics, like animation tools, modelling software, or rendering engines.

Understanding 3D Concepts: 

They have a deep understanding of 3D graphics and rendering algorithms. This allows them to optimize software for efficient creation and display of 3D visuals.

Problem-Solving: 

They troubleshoot and debug software to ensure it functions smoothly and delivers high-quality results.

Collaboration: 

They often work alongside software development teams and may even collaborate with 3D artists or designers to understand their needs and create effective tools.

Here are some of the industries that employ 3D Software Engineers:

- Video Game Development

- Film and Animation Studios

- Architecture and Engineering

- Medical Visualization

- Scientific Research

- Building software which will be used for developing flight-simulation, rocket and missile simulation, etc

If you're interested in this field, you'll need strong skills in computer science and mathematics, along with a passion for 3D graphics. Expertise in programming languages like C++ or Python and being familiar with 3D software like Maya or Blender would be a big plus.

My son, Ridit is at the juncture of software development and 3D modelling - having expertise in both of these fields.

Here are some of the animations my son Ridit created using Blender...

This is how it started for Ridit - the journey to learn 3D modelling.

And here are some others...

The passage of Time...




The Water Tornado...




The making of a filter coffee maker... (Fusion 360)




Here's his technical blog...

This blog mainly has stories of his journey as a software professional through the maze called software. 

Saturday, June 1, 2024

Bharat's ambitious three-stage nuclear energy program...

Watch...


I am not a Nuclear Energy expert - but these days with the help of Gemini and ChatGPT, we can get the right information easily. This blog post is just to disseminate the good work done by the scientists of Bharat.

I am sure the Bharat that my son will be experiencing - will be much different than what we saw after coming out from the engineering colleges in '90s.

#JaiHind

Let's come to the point...

India's ambitious three-stage nuclear program is a strategic plan for developing nuclear power using domestic uranium and thorium reserves. It was formulated by Homi Bhabha, a renowned physicist in the 1950s. The ultimate goal of this program is to achieve long-term energy security for the country by effectively utilizing its abundant thorium reserves.

Here's a breakdown of the three stages:

Stage 1: Pressurized Heavy Water Reactors (PHWRs)

PHWRs use natural uranium as fuel and heavy water (deuterium oxide) as a moderator and coolant.

These reactors are efficient in extracting energy from uranium because heavy water is a more effective neutron moderator than regular water.

India has successfully built and operated numerous PHWRs, and they currently form the backbone of the country's nuclear power generation.

Stage 2: Fast Breeder Reactors (FBRs)

FBRs are designed to produce more fissile material (plutonium) than they consume.

They achieve this by using plutonium or enriched uranium as fuel and a liquid metal (like sodium) as coolant.

The plutonium produced in FBRs can be used as fuel in further reactors, reducing dependence on mined uranium.

India is actively developing FBR technology, and the Prototype Fast Breeder Reactor (PFBR) at Kalpakkam is a significant milestone in this direction.

Stage 3: Advanced Nuclear Power Systems (Thorium Reactors)

This stage focuses on utilizing India's vast thorium reserves for sustainable energy generation.

Thorium itself is not fissile, but it can be converted into fissile uranium-233, which can be used as fuel in nuclear reactors.

Advanced reactor designs like Advanced Heavy Water Reactors (AHWRs) and Molten Salt Reactors (MSRs) are being explored for efficient thorium utilization.

Significance of the 3-stage program:

India has limited uranium reserves but vast thorium reserves. This program allows India to achieve energy security by effectively using its domestic resources.

FBRs help in plutonium production, reducing reliance on imported fissile material.

Thorium-based reactors offer a sustainable and long-term solution for India's energy needs due to the abundance of thorium.

Challenges:

Developing and deploying advanced reactor technologies like FBRs and thorium reactors is a complex and time-consuming process.

Nuclear safety and waste management are critical concerns that need to be addressed effectively.

Overall, India's three-stage nuclear program is a far-sighted approach to ensuring the country's long-term energy security. It leverages domestic resources and promotes sustainable nuclear power generation.