Error on SharedMutex & SharedTimedMutex

[samchon]

Summary

• TSTL Version: 2.1.3
• Expected behavior: Writing and reading locks are not mutual exclusive.
• Actual behavior: Both of them must be mutual exclusive.

Code occuring bug

import std = require("tstl");

const enum Status
{
    START_READING = "Start Reading",
    END_READING = "End Reading",
    START_WRITING = "Start Writing",
    END_WRITING = "End Writing"
}
const MAGNIFIER: number = 3;

async function write(mutex: std.SharedTimedMutex, statusList: std.Pair<Status, number>[]): Promise<void>
{
    for (let i: number = 0; i < MAGNIFIER * 10; ++i)
    {
        // JUST DELAY FOR SAFETY
        await std.sleep_for(100);
        let time: number = Date.now();

        // DO WRITE
        await mutex.lock();
        {
            let now: number = Date.now();
            statusList.push(new std.Pair(Status.START_WRITING, now - time));
            
            await std.sleep_for(50);
            statusList.push(new std.Pair(Status.END_WRITING, Date.now() - now));
        }
        await mutex.unlock();
    }
}

async function read(mutex: std.SharedTimedMutex, statusList: std.Pair<Status, number>[]): Promise<void>
{
    for (let i: number = 0; i < MAGNIFIER * 100; ++i)
    {
        let time: number = Date.now();

        // DO READ
        await mutex.lock_shared();
        {
            let now: number = Date.now();
            statusList.push(new std.Pair(Status.START_READING, now - time));

            await std.sleep_for(10);
            statusList.push(new std.Pair(Status.END_READING, Date.now() - now));
        }
        await mutex.unlock_shared();
    }
}

async function main(): Promise<void>
{
    let mutex: std.SharedTimedMutex = new std.SharedTimedMutex();
    let statusList: std.Pair<Status, number>[] = [];

    try
    {
        let promises: Promise<void>[] = [];
        for (let i: number = 0; i < 25; ++i)
            promises.push(read(mutex, statusList));
        promises.push(write(mutex, statusList));

        await Promise.all(promises);

        let reading: number = 0;
        let writing: number = 0;
        
        for (let i: number = 0; i < statusList.length; ++i)
        {
            let status: Status = statusList[i].first;

            if (status === Status.START_READING)
                ++reading;
            else if (status === Status.START_WRITING)
                ++writing;
            else if (status === Status.END_READING)
                --reading;
            else
                --writing;
            
            if (writing > 0 && reading > 0)
                throw new Error(`Error on SharedTimeMutex; reading and writing at the same time at ${i}`);
        }
    }
    catch (exp)
    {
        for (let pair of statusList)
            console.log(pair.first, pair.second);
        throw exp;
    }
}
main();

[samchon]

Until now, I'd implemented mutexes for one by one.

• Mutex.ts
• TimedMutex.ts
• SharedMutex.ts
• SharedTimedMutex.ts

However, from now on, I'll implement only SharedTimedMutex class and let other mutexes to capsulize the SharedTimedMutex instance like below:

export class TimedMutex
{
    private mtx_: SharedTimedMutex = new SharedTimedMutex();

    public lock(): Promise<void>
    {
        return this.mtx_.lock();
    }
    public unlock(): Promise<void>
    {
        return this.mtx_.unlock();
    }

    public try_lock(): Promise<boolean>
    {
        return this.mtx_.try_lock();
    }
    public try_lock_for(ms: number): Promise<boolean>
    {
        return this.mtx_.try_lock_for(ms);
    }
    public try_lock_until(at: Date): Promise<boolean>
    {
        return this.mtx_.try_lock_until(at);
    }
}

[samchon]

Have fixed until v2.1.6 patch and v2.2 update.

From the implementation, I can assure that writing and reading locks are mutual exclusive, but I can't sure that timed locks are working correctly. If someone can help me to implement the timed lock, or provide me the teseting code for the timed locks, then please help me.