PROCESS MONITOR DASHBOARD

A PROJECT REPORT

Submitted by

FLORENCE D (95072415020)
GOWRI E (95072415022)
ISAIVANI D (95072415024)

in partial fulfillment for the award of the

degree of

BACHELOR OF TECHNOLOGY

in

INFORMATION TECHNOLOGY

FRANCIS XAVIER ENGINEERING COLLEGE

(Autonomous)
TIRUNELVELI – 627 003
MAY 2026

1
 FRANCIS XAVIER ENGINEERING COLLEGE

(Autonomous)
TIRUNELVELI – 627 003

BONAFIDE CERTIFICATE

Certified that this project report “ PROCESS MONITOR DASHBOARD ” is the

Bonafide work of “ISAIVANI D (95072415024)” who carried out the project work
under my supervision. Certified further that to the best of my knowledge the work
reported here in does not form part of any other thesis or dissertation on the basis of
which a degree or award was conferred on an earlier occasion on this or any other
candidate.

SUPERVISOR HEAD OF THE DEPARTMENT

Submitted for the B. TECH Degree Project Viva Voce held on ……………………………….

INTERNAL EXAMINER

2
 TABLE OF CONTENTS
[Link]
TITLE [Link]

1. PROBLEM STATEMENT

2. ABSTRACT

3. OBJECTIVE

4. INTRODUCTION

5. FLOW CHART

6. LIST OF MODULES WITH DESCRIPTION

7. SAMPLE CODE

8. RESULT

9. CONCLUSION

10. FUTURE SCOPE

3
 PROBLEM STATEMENT

Modern computer systems run multiple processes simultaneously, making it difficult

for users to monitor system performance and resource usage effectively. Existing
system monitoring tools like Task Manager provide detailed insights, but they often
involve graphical interfaces that may not be suitable for low-resource environments or
for understanding core operating system concepts at a fundamental level. There is a
need for a simple, lightweight, and terminal-based solution that can display essential
system information such as CPU usage, memory utilization, and active processes in
real time. Such a tool would help users and students gain a better understanding of how
processes are managed by the operating system while also providing basic monitoring
capabilities without relying on heavy graphical interfaces. This project aims to develop
a Process Monitor Dashboard using the C programming language, which simulates a
simplified version of a task manager. The system will retrieve and display real-time
system statistics, including CPU usage, memory status, and a list of running processes,
thereby offering an efficient and educational tool for system monitoring.

4
 ABSTRACT

The Process Monitor Dashboard is a lightweight, terminal-based system monitoring

tool developed using the C programming language. The primary objective of this
project is to provide real-time information about system performance, including CPU
usage, memory utilization, and active processes, in a simple and efficient manner.
Unlike traditional graphical task managers, this application focuses on a command-line
interface, making it suitable for low-resource environments and for understanding core
operating system functionalities. The system utilizes Windows API functions to collect
and display system statistics dynamically. It periodically refreshes the data to ensure
up-to-date monitoring, allowing users to observe system behavior in real time.
Additionally, the project includes process listing features that display process IDs and
names, helping users identify active tasks within the system. This project serves both
as a practical utility and an educational tool, demonstrating how operating systems
manage resources and processes. It also highlights the use of system-level
programming concepts, making it valuable for students learning about operating
systems and system monitoring techniques.

5
 OBJECTIVES

• To develop a terminal-based Process Monitor Dashboard using the C

programming language.
• To display real-time CPU usage of the system.
• To monitor and present memory utilization (total, used, and free memory).
• To retrieve and display a list of running processes with their Process IDs (PID).
• To create a lightweight alternative to graphical task managers.
• To understand and implement system-level programming concepts using
Windows API.
• To provide a user-friendly command-line interface for system monitoring.
• To update system information dynamically at regular intervals.
• To help users and students analyze system performance and resource usage.
• To serve as an educational tool for learning operating system process
management.

6
 INTRODUCTION

In modern computing systems, multiple processes run simultaneously, competing for

system resources such as CPU time and memory. Efficient management and
monitoring of these resources are essential to ensure smooth system performance and
stability. Operating systems provide built-in tools like Task Manager to help users
observe system activity, but these tools are typically graphical and may not clearly
demonstrate the underlying working principles. The Process Monitor Dashboard is
designed as a simplified, terminal-based system monitoring tool that provides real-time
insights into system performance. Developed using the C programming language, this
project focuses on displaying essential information such as CPU usage, memory
utilization, and active processes in a clear and concise format. By using system-level
programming and Windows API functions, the application directly interacts with the
operating system to retrieve live data. This project not only serves as a lightweight
monitoring utility but also helps in understanding key operating system concepts such
as process management, resource allocation, and system calls. It is particularly useful
for students and beginners who want to explore how system monitoring tools work
internally. The simplicity of the command-line interface makes it efficient, fast, and
suitable for environments with limited resources.

7
FLOWCHART

8
 LIST OF MODULES WITH DESCRIPTION

1. Screen Management Module

Function: clear_screen()
Description: This module is responsible for clearing the console screen before
displaying updated information. It ensures that the output looks clean and refreshed
during each cycle of execution.

