front::Schedule Struct Reference

#include <SignalVk.h>

Public Types
typedef UINT16	tpCnt
typedef UINT32	tpOrd

Public Member Functions
void	start ()
void	stop ()
tpOrd	wakeup (bool boss=false)
void	gohome (tpOrd order)
bool	rollcall (uint64_t num)
void	EnsureEscapeEnd ()
tpOrd	wakeup (tpCnt kumi, bool tyo=false)
void	gohome (tpCnt kumi, tpCnt sima)
bool	rollcall (tpCnt kumi, uint32_t num)

Public Attributes
bool	escape
uint64_t	escapeID
CRITICAL_SECTION	gCs
const uint64_t	seed = 0x19f093ab37c01fULL
struct {
uint64_t   fmly64
uint32_t   fmly32 [64]
uint32_t *   fmlyNext
}	gene
struct {
uint64_t   fmly64
uint32_t   fmly32 [64]
uint32_t *   fmlyNext
}	mask

Detailed Description

Definition at line 92 of file SignalVk.h.

Member Typedef Documentation

tpCnt

typedef UINT16 front::Schedule::tpCnt

Definition at line 94 of file SignalVk.h.

tpOrd

typedef UINT32 front::Schedule::tpOrd

Definition at line 95 of file SignalVk.h.

Member Function Documentation

EnsureEscapeEnd()

void front::Schedule::EnsureEscapeEnd

(

)

Definition at line 133 of file SignalVk.cpp.

                                   {
 
        if (escape) {
            EnterCriticalSection(&gCs);
            gene.fmly64 = escapeID;
 
            LeaveCriticalSection(&gCs);
            escape = false;
        }
        else {
 
        };
    };

gohome() [1/2]

void front::Schedule::gohome	(	tpCnt	kumi,
		tpCnt	sima
	)

Definition at line 178 of file SignalVk.cpp.

                                                {
        InterlockedBitTestAndSet((LONG*)&gene.fmly32[kumi], sima);
    };

gohome() [2/2]

void front::Schedule::gohome

(

tpOrd

order

)

Definition at line 114 of file SignalVk.cpp.

                                      {
        InterlockedBitTestAndSet64((LONG64*)&gene.fmly64, (LONG64)order);
    };

rollcall() [1/2]

bool front::Schedule::rollcall	(	tpCnt	kumi,
		uint32_t	num
	)

assert(room[curry.key].table[curry.buc].val == room[curry.key].table[curry.buc].key);

Definition at line 181 of file SignalVk.cpp.

                                                    {
 
 
        while (num != _InterlockedCompareExchange(&gene.fmly32[kumi], mask.fmly32[kumi], num)) {
 
            std::this_thread::sleep_for(std::chrono::nanoseconds(100));
        };
 
 
 
 
 
        return true;
    };

rollcall() [2/2]

bool front::Schedule::rollcall

(

uint64_t

num

)

assert(room[curry.key].table[curry.buc].val == room[curry.key].table[curry.buc].key);

Definition at line 117 of file SignalVk.cpp.

                                        {
 
        escape = true; escapeID = num;
        while (num != _InterlockedCompareExchange(&gene.fmly64, mask.fmly64, num)) {
 
 
            std::this_thread::sleep_for(std::chrono::nanoseconds(100));
 
        };
        escape = false;
 
 
 
        return true;
    };

start()

void front::Schedule::start

(

)

memset(mask.fmly32, 0, 4 * 64);

memset(gene.fmly32, 0, 4 * 64);

Definition at line 46 of file SignalVk.cpp.

                         {
        InitializeCriticalSectionAndSpinCount(&gCs, 8000);
        mask = { 0,{0},nullptr }; 
        gene = { 0,{0},nullptr }; 
    };

stop()

void front::Schedule::stop

(

)

Definition at line 51 of file SignalVk.cpp.

                        {
        DeleteCriticalSection(&gCs);
        if (gene.fmlyNext != nullptr) delete[] gene.fmlyNext;
        mask = { 0,{0},nullptr };
        gene = { 0,{0},nullptr };
 
    };

