CriticalSection and Mutex locks work unexpectedly - c

Question

I have been given the homework of making 5 threads as "philosophers" and each of them has to lock "eat" 2 synchronization locks simultaneously. Each thread must do this a million times.
The other part of this homework is to make the "philosophers" processes, and the locks mutex's.
I have made this code for the threaded part, and while it does technically work, the result isn't what I'd expect. The code has a logging system in which a red [NUM-x] means NUM thread attempted to lock two locks and failed to do so. And a green [NUM1-NUM2] means NUM1 thread successfully locked and unlocked 2 threads for the NUM2'd time.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <Windows.h>
#define CHOPSTICKS 5
#define PEOPLE 5
#define EAT_AMOUNT 1000000
#define MIN 2
#define INVALID -1
#define PAUSE printf("\n\n"); system("pause")
CRITICAL_SECTION chopsticks[CHOPSTICKS];
HANDLE chopsticksMutex[CHOPSTICKS]; // used for the mutex part of this question
VOID WINAPI eatThreadCritSect(LPVOID params) {
int index[MIN] = { 0 };
int usage = 0;
BOOL usageFlag = FALSE;
for (int i = 0; i < MIN; i++) {
index[i] = INVALID;
}
for (int i = 0; i < EAT_AMOUNT; i++) {
while (usage != MIN) {
for (int j = 0; j < CHOPSTICKS; j++) {
for (int k = 0; k < MIN && !usageFlag; k++) {
if (index[k] == j) {
usageFlag = TRUE;
}
}
if (!usageFlag) {
for (int k = 0; k < MIN && !usageFlag; k++) {
if (index[k] == INVALID) {
if (TryEnterCriticalSection(&chopsticks[j])) {
index[k] = j;
usage++;
}
usageFlag = TRUE;
}
}
}
usageFlag = FALSE;
}
for (int j = 0; j < MIN; j++) {
if (index[j] != INVALID) {
LeaveCriticalSection(&chopsticks[index[j]]);
index[j] = INVALID;
}
}
if (usage != MIN) {
printf("\x1b[31m[%d-X]", (int)params + 1); // CHOPSTICKS UNAVAILABLE
usage = 0;
}
}
printf("\x1b[32m[%d-%d]", ((int)params + 1), i + 1); // ATE SUCCESSFULLY
usage = 0;
}
}
void criticalEat() {
HANDLE hThreads[PEOPLE];
time_t begin = time(NULL);
for (int i = 0; i < PEOPLE; i++) {
hThreads[i] = CreateThread(NULL, 0, eatThreadCritSect, i, 0, NULL);
}
for (int i = 0; i < PEOPLE; i++) {
if (hThreads[i]) {
WaitForSingleObject(hThreads[i], INFINITE);
CloseHandle(hThreads[i]);
}
}
time_t end = time(NULL);
printf("\n\n\x1b[0mThey're now very saturated. It took them %llu seconds to eat with critical sections.", (end - begin));
}
void mutexEat() { // used for the mutex part of this question
PROCESS_INFORMATION hProcesses[PEOPLE];
CHAR name[] = "philosopher.exe 0";
time_t begin = time(NULL);
for (int i = 0; i < PEOPLE; i++) {
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
name[strlen(name) - 1] = i + '0';
CreateProcessA("philosopher.exe", name, NULL, NULL, FALSE, 0, NULL, NULL, &si, &hProcesses[i]);
}
for (int i = 0; i < PEOPLE; i++) {
WaitForSingleObject(hProcesses[i].hProcess, INFINITE);
CloseHandle(hProcesses[i].hThread);
CloseHandle(hProcesses[i].hProcess);
}
time_t end = time(NULL);
printf("\n\n\x1b[0mThey're now extremely fat and about to explode. It took them %llu seconds to eat with mutex's.", (end - begin));
}
int main() {
// used for the mutex part of this question
CHAR name[] = { "STICK_0" };
for (int i = 0; i < CHOPSTICKS; i++) {
name[strlen(name) - 1] = '0' + (i + 1);
InitializeCriticalSection(&chopsticks[i]);
chopsticksMutex[i] = CreateMutexA(NULL, FALSE, name);
}
criticalEat();
PAUSE;
mutexEat();
for (int i = 0; i < CHOPSTICKS; i++) {
DeleteCriticalSection(&chopsticks[i]);
if (chopsticksMutex[i]) { // preventing annoying warning
CloseHandle(chopsticksMutex[i]);
}
}
printf("\n\nI'm honestly surprised they made it. Why are we torturing philosophers?");
PAUSE;
return 0;
}
If I run this code, it will in a very technical sense work. However, the logged results show only green success logs, leading me to believe one of the lock checks is flawed. However, if I try to run the program in debug mode with breakpoints, and run it very slowly, red unsuccessful logs do appear. The same thing happens if I add a Sleep(1). Red logs appear. I believe red logs should appear regardless of these slowing measures, since 5 threads are trying to access 5 locks at the same time, each thread taking 2 locks for themselves.
As for the mutex part, here it is:
#include <Windows.h>
#include <stdio.h>
#define CHOPSTICKS 5
#define MIN 2
#define INVALID -1
#define EAT_AMOUNT 1000000
int main(int argc, char** argv) {
HANDLE chopsticksMutex[CHOPSTICKS];
int index[MIN] = { 0 };
int usage = 0;
BOOL usageFlag = FALSE;
CHAR name[] = { "STICK_0" };
for (int i = 0; i < CHOPSTICKS; i++) {
name[strlen(name) - 1] = '0' + (i + 1);
chopsticksMutex[i] = CreateMutexA(NULL, FALSE, name);
}
for (int i = 0; i < MIN; i++) {
index[i] = INVALID;
}
for (int i = 0; i < EAT_AMOUNT; i++) {
while (usage != MIN) {
for (int j = 0; j < CHOPSTICKS; j++) {
for (int k = 0; k < MIN && !usageFlag; k++) {
if (index[k] == j) {
usageFlag = TRUE;
}
}
if (!usageFlag) {
for (int k = 0; k < MIN && !usageFlag; k++) {
if (index[k] == INVALID) {
if (WaitForSingleObject(chopsticksMutex[j], 0) != WAIT_ABANDONED) {
index[k] = j;
usage++;
}
usageFlag = TRUE;
}
}
}
usageFlag = FALSE;
}
for (int j = 0; j < MIN; j++) {
if (index[j] != INVALID) {
ReleaseMutex(chopsticksMutex[index[j]]);
index[j] = INVALID;
}
}
if (usage != MIN) {
printf("\x1b[31m[%c-X]", argv[1][0] + 1); // CHOPSTICKS UNAVAILABLE
usage = 0;
}
}
printf("\x1b[32m[%c-%d]", argv[1][0], i + 1); // ATE SUCCESSFULLY
usage = 0;
}
return 0;
}
Now, from what I've been taught, Mutex locks, in general, are slower. But here again, there are no red logs indicating that there was a failed attempt to lock 2 locks, and the Mutex implementation is faster, even though it makes no sense.
Does what I'm saying even make any sense? In multi-threaded programming, should I expect this behaviour? I'm pretty sure I should expect a couple of red logs, without intentionally bottlenecking the program.