2. CPU Monitoring Module

Function: get_cpu_usage()
Description: This module calculates the CPU usage percentage using Windows
system calls. It retrieves idle, kernel, and user time using GetSystemTimes() and
computes real-time CPU utilization.

3. Memory Monitoring Module

Function: get_memory_usage()
Description: This module fetches system memory details such as total memory, used
memory, free memory, and memory usage percentage using Global Memory
StatusEx().

4. Process Management Module

Function: list_processes()
Description: This module retrieves and displays the list of currently running
processes along with their Process IDs (PID). It uses Windows API functions like
CreateToolhelp32Snapshot() to access process information.

5. Display Module
Description: This module organizes and prints all collected data (CPU, memory,
processes) in a structured format on the terminal. It ensures readability and proper

9
alignment of output.
6. Control Module (Main Loop)
Function: main()
Description: This is the core module that controls the program flow. It runs an infinite
loop (while(1)), calls all other modules sequentially, and refreshes the display every 2
seconds using Sleep().

10
 SAMPLE CODE

#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>
void clear_screen() {
system("cls");
}
void get_memory_usage() {
MEMORYSTATUSEX mem;
[Link] = sizeof(mem);
GlobalMemoryStatusEx(&mem);
printf("Total Memory: %llu MB\n", [Link] / (1024 * 1024));
printf("Used Memory : %llu MB\n",
([Link] - [Link]) / (1024 * 1024));
printf("Free Memory : %llu MB\n", [Link] / (1024 * 1024));
printf("Memory Usage: %ld%%\n", [Link]);
}
void get_cpu_usage() {
FILETIME idleTime, kernelTime, userTime;
static ULONGLONG prevIdle = 0, prevKernel = 0, prevUser = 0;
GetSystemTimes(&idleTime, &kernelTime, &userTime);
ULONGLONG idle = (*(ULONGLONG*)&idleTime);
ULONGLONG kernel = (*(ULONGLONG*)&kernelTime);
ULONGLONG user = (*(ULONGLONG*)&userTime);
ULONGLONG total = (kernel - prevKernel) + (user - prevUser);
ULONGLONG idleDiff = idle - prevIdle;
float cpu = 0;
if (total != 0)

1
11
 cpu = 100.0f * (total - idleDiff) / total;
printf("CPU Usage: %.2f%%\n", cpu);
prevIdle = idle;
prevKernel = kernel;
prevUser = user;
}
void list_processes() {
PROCESSENTRY32 pe32;
HANDLE hSnap;
hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnap == INVALID_HANDLE_VALUE) {
printf("Error getting process list\n");
return;
}
[Link] = sizeof(PROCESSENTRY32);
if (!Process32First(hSnap, &pe32)) {
CloseHandle(hSnap);
return;
}
printf("\n%-10s %-30s\n", "PID", "Process Name");
printf("--------------------------------------------------\n");
int count = 0;
do {
printf("%-10lu %-30s\n", pe32.th32ProcessID, [Link]);
count++;
if (count >= 10) break; // show only top 10
} while (Process32Next(hSnap, &pe32));
CloseHandle(hSnap);
}

1
12
int main() {
while (1) {
clear_screen();
printf("=================================\n");
printf(" PROCESS MONITOR DASHBOARD \n");
printf("=================================\n\n");
get_cpu_usage();
printf("\n");
get_memory_usage();
list_processes();
printf("\nPress Ctrl+C to exit...\n");
Sleep(2000);
}
return 0;
}

1
13
RESULT

1
14
 CONCLUSION

The Process Monitor Dashboard project successfully demonstrates a simple and

efficient way to monitor system performance using a command-line interface. By
utilizing the C programming language and Windows API functions, the system is able
to display real-time information such as CPU usage, memory utilization, and active
processes. This project highlights important operating system concepts, including
process management, resource allocation, and system-level programming. The
implementation of a continuous monitoring loop ensures that system data is updated
dynamically, providing users with accurate and timely information. Overall, the project
serves as both a practical utility and a learning tool for understanding how system
monitoring works internally. It proves that even without complex graphical interfaces,
essential system details can be effectively presented in a lightweight and user-friendly
manner.

1
15
 FUTURE SCOPE

• Graphical User Interface (GUI):

Upgrade the terminal-based system into a GUI application using frameworks to
make it more interactive and visually appealing.
• Process Control Features:
Add options to terminate (kill) processes, suspend, or resume them using
Process IDs.
• Detailed Process Information:
Display additional details such as CPU usage per process, memory
consumption per process, and process priority.
• Sorting and Filtering:
Allow users to sort processes based on CPU usage, memory usage, or name,
and implement search functionality.
• Colorful Dashboard:
Enhance the interface with colors to indicate system status (e.g., high CPU
usage in red, normal in green).
• Disk and Network Monitoring:
Extend the system to include disk usage and network activity for complete
system monitoring.
• User Interaction Menu:
Provide a menu-driven interface to improve usability and control.
• Cross-Platform Support:
Modify the application to work on Linux and other operating systems.
• Data Logging and Reports:
Store system performance data over time and generate reports for analysis.

1
16