int main() {
sThread1.start();
sThread2.start();
sSemaphore1.wait();
sSemaphore2.wait();
sHandler4 = new Handler4(*sLooper2);
while (true) {
Message& msg = sHandler1->obtainMessage(Handler1::MSG_PRINT_INFO);
sHandler1->sendMessage(msg);
sHandler1->obtainMessage(Handler1::MSG_START_ASYNC_TASKS).sendToTarget();
Runnable1* runnable1 = new Runnable1();
sHandler2->postDelayed(runnable1, 100);
sHandler2->removeCallbacks(runnable1);
sHandler2->postDelayed(newRunnable(sClosure1, &Closure1::test, 42), 500);
sHandler3->test();
sHandler4->test();
Thread::sleep(2000);
}
sLooper1->quit();
sThread1.join();
sLooper2->quit();
sThread2.join();
return 0;
}
TEST(SemaphoreTest, test)
{
Semaphore sem;
ASSERT_EQ(sem.wait(100), false);
sem.post();
ASSERT_EQ(sem.wait(100), true);
thread th1([&] {
cout << "post1" << endl;
sem.post();
this_thread::sleep_for(chrono::milliseconds(1000));
cout << "post2" <<endl;
sem.post();
cout << "post3" << endl;
sem.post();
});
sem.wait();
cout << "wait1" << endl;
sem.wait();
cout << "wait2" << endl;
sem.wait();
cout << "wait3" << endl;
th1.join();
}
virtual bool read(ConnectionReader& reader) {
go.wait();
mutex.wait();
bool ok = last.read(reader);
mutex.post();
gone.post();
return ok;
}
void wait() {
stateMutex.wait();
if (signalled) {
stateMutex.post();
return;
}
waiters++;
stateMutex.post();
action.wait();
if (autoReset) {
reset();
}
}
TEST(core, Semaphore)
{
Semaphore s;
ASSERT_FALSE(s.wait(10));
s.signal();
ASSERT_TRUE(s.wait(10));
ASSERT_FALSE(s.wait(10));
s.signal(2);
ASSERT_TRUE(s.wait(10));
ASSERT_TRUE(s.wait(10));
ASSERT_FALSE(s.wait(10));
std::thread t1([&s]() {
ASSERT_FALSE(s.wait(10));
s.wait();
});
std::thread t2([&s]() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
s.signal(2);
s.wait();
});
t1.join();
t2.join();
}
void testSimple()
{
//Some very basic semaphore tests.
Semaphore sem;
sem.signal();
sem.wait();
testTimedElapsed(sem, 100);
sem.signal();
testTimedAvailable(sem);
sem.reinit(2);
sem.wait();
testTimedAvailable(sem);
testTimedElapsed(sem, 5);
}
bool process() {
produce.wait();
if (!active) return false;
mutex.wait();
Bottle b = msgs.front();
msgs.pop_front();
mutex.post();
DummyConnector con;
b.write(con.getWriter());
owner.read(con.getReader());
mutex.wait();
available_threads++;
mutex.post();
return active;
}
// Dump contents of feature (6) MAIL queue to the serial connection to the PC.
// (Data will be passed through the MBED USB connection)
// content is also dumped into a csv file
// car mail semaphore used to protect messages
// Repetition rate 0.05 Hz = 20 seconds
void dumpContents(void const *args){
while(true){
CAR_MAIL_SEM.wait();
while(write > read){
osEvent evt = mail_box.get();
if (evt.status == osEventMail)
{
mail_t *mail = (mail_t*)evt.value.p;
// values sent to csv file
FILE *fp = fopen("/local/Car_Values.csv", "a");
fprintf(fp,"%f ,", mail->speedVal);
fprintf(fp,"%f ,", mail->accelerometerVal);
fprintf(fp,"%f ", mail->breakVal);
fprintf(fp,"\r\n");
fclose(fp);
// values sent to serial port
serial.printf("average speed: %f ,", mail->speedVal);
serial.printf("break value: %f ,", mail->breakVal);
serial.printf("acceleration: %f ,", mail->accelerometerVal);
serial.printf("\r\n");
mail_box.free(mail);
read++;
}
}
CAR_MAIL_SEM.release();
Thread::wait(20000);
}
}
ActionItem *pop()
{
mutex.wait();
ActionItem *ret=actions.pop();
mutex.post();
return ret;
}
void getObjectList(Bottle &reply)
{
double t0=Time::now();
int max_size=0;
vector<Blob> max_blobs;
while(Time::now()-t0<0.5)
{
mutex.wait();
reply.clear();
int size=0;
for(unsigned int i=0; i<blobs.size(); i++)
if(blobs[i].getBest()!="")
size++;
if(max_size<size)
{
max_size=size;
max_blobs=blobs;
}
mutex.post();
Time::delay(0.05);
}
reply.addInt(max_size);
for(unsigned int i=0; i<max_blobs.size(); i++)
if(max_blobs[i].getBest()!="")
reply.addString(max_blobs[i].getBest().c_str());
}
void testTimedElapsed(Semaphore & sem, unsigned time)
{
unsigned now = msTick();
sem.wait(time);
unsigned taken = msTick() - now;
ASSERT(taken >= time && taken < 2*time);
}
// Get the car acceleration and break and calculate speed
// speed semaphores are used so these values are not altered
// any anything process while getting the values.
// repetition rate 20Hz = 0.05 seconds
void carSimulation(void const *args){
while (true) {
// calculate current speed from these values
Speed_SEM.wait();
// both acceleration and break value range between 0 and 1
// engine state is either 0 or 1
float totalAcc = (accelerationValue - brakeValue) * 100;
float time = 0.05;
currentSpeed = (currentSpeed + float(totalAcc * time)) * engineState;
if(currentSpeed < 0)
{
currentSpeed = 0;
}
if(currentSpeed > maxSpeed)
{
currentSpeed = maxSpeed;
}
Speed_SEM.release();
// saves the last 3 speeds
speeds[counter] = currentSpeed;
counter++;
if(counter > 2)
{
counter = 0;
}
Thread::wait(50);
}
}
// Show the average speed value with a RC servo motor
// average speed semaphore is used to hold this value constant
// Repetition rate 1 Hz = 1 second
void showAverageSpeed(){
AVR_SPEED_SEM.wait();
// scales the average speed to the max allowed speed
// servo value is between 0 and 1
servo = 1.0 - (averageSpeed / maxSpeed) ;
AVR_SPEED_SEM.release();
}
void bslmt::QLock_EventFlag::waitUntilSet(int spinRetryCount)
{
Semaphore *flagValue = 0;
// Read flag value with memory barrier, and if it was not set, spin a
// little bit.
int i = 0;
do {
flagValue = d_status;
} while (!flagValue && ++i < spinRetryCount);
if (0 == flagValue) {
// This flag is still unset, use a semaphore to more efficiently wait
// for the flag.
Semaphore *sem = getSemaphoreForCurrentThread();
flagValue = d_status.testAndSwap(0, sem);
if (0 == flagValue ) {
// A semaphore handle has been successfully stored, now wait until
// it is signaled.
sem->wait();
return; // RETURN
}
}
// If we did not wait on the semaphore (and return above), then the flag
// must have been set without a semaphore.
BSLS_ASSERT(flagValue == FLAG_SET_WITHOUT_SEMAPHORE);
}
void onRead(Sound& sound) {
int ct = port.getPendingReads();
//printf("pending reads %d\n", ct);
while (ct>padding) {
ct = port.getPendingReads();
printf("Dropping sound packet -- %d packet(s) behind\n", ct);
port.read();
}
mutex.wait();
/*
if (muted) {
for (int i=0; i<sound.getChannels(); i++) {
for (int j=0; j<sound.getSamples(); j++) {
sound.put(0,j,i);
}
}
}
*/
if (!muted) {
if (put!=NULL) {
put->renderSound(sound);
}
}
if (saving) {
saveFrame(sound);
}
mutex.post();
Time::yield();
}
bool saveFile(const char *name) {
mutex.wait();
saving = false;
Sound total;
total.resize(samples,channels);
long int at = 0;
while (!sounds.is_empty()) {
Sound tmp;
sounds.dequeue_head(tmp);
for (int i=0; i<channels; i++) {
for (int j=0; j<tmp.getSamples(); j++) {
total.set(tmp.get(j,i),at+j,i);
}
}
total.setFrequency(tmp.getFrequency());
at += tmp.getSamples();
}
mutex.post();
bool ok = write(total,name);
if (ok) {
printf("Wrote audio to %s\n", name);
}
samples = 0;
channels = 0;
return ok;
}
void testTimedElapsed(Semaphore & sem, unsigned time, unsigned loopCount)
{
unsigned __int64 sumTaken = 0;
unsigned maxTaken = 0;
unsigned timeLimit = 2 * time;
unsigned numberOfOut = 0;
bool isSignaled = false;
PROGLOG("Start loop");
for (int i = 0 ; i <= loopCount; i++)
{
unsigned now = msTick();
if (sem.wait(time))
{
isSignaled = true;
break;
}
unsigned taken = msTick() - now;
sumTaken += taken;
maxTaken = (taken > maxTaken ? taken : maxTaken);
numberOfOut += (taken > timeLimit ? 1 : 0);
}
VStringBuffer errMsg("values: time: %d, loop: %d, sum taken: %llu, average taken: %llu, max taken: %d, out of limit: %d times, signaled: %s",
time, loopCount, sumTaken, sumTaken/loopCount, maxTaken, numberOfOut, (isSignaled ? "yes" : "no"));
CPPUNIT_ASSERT_MESSAGE(errMsg.str(), 0 == numberOfOut && !isSignaled );
PROGLOG("%s", errMsg.str());
}
void sendNow(ActionItem *item)
{
mutex.wait();
actions.clear();
_send(item);
mutex.post();
}
void update() {
Bottle& status = port.prepare();
mutex.wait();
status.clear();
addQueue(status);
mutex.post();
port.write();
}
virtual bool read(ConnectionReader& reader) override {
go.wait();
mutex.lock();
bool ok = last.read(reader);
mutex.unlock();
gone.post();
return ok;
}
void testTimedAvailable(Semaphore & sem)
{
unsigned now = msTick();
sem.wait(100);
unsigned taken = msTick() - now;
//Shouldn't cause a reschedule, definitely shouldn't wait for 100s
ASSERT(taken < 5);
}
void onRead(Bottle &v)
{
mutex.wait();
Datum=v;
//Time::delay(5);
mutex.post();
fprintf(stderr, "Callback got: %s\n",Datum.toString().c_str());
}
BigRealResourcePool &getInstance() {
m_gate.wait();
if(m_instance == NULL) {
m_instance = new BigRealResourcePool; TRACE_NEW(m_instance);
}
m_gate.signal();
return *m_instance;
}
// Read brake and accelerator values from variable resistors
// input semaphore is so these values are not changed while reading them
// Repetition rate 10Hz = 0.1 seconds
void readBreakAndAccel(void const *args){
while (true) {
INPUT_SEM.wait();
accelerationValue = acceleratorPedal.read();
brakeValue = brakePedal.read();
INPUT_SEM.release();
Thread::wait(100);
}
}
void barber(){
while(true){
semCustomers.wait();
bool blockBarber = false;
if(cntCustomers == 0)
blockBarber = true;
semCustomers.signal();
if(blockBarber)
sleep.wait();
mutex.signal();
semCustomers.wait();
cntCustomers--;
semCustomers.signal();
}
}
// Read the two turn indicator switches.
// input semaphore used to protect values
// Repetition rate 0.5 Hz = 2 seconds
void getIndicators(void const *args){
while(true){
INPUT_SEM.wait();
leftLightState = leftIndicatorSwitch;
rightLightState = rightIndicatorSwitch;
INPUT_SEM.release();
Thread::wait(2000);
}
}
bool close() {
port.close();
mutex.wait(); // onRead never gets called again once it finishes
//free the memory that's been mapped to write the audio data
munmap(mappedAudioData,kMappedFileSize_samples*sizeof(short));
return true;
}
static void init_netif(ip_addr_t *ipaddr, ip_addr_t *netmask, ip_addr_t *gw) {
tcpip_init(tcpip_init_done, NULL);
tcpip_inited.wait();
memset((void*) &lpcNetif, 0, sizeof(lpcNetif));
netif_add(&lpcNetif, ipaddr, netmask, gw, NULL, lpc_enetif_init, tcpip_input);
netif_set_default(&lpcNetif);
netif_set_status_callback(&lpcNetif, netif_status_callback);
}
void testTimedElapsed(Semaphore & sem, unsigned time)
{
unsigned now = msTick();
sem.wait(time);
unsigned taken = msTick() - now;
VStringBuffer errMsg("values: time: %u, taken: %u", time, taken);
CPPUNIT_ASSERT_MESSAGE(errMsg.str(), taken >= time && taken < 2*time);
PROGLOG("%s", errMsg.str());
}
void drawObj(string &obj_name)
{
draw_mutex.wait();
if(obj_name=="draw")
blob_draw=!blob_draw;
else
current_draw_name=obj_name;
draw_mutex.post();
}
