update the all project

Author: orcalinux

…heap-memory-manager/source-code/Makefile …diate/tasks/heap-memory-manager/Makefileintermediate/tasks/heap-memory-manager/source-code/Makefile renamed to intermediate/tasks/heap-memory-manager/Makefile intermediate/tasks/heap-memory-manager/source-code/Makefile renamed to intermediate/tasks/heap-memory-manager/Makefile

@@ -1,34 +1,34 @@
 .PHONY: clean_all clean_obj doc
 
-cc = gcc
-CFLAGS = -Wall -Wextra
+CC = gcc
+CFLAGS = -Wall -Wextra -Iinclude
 
-#List of Source files
-SRC = $(wildcard *.c)
+# List of Source files
+SRC = $(wildcard src/*.c)
 
 # List of header files
-HDR = $(wildcard *.h) 
+HDR = $(wildcard include/*.h)
 
-#List of Source files except the memory_manager_test
-LIB_SRC = $(filter-out memory_manager_test.c, $(wildcard *.c))
+# List of Source files except the memory_manager_test
+LIB_SRC = $(filter-out src/memory_manager_test.c, $(wildcard src/*.c))
 
 # List of object files
-OBJ = $(SRC:.c=.o)
+OBJ = $(SRC:src/%.c=bin/%.o)
 
 # List of object files for shared build
-OBJ_SHARED = $(LIB_SRC:.c=_shared.o)
+OBJ_SHARED = $(LIB_SRC:src/%.c=bin/%_shared.o)
 
 # List of object files for static build
-OBJ_STATIC = $(LIB_SRC:.c=_static.o)
+OBJ_STATIC = $(LIB_SRC:src/%.c=bin/%_static.o)
 
 # Name of the executable
-TARGET = hmm
+TARGET = bin/hmm
 
 # Name of the static library
-STATIC_LIB = lib$(TARGET).a
+STATIC_LIB = lib/lib$(TARGET).a
 
 # Name of the shared library
-SHARED_LIB = lib$(TARGET).so
+SHARED_LIB = lib/lib$(TARGET).so
 
 # Command to remove files
 RM = rm -f
@@ -52,25 +52,26 @@ shared: $(OBJ_SHARED)
 	$(RM) $(OBJ_SHARED)
 
 # Rule to compile C source files into object files
-%.o: %.c $(HDR)
+bin/%.o: src/%.c $(HDR)
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Rule to compile C source files to object files for shared build
-%_shared.o: %.c $(HDR)
+bin/%_shared.o: src/%.c $(HDR)
 	$(CC) $(CFLAGS) -fPIC -c $< -o $@
 
 # Rule to compile C source files to object files for static build
-%_static.o: %.c $(HDR)
+bin/%_static.o: src/%.c $(HDR)
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Clean target
 clean_all:
-	$(RM) $(TARGET)	$(OBJ) $(OBJ_STATIC) $(OBJ_SHARED) $(STATIC_LIB) $(SHARED_LIB)
+	$(RM) bin/* lib/*
 
 # Clean object files
 clean_obj:
-	$(RM) $(OBJ_SHARED) $(OBJ_STATIC)
+	$(RM) bin/*.o bin/*_shared.o bin/*_static.o
 
 # Generate documentation
 doc:
-	doxygen Doxyfile
+	doxygen docs/Doxyfile
+

intermediate/tasks/heap-memory-manager/README.md

@@ -1,38 +1,156 @@
 # Linux Memory Manager
 
-This project provides a comprehensive memory management solution for Linux systems. It includes various components and utilities to efficiently manage memory allocation and deallocation, optimizing memory usage in applications.
+This project provides a comprehensive and optimized memory management solution tailored for Linux systems. It implements a custom heap memory manager, offering enhanced control over memory allocation and deallocation processes, which is critical for high-performance and resource-constrained applications.
 
-## Features
-- **Heap Memory Manager (HMM)**: Implements a flexible and efficient heap memory management system, replacing standard `malloc` and `free` functions with optimized versions.
-- **GLib Thread (GLThread)**: Offers a generic linked list implementation using GLib for thread-safe operations.
-- **Memory Manager Test Suite**: Includes a test suite to validate the functionality and performance of the memory manager under various scenarios.
-- **Shared and Static Libraries**: Supports building both shared and static libraries, providing flexibility in integration with different applications.
+## Table of Contents
+1. [Introduction](#introduction)
+2. [Linux Memory Management Overview](#linux-memory-management-overview)
+   - [Why Custom Memory Management?](#why-custom-memory-management)
+3. [Project Features](#project-features)
+4. [Project Structure](#project-structure)
+5. [Building the Project](#building-the-project)
+   - [Building the Library](#building-the-library)
+   - [Running Tests](#running-tests)
+   - [Integration with Applications](#integration-with-applications)
+6. [Documentation](#documentation)
+7. [Contributing](#contributing)
+8. [License](#license)
+9. [Acknowledgments](#acknowledgments)
 
-## Usage
-1. **Building the Library**:
-   - Run `make all` to build the library and test suite.
-   - Use `make static` or `make shared` to build the library as a static or shared object, respectively.
+---
 
-2. **Running Tests**:
-   - After building, execute the default test suite by running the `hmm` executable.
-   - Optionally, run specific tests or modify the test suite according to your requirements.
+## Introduction
 
-3. **Integration with Applications**:
-   - Link your application with the generated library (`libhmm.a` for static or `libhmm.so` for shared) to leverage the memory management features.
+Memory management is a critical aspect of system programming, particularly in environments where resource efficiency and performance are paramount. This project presents a custom Heap Memory Manager (HMM) designed specifically for Linux systems, offering an alternative to the standard `malloc` and `free` functions with more efficient, flexible, and robust memory management capabilities.
 
-## Documentation
-- Detailed documentation and API references are available in the project website: [Linux Memory Manager Documentation](https://mahmoud-abdelraouf.github.io/STM_System-Programming-under-Linux/)
+## Linux Memory Management Overview
+
+### Why Custom Memory Management?
+
+In typical Linux applications, memory management is handled by the system's allocator, which uses functions like `malloc`, `calloc`, and `free`. While these standard functions are sufficient for many applications, they may not provide the level of control, efficiency, or customization required for certain high-performance or specialized applications. This project addresses these limitations by offering:
+
+- **Improved Performance:** Custom memory allocation algorithms can reduce fragmentation and enhance performance.
+- **Thread Safety:** The GLib Thread (GLThread) module provides a thread-safe linked list implementation, essential for concurrent applications.
+- **Memory Usage Optimization:** The HMM system is designed to make better use of available memory, reducing wastage and improving overall application efficiency.
+
+## Project Features
+
+- **Heap Memory Manager (HMM):** A robust memory management system that replaces the standard dynamic memory allocation functions with custom, optimized alternatives.
+- **GLib Thread (GLThread):** A generic, thread-safe linked list implementation built using GLib, facilitating safe and efficient multi-threaded operations.
+- **Memory Manager Test Suite:** A comprehensive test suite that rigorously tests the memory manager's functionality and performance across various scenarios, ensuring reliability and robustness.
+- **Support for Static and Shared Libraries:** The project can be built as either a static library (`.a`) or a shared library (`.so`), providing flexibility in how it can be integrated into different applications.
+
+## Project Structure
+
+The project is organized into several directories, each serving a specific purpose:
+
+```
+.
+├── src/                    # Source files containing the core logic of the project
+│   ├── datatype_size_lookup.c  # Handles datatype size lookups
+│   ├── glthread.c              # GLib-based thread-safe linked list implementation
+│   ├── memory_manager.c        # Core heap memory manager implementation
+│   ├── memory_manager_test.c   # Test suite for the memory manager
+│   ├── parse_datatype.c        # Utilities for parsing datatypes
+├── include/                # Header files defining interfaces and structures
+│   ├── colors.h                # Utilities for color-coded terminal output
+│   ├── datatype_size_lookup.h  # Header for datatype size lookup functions
+│   ├── glthread.h              # Header for GLib thread-safe linked list
+│   ├── memory_manager.h        # Header for heap memory manager
+│   ├── memory_manager_api.h    # API definitions for memory management
+│   ├── parse_datatype.h        # Header for datatype parsing utilities
+├── lib/                    # Compiled libraries (static and shared)
+│   ├── libhmm.a                # Static library for HMM
+│   ├── libhmm.so               # Shared library for HMM
+├── bin/                    # Compiled executables and object files
+│   ├── hmm                     # Executable test suite for the memory manager
+│   ├── *.o                     # Object files generated during compilation
+├── docs/                   # Documentation and Doxygen configuration
+│   ├── Doxyfile                # Configuration file for generating project documentation
+├── Makefile                # Makefile for automating build and test processes
+├── LICENSE                 # License file outlining the terms of use
+└── README.md               # This README file
+```
+
+## Building the Project
+
+### Building the Library
+
+To build the project, ensure that you have `gcc` and `make` installed on your system. You can then use the following commands:
+
+- **Build Everything:**  
+  ```sh
+  make all
+  ```
+  This command compiles all source files, creates object files, and links them to produce the `hmm` executable, as well as the static and shared libraries.
+
+- **Build Static Library Only:**  
+  ```sh
+  make static
+  ```
+  This builds only the static library (`libhmm.a`).
+
+- **Build Shared Library Only:**  
+  ```sh
+  make shared
+  ```
+  This builds only the shared library (`libhmm.so`).
+
+### Running Tests
+
+After building, you can run the test suite to verify the memory manager's functionality:
 
-## EditorConfig:
-   - The project includes an `.editorconfig` file to ensure consistent coding styles and formatting across different editors and IDEs.
+- **Run All Tests:**  
+  ```sh
+  ./bin/hmm
+  ```
+  The test suite is comprehensive and covers a wide range of scenarios, ensuring the robustness of the memory manager.
+
+### Integration with Applications
+
+To use the memory manager in your application, link your application with the generated library:
+
+- **Static Linking:**  
+  Include the static library `libhmm.a` in your build process.
 
+- **Shared Linking:**  
+  Include the shared library `libhmm.so` and ensure it is in your system's library path.
+
+```sh
+gcc -o myapp myapp.c -Llib -lhmm
+```
+
+This command compiles `myapp.c` and links it with the `hmm` library.
+
+## Documentation
+
+Detailed documentation is generated using Doxygen and is available in the `docs/` directory. You can also access the documentation online at the [Linux Memory Manager Documentation](https://mahmoud-abdelraouf.github.io/STM_System-Programming-under-Linux/).
+
+To generate the documentation locally, run:
+
+```sh
+make doc
+```
+
+This will produce HTML documentation that can be viewed in any web browser.
+
 ## Contributing
-- Contributions are welcome! Fork the repository, make your changes, and submit a pull request.
-- Report any issues or suggestions by opening an issue on GitHub.
+
+We welcome contributions from the community! Here’s how you can contribute:
+
+1. **Fork the Repository:** Start by forking the project repository.
+2. **Create a Branch:** Develop your feature or fix in a new branch.
+3. **Submit a Pull Request:** Once your changes are ready, submit a pull request for review.
+4. **Report Issues:** If you find any bugs or have suggestions, please open an issue on GitHub.
+
+### Coding Standards
+
+Please adhere to the coding standards outlined in the `.editorconfig` file to ensure consistency across the project.
 
 ## License
-This project is licensed under the MIT License. See the [LICENSE](../../../LICENSE) file for details.
 
----
+This project is licensed under the MIT License. See the [LICENSE](../../../LICENSE) file for more details.
+
+## Acknowledgments
 
-*This project is part of the Linux System Programming course offered by STMicroelectronics Egypt.*
+This project is a part of the Linux System Programming course offered by STMicroelectronics Egypt. Special thanks to the course instructors and contributors for their valuable input and guidance.