Internal Fragmentation in OS

"""Internal fragmentation: memory granted minus memory actually used."""

import math

PAGE_SIZE_KB = 4


def pages_needed(request_kb, page_size_kb=PAGE_SIZE_KB):
    """Whole pages required to hold a request of this size."""
    return math.ceil(request_kb / page_size_kb)


def internal_fragmentation(request_kb, page_size_kb=PAGE_SIZE_KB):
    """KB granted to the process that it cannot use."""
    granted = pages_needed(request_kb, page_size_kb) * page_size_kb
    return granted - request_kb


def main():
    for request in (5, 8, 9):
        pages = pages_needed(request)
        granted = pages * PAGE_SIZE_KB
        wasted = internal_fragmentation(request)
        print(f"{request:2d} KB -> {pages} pages = {granted:2d} KB granted, "
              f"{wasted} KB wasted")

    worst = PAGE_SIZE_KB - 1
    print(f"worst case per allocation: {worst} KB")
    print(f"average across many requests: about {PAGE_SIZE_KB / 2} KB")


if __name__ == "__main__":
    main()

// Internal fragmentation: memory granted minus memory actually used.
#include <iostream>
constexpr int kPageSizeKb = 4;
// Whole pages required to hold a request of this size.
int pagesNeeded(int requestKb, int pageSizeKb = kPageSizeKb) {
    return (requestKb + pageSizeKb - 1) / pageSizeKb; // integer ceiling
}
// KB granted to the process that it cannot use.
int internalFragmentation(int requestKb, int pageSizeKb = kPageSizeKb) {
    return pagesNeeded(requestKb, pageSizeKb) * pageSizeKb - requestKb;
}
int main() {
    for (int request : {5, 8, 9}) {
        const int pages = pagesNeeded(request);
        std::cout << request << " KB -> " << pages << " pages = "
        << pages * kPageSizeKb << " KB granted, "
        << internalFragmentation(request) << " KB wasted\n";
    }
    std::cout << "worst case per allocation: " << kPageSizeKb - 1 << " KB\n";
}

// Internal fragmentation: memory granted minus memory actually used.
public class InternalFragmentation {
    static final int PAGE_SIZE_KB = 4;
    /** Whole pages required to hold a request of this size. */
    static int pagesNeeded(int requestKb) {
        return (requestKb + PAGE_SIZE_KB - 1) / PAGE_SIZE_KB; // integer ceiling
    }
    /** KB granted to the process that it cannot use. */
    static int internalFragmentation(int requestKb) {
        return pagesNeeded(requestKb) * PAGE_SIZE_KB - requestKb;
    }
    public static void main(String[] args) {
        for (int request : new int[]{5, 8, 9}) {
            int pages = pagesNeeded(request);
            System.out.printf("%2d KB -> %d pages = %2d KB granted, %d KB wasted%n",
            request, pages, pages * PAGE_SIZE_KB,
            internalFragmentation(request));
        }
        System.out.println("worst case per allocation: "
        + (PAGE_SIZE_KB - 1) + " KB");
    }
}