Simplified Producer-Consumer System with Thread-Safe Bounded Storage

Design a simplified, thread‑safe producer‑consumer system that consists of a fixed‑size buffer, a producer, and a consumer.

Buffer (Storage)

The shared buffer holds integers and exposes two non‑blocking operations:

bool insert(int value);
bool remove(int& out);

Rules:

• insert(value) succeeds and returns true only when fewer items than the capacity are present; otherwise it ignores the request and immediately returns false.
• remove(out) succeeds and returns true only when at least one item exists; the oldest item stored is written into out. On failure it returns false.
• The buffer is intended for concurrent use by exactly two threads (a producer and a consumer), so every method must be free of data races.
• Both methods are non‑blocking: a producer never waits when the buffer is full, and a consumer never waits when it is empty.

Producer (Generator)

Generator(unsigned ratePerSecond, Storage& buffer);
void start();
void shutdown();

Requirements:

• ratePerSecond = k means the producer tries to create k items each second.
• The generated values are consecutive non‑negative integers beginning with 0: 0, 1, 2, ….
• When insert fails because the buffer is full, that particular integer is discarded; the producer then generates the next integer on its subsequent attempt (it does not retry the same value).

Consumer

Consumer(unsigned ratePerSecond, Storage& buffer);
void start();
void shutdown();

Requirements:

• ratePerSecond = k means the consumer attempts to retrieve an item k times each second.
• When remove fails because the buffer is empty, that attempt is simply lost; the consumer resumes polling in the next period.

Thread Lifetime

In a driver function (e.g., execute()):

1. Launch one Generator thread.
2. Launch one Consumer thread.
3. Keep both threads alive for a chosen interval.
4. Signal each thread to stop.
5. Join both threads.

Do not embed a fixed duration inside start(). Instead, use a thread‑safe stop indicator, for example std::atomic<bool>.

Discussion Points

• How can a plain bool stop cause a data race?
• What memory ordering does std::atomic<bool> use by default?
• When is memory_order_relaxed sufficient for an isolated stop flag?
• What are the drawbacks of a mutex‑based approach here?
• For exactly one producer and one consumer, how could a lock‑free SPSC ring buffer replace a mutex‑protected queue?
• Contrast SPSC with MPMC queues.

Verify‑the‑Buffer Basic‑Semantics Mode

The first line of input supplies the buffer capacity C and the number of commands Q.

Subsequent Q lines each contain one command:

• STORE x – attempts to insert x; output true or false on its own line.
• TAKE – attempts to remove the oldest item; output the integer on success, else false.
• COUNT – output the current number of items residing in the buffer.

Constraints

• 1 <= C <= 50000
• 1 <= Q <= 150000
• -5 000 000 000 <= item <= 5 000 000 000

Example (as reported)

Input:
2 8
STORE 1
STORE 2
STORE 3
COUNT
TAKE
STORE 4
TAKE
TAKE

Output:
true
true
false
2
1
true
2
4

Example

Input:
2 8
STORE 10
STORE 20
STORE 30
COUNT
TAKE
STORE 40
TAKE
TAKE

Output:
true
true
false
2
10
true
20
40

Explanation:
Capacity is 2. After inserting 10 and 20 the buffer is full, so inserting 30 fails. COUNT reports 2 items. The first TAKE removes 10. Inserting 40 succeeds, filling the buffer again. The next two removes retrieve 20 and then 40.

C = 2
commands = [('STORE', 10), ('STORE', 20), ('STORE', 30), ('COUNT',), ('TAKE',), ('STORE', 40), ('TAKE',), ('TAKE',)]

true
true
false
2
10
true
20
40