Project 9.05 Section 9 ⚡ Embedded Relevance: Core Histograms Categorization Frequency Table Static Bins Data Analysis

9.05 Stream Categorization, Frequency Tables & Static Fixed-Capacity Bins in RAM

Executive Summary: Analyzing category frequency distributions and histograms from file streams. We explore fixed-size category binning, counting algorithm complexity, and replacing dynamic associative maps with static fixed-array frequency tables in embedded telemetry analyzers.

💻 1. Annotated Source Code

#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <map>
using namespace std;

int main() {
	ifstream infile("genres.txt");

	if (!infile) {
		cerr << "Error opening genres.txt.  Aborting..." << endl;
		return 1;
	}

	map<string, int> genreCounts;
	string genre;
	int total = 0;

	while (infile >> genre) {
		genreCounts[genre]++;
		total++;
	}

	infile.close();

	cout << fixed << showpoint << setprecision(2);
	cout << "\nMovie Genre Preferences" << endl;
	cout << "------------------------------" << endl;
	cout << left << setw(15) << "Genre"
		<< right << setw(10) << "Count"
		<< setw(12) << "Percent" << endl;

	cout << "------------------------------" << endl;

	for (const auto& pair : genreCounts) {
		double percent = (static_cast<double>(pair.second) / total) * 100.0;

		cout << left << setw(15) << pair.first
			<< right << setw(10) << pair.second
			<< setw(11) << percent << "%" << endl;
	}

	cout << "------------------------------" << endl;
	cout << "Total responses: " << total << endl;


	return 0;
}

action
comedy
horror
comedy
drama
comedy
action
thriller
drama
comedy
sci-fi
horror
romance
sci-fi
horror
comedy
drama
documentary
comedy
animation

📐 2. Architecture & UML Class Model

📐 Movie Genre Classifier & File Parsing Architecture

+ Public - Private # Protected

<<struct>> MovieEntry Catalog Entry

Attributes / Data Members

+title : std::string

+genre : std::string

<<compilation-unit>> MovieGenreParser Catalog Parser

Attributes / Data Members

-catalog : std::vector<MovieEntry>

Operations / Methods

+parseGenreFile(path: const char*) : void

+filterByGenre(genre: string) : void const

🔗 Architectural Relationships & Hierarchy

MovieGenreParser ◆── populates catalog ◆── MovieEntry

📚 3. Core C++ Concepts Deep-Dive

1. Frequency Binning & Histograms

Counting occurrences of categorical items across a dataset to compute statistical distributions.

⚡ 4. Embedded Systems & Hardware Reality

1. Hardware Event Diagnostic Bins

In automotive ECUs, Diagnostic Trouble Codes (DTCs) and CAN bus message counters use static integer histogram bins in battery-backed SRAM to log fault occurrences across vehicle operational lifetimes.

💡 5. Production-Ready Embedded Refactoring

Fixed-array event diagnostic histogram:

💡 Production-Ready Refactor

#include <cstdint>
#include <array>

enum class FaultCategory : uint8_t {
    OverVoltage = 0,
    UnderVoltage,
    OverTemperature,
    CanBusTimeout,
    SensorMismatch,
    Count // 5 categories
};

class DiagnosticHistogram {
private:
    std::array<uint32_t, static_cast<size_t>(FaultCategory::Count)> counts_{};

public:
    void record_fault(FaultCategory fault) noexcept {
        size_t idx = static_cast<size_t>(fault);
        if (idx < counts_.size()) {
            ++counts_[idx]; // O(1) single-instruction increment!
        }
    }

    uint32_t get_count(FaultCategory fault) const noexcept {
        return counts_[static_cast<size_t>(fault)];
    }
};

📝 Knowledge Verification Quiz

Test your understanding of the C++ concepts and embedded microcontroller trade-offs covered in this guide. Click any option for instant feedback.

Q1. What is the time complexity of incrementing a histogram bin indexed by an enum value in a static array?

A O(1) constant time (direct array index access)

B O(N) linear search time

C O(log N) tree search time

D O(N^2) quadratic time

Detailed Explanation: Indexing an array directly by enum value compiles to a single load/add/store instruction sequence in $O(1)$ time.

Q2. Why is 'std::map<string, int>' suboptimal for histogram counting on microcontrollers?

A std::map dynamically allocates 32-48 byte Red-Black tree nodes on the heap for every unique entry, causing RAM exhaustion and heap fragmentation

B std::map only supports floating point keys

C std::map cannot store numbers

D std::map is deprecated

Detailed Explanation: std::map allocates node objects on the heap, consuming excessive RAM and fragmenting heap memory on microcontrollers.

Q3. What is the standard idiom for tracking the total number of enum values in an enum class?

A Add a final 'Count' element to the enum: enum class Cat { A=0, B, C, Count };

B Use sizeof(Enum)

C Query the compiler version

D Count lines in the header

Detailed Explanation: Appending a Count element automatically sets its value equal to the total number of preceding items.

Q4. Where should diagnostic fault counters in an automotive ECU be stored so they persist across engine restarts?

A In Non-Volatile RAM (NVRAM / battery-backed SRAM / EEPROM)

B On the CPU stack frame

C In the CPU instruction cache

D In .bss section RAM

Detailed Explanation: Diagnostic Trouble Code (DTC) histograms are stored in non-volatile memory (EEPROM / NVRAM) to survive vehicle power-down.