nlib
misc/threading/semaphore/semaphore.cpp

A semaphore sample. A semaphore is a mechanism to use a limited resource between multiple threads.

Perform the following processes in the main thread.

  1. Use nn::nlib::threading::Semaphore::Init to set the maximum value to 2 and the initial semaphore count to 0, where the semaphore is unobtainable.
  2. Start kNumThread threads.
  3. Releasing the semaphore and setting the semaphore count to 2 allows a maximum of two threads to get a semaphore.

In other threads, perform the following processes with the SemaphoreDemoFunc() function.

  1. Waits until a semaphore is acquired in the nn::nlib::threading::Semaphore::Acquire function.
  2. Sleeps twice for one millisecond each time when a semaphore is acquired (and decrements the semaphore count by 1). Up to two threads can run this process.
  3. Releases a semaphore in the nn::nlib::threading::Semaphore::Release function, incrementing semaphore by 1.
/*--------------------------------------------------------------------------------*
Project: CrossRoad
Copyright (C)Nintendo All rights reserved.
These coded instructions, statements, and computer programs contain proprietary
information of Nintendo and/or its licensed developers and are protected by
national and international copyright laws. They may not be disclosed to third
parties or copied or duplicated in any form, in whole or in part, without the
prior written consent of Nintendo.
The content herein is highly confidential and should be handled accordingly.
*--------------------------------------------------------------------------------*/
using ::nlib_ns::threading::Semaphore;
using ::nlib_ns::threading::Thread;
const int kNumThread = 10;
Thread g_th[kNumThread];
Semaphore g_semaphore;
void SemaphoreDemoFunc(int threadNum) {
nlib_printf(" Thread %d, Trying wait semaphore\n", threadNum);
g_semaphore.Acquire();
nlib_printf(" Thread %d, Success get semaphore\n", threadNum);
for (int i = 0; i < 2; ++i) {
nlib_printf(" Thread %d, doing jobs using limited resource\n", threadNum);
}
nlib_printf(" Thread %d, Release semaphore\n", threadNum);
g_semaphore.Release(NULL);
}
bool SemaphoreDemo() {
nlib_printf("-- Semaphore Demo --\n");
// initializes Semaphore
e = g_semaphore.Init(0);
if (e != 0) return false;
int i;
for (i = 0; i < kNumThread; ++i) {
e = g_th[i].Start(SemaphoreDemoFunc, i);
NLIB_ASSERT_NOERR(e);
}
// kNumThread threads share 2 resources
nlib_printf("Main Thread: Release semaphores\n");
e = g_semaphore.Release(2, NULL);
NLIB_ASSERT_NOERR(e);
for (i = 0; i < kNumThread; ++i) {
e = g_th[i].Join();
NLIB_ASSERT_NOERR(e);
}
return true;
}
static bool SampleMain(int, char**) { return SemaphoreDemo(); }
NLIB_MAINFUNC