How to Create Multi-Unit Acquire/Release with std::counting_semaphore in C++20 for a Producer-Consumer Scenario?

Question

In the context of semaphore definitions as originally proposed by Dijkstra, a semaphore could be incremented or decremented by an arbitrary count, facilitating operations where a thread might need to wait for or release multiple units of a resource at once.

Specifically, Dijkstra described operations like this:

function V(semaphore S, integer I):
    [S ← S + I]

function P(semaphore S, integer I):
    repeat:
        [if S ≥ I:
        S ← S − I
        break]

However, in C++20, the introduction of std::counting_semaphore provides acquire and release methods that do not accept any arguments, which means they can only operate one unit at a time. This poses a challenge in scenarios such as the typical producer-consumer pattern, where a consumer might need to wait until a specific number of items (e.g., 10) are available in a buffer before proceeding (P(s,10) or, hypothetically, sem_empty.acquire(10)).

My workaround involves using a loop to call acquire or release the required number of times, which seems inefficient and inelegant:

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <semaphore>
#include <cstdlib>

#define MAX 100
static std::vector<int> buffer;
static std::mutex mtx;
static std::counting_semaphore<MAX> sem_empty(MAX);
static std::counting_semaphore<MAX> sem_full(0);

void consumer(int N) {
    while (true) {
        for (int i = 0; i < N; ++i) {
            sem_full.acquire();
        }
        {
            std::lock_guard<std::mutex> lock(mtx);
            for (int i = 0; i < N; ++i) {
                if (!buffer.empty()) {
                    int data = buffer.back();
                    buffer.pop_back();
                    std::cout << "Consumer: " << data << std::endl;
                }
            }
        }
        for (int i = 0; i < N; ++i) {
            sem_empty.release();
        }
    }
}

void producer() {
    while (true) {
        const int data = std::rand() % 100;
        sem_empty.acquire();
        {
            std::lock_guard<std::mutex> lock(mtx);
            buffer.push_back(data);
            std::cout << "Producer: " << data << std::endl;
        }
        sem_full.release();
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer, 4); // Suppose that the consumer consumes 4 items at a time
    t1.join();
    t2.join();
}

This approach feels clunky and suboptimal, especially considering the original intent behind semaphores to manage multiple resources more succinctly. Is there a more elegant or efficient way to implement this behavior using std::counting_semaphore in C++20, or is a different synchronization mechanism more appropriate for this scenario?