wakeup() [1/2]

Schedule::tpOrd front::Schedule::wakeup

(

bool

boss = false

)

gene.fmly32 = new uint32_t[64 * 32];

Definition at line 59 of file SignalVk.cpp.

                                            {
 
        static tpCnt member = -1;
        constexpr  tpCnt  giant64 = 64 - 1;
        constexpr  tpCnt  giant64x32 = 64 * 32 - 1;
        constexpr  tpCnt  giant64x32x32 = 64 * 32 * 32 - 1;
 
        if (boss) {
 
            uint64_t id = _InterlockedCompareExchange(&mask.fmly64, 0, gene.fmly64);
            if (id == gene.fmly64) {
                member = -1;
                gene.fmly64 = 0;
                escape = false;
            }
            else {
                log_bad("a busy mainstream.\n");
            }
 
            return 0;
        }
        else {
 
 
            tpOrd  ID = 0;
            tpCnt order = (tpCnt)(InterlockedIncrement16((SHORT*)&member));
 
            if (order > giant64) {
                order -= 64;
                if (order > giant64x32) {
                    log_bad("memory out\n");
                }
                else {
 
                    if (gene.fmly32 == nullptr) {
                        EnterCriticalSection(&gCs);
                        LeaveCriticalSection(&gCs);
                    }
 
                    ID = (order / 32);
                    ID |= ((order % 32) << 6);
 
                    InterlockedBitTestAndSet((volatile LONG*)(&mask.fmly32[(order / 32)]), (LONG)(order % 32));
                }
            }
            else {
 
                InterlockedBitTestAndSet64((LONG64*)&mask.fmly64, (LONG64)order);
                ID = order;
 
            }
            return ID;
        }
    };

wakeup() [2/2]

Schedule::tpOrd front::Schedule::wakeup	(	tpCnt	kumi,
		bool	tyo = false
	)

Definition at line 147 of file SignalVk.cpp.

                                                       {
 
        static tpCnt member[64] = { 0 };
        constexpr  tpCnt  giant64 = 64 - 1;
        constexpr  tpCnt  giant64x32 = 64 * 32 - 1;
        constexpr  tpCnt  giant64x32x32 = 64 * 32 * 32 - 1;
 
        if (tyo) {
 
            uint64_t id = _InterlockedCompareExchange(&mask.fmly32[kumi], 0, gene.fmly32[kumi]);
            if (id == gene.fmly32[kumi]) {
                member[kumi] = -1;
                gene.fmly32[kumi] = 0;
            }
            else {
                log_bad("a busy mainstream.\n");
            }
 
            return 0;
        }
 
 
 
    
        tpCnt order = (tpCnt)(InterlockedIncrement16((SHORT*)&member[kumi])) % 32;
 
        InterlockedBitTestAndSet((volatile LONG*)(&mask.fmly32[kumi]), (LONG)(order));
 
        return order;
 
    };

Member Data Documentation

escape

bool front::Schedule::escape

Definition at line 96 of file SignalVk.h.

escapeID

uint64_t front::Schedule::escapeID

Definition at line 97 of file SignalVk.h.

fmly32

uint32_t front::Schedule::fmly32[64]

Definition at line 105 of file SignalVk.h.

fmly64

uint64_t front::Schedule::fmly64

Definition at line 104 of file SignalVk.h.

fmlyNext

uint32_t* front::Schedule::fmlyNext

Definition at line 106 of file SignalVk.h.

gCs

CRITICAL_SECTION front::Schedule::gCs

Definition at line 98 of file SignalVk.h.

struct { ... } front::Schedule::gene

struct { ... } front::Schedule::mask

seed

const uint64_t front::Schedule::seed = 0x19f093ab37c01fULL

Definition at line 99 of file SignalVk.h.

---

The documentation for this struct was generated from the following files:

• SignalVk.h
• SignalVk.cpp