void CComponentInputKeyboard::InitKeyboard(CInput* pcInput)
{
InitLocks(pcInput);
InitModifiers(pcInput);
InitButttons(pcInput);
InitNumpadRemap();
}
int main(int argc, char **argv)
{
if(InitLocks("qlite", "sapc13", 5468))
{
if(GetLock(1, 5)==0)
printf("Got lock!\n");
else
printf("Lock denied!\n");
/*
if(GetLock(1, 5)==0)
printf("Got lock!\n");
else
printf("Lock denied!\n");
if(ReleaseLock(1))
printf("Lock released!\n");
else
printf("Couldn't release lock!\n");
if(GetLock(1, 5)==0)
printf("Got lock!\n");
else
printf("Lock denied!\n");
if(ReleaseLock(2))
printf("Lock released!\n");
else
printf("Couldn't release lock!\n");
*/
}
return(0);
}
static Status wutil_Init()
{
InitLocks();
ForciblyLoadUser32Dll();
EnableLowFragmentationHeap();
ReadCommandLine();
GetDirectories();
ImportWow64Functions();
DetectWow64();
return INFO::OK;
}
/**************************************************
* Main *
**************************************************/
int main(int argc, const char* argv[]) {
parseArgs(argc, argv);
// Print("main thread starting the test..."); // FOR DEBUG
InitLocks();
if (!createThreads()) { // returns true if all threads were created successfully
ErrorExit(RES_CREATE_FAILED);
}
waitForThreads();
waitOrExit();
Print("main thread is calling return from main()"); // FOR DEBUG
return RES_SUCCESS;
}
/**************************************************
* Main *
**************************************************/
int main() {
InitLocks();
if (!createThreads(numOfFirstCreateLoop, (void*)DoDummyThread)) { // create first batch of dummy threads
ErrorExit(RES_CREATE_FAILED);
}
Print("Creating the exit thread");
if (!createThreads(1, (void*)DoExitThread)) { // create the exit thread
ErrorExit(RES_CREATE_FAILED);
}
if (!createThreads(numOfSecondCreateLoop, (void*)DoDummyThread)) { // create second batch of dummy threads
ErrorExit(RES_CREATE_FAILED);
}
DoSleep(1000); // wait here to be terminated
// Failsafe - this should not be reached but we want to avoid a hung test.
ErrorExit(RES_EXIT_TIMEOUT); // never returns
// This can't be reached, simply for successful compilation.
return RES_SUCCESS;
}
/*
* CreateSharedMemoryAndSemaphores
* Creates and initializes shared memory and semaphores.
*
* This is called by the postmaster or by a standalone backend.
* It is also called by a backend forked from the postmaster in the
* EXEC_BACKEND case. In the latter case, the shared memory segment
* already exists and has been physically attached to, but we have to
* initialize pointers in local memory that reference the shared structures,
* because we didn't inherit the correct pointer values from the postmaster
* as we do in the fork() scenario. The easiest way to do that is to run
* through the same code as before. (Note that the called routines mostly
* check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
* This is a bit code-wasteful and could be cleaned up.)
*
* If "makePrivate" is true then we only need private memory, not shared
* memory. This is true for a standalone backend, false for a postmaster.
*/
void
CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
{
if (!IsUnderPostmaster)
{
PGShmemHeader *seghdr;
Size size;
int numSemas;
/*
* Size of the Postgres shared-memory block is estimated via
* moderately-accurate estimates for the big hogs, plus 100K for the
* stuff that's too small to bother with estimating.
*
* We take some care during this phase to ensure that the total size
* request doesn't overflow size_t. If this gets through, we don't
* need to be so careful during the actual allocation phase.
*/
size = 100000;
size = add_size(size, SpinlockSemaSize());
size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
sizeof(ShmemIndexEnt)));
size = add_size(size, BufferShmemSize());
size = add_size(size, LockShmemSize());
size = add_size(size, PredicateLockShmemSize());
size = add_size(size, ProcGlobalShmemSize());
size = add_size(size, XLOGShmemSize());
size = add_size(size, CLOGShmemSize());
size = add_size(size, SUBTRANSShmemSize());
size = add_size(size, TwoPhaseShmemSize());
size = add_size(size, BackgroundWorkerShmemSize());
size = add_size(size, MultiXactShmemSize());
size = add_size(size, LWLockShmemSize());
size = add_size(size, ProcArrayShmemSize());
size = add_size(size, BackendStatusShmemSize());
size = add_size(size, SInvalShmemSize());
size = add_size(size, PMSignalShmemSize());
size = add_size(size, ProcSignalShmemSize());
size = add_size(size, CheckpointerShmemSize());
size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, ReplicationSlotsShmemSize());
size = add_size(size, WalSndShmemSize());
size = add_size(size, WalRcvShmemSize());
size = add_size(size, BTreeShmemSize());
size = add_size(size, SyncScanShmemSize());
size = add_size(size, AsyncShmemSize());
#ifdef EXEC_BACKEND
size = add_size(size, ShmemBackendArraySize());
#endif
/* freeze the addin request size and include it */
addin_request_allowed = false;
size = add_size(size, total_addin_request);
/* might as well round it off to a multiple of a typical page size */
size = add_size(size, 8192 - (size % 8192));
elog(DEBUG3, "invoking IpcMemoryCreate(size=%zu)", size);
/*
* Create the shmem segment
*/
seghdr = PGSharedMemoryCreate(size, makePrivate, port);
InitShmemAccess(seghdr);
/*
* Create semaphores
*/
numSemas = ProcGlobalSemas();
numSemas += SpinlockSemas();
PGReserveSemaphores(numSemas, port);
}
else
{
/*
* We are reattaching to an existing shared memory segment. This
* should only be reached in the EXEC_BACKEND case, and even then only
* with makePrivate == false.
*/
#ifdef EXEC_BACKEND
Assert(!makePrivate);
#else
elog(PANIC, "should be attached to shared memory already");
#endif
}
/*
* Set up shared memory allocation mechanism
*/
if (!IsUnderPostmaster)
InitShmemAllocation();
/*
* Now initialize LWLocks, which do shared memory allocation and are
* needed for InitShmemIndex.
*/
CreateLWLocks();
/*
* Set up shmem.c index hashtable
*/
InitShmemIndex();
/*
* Set up xlog, clog, and buffers
*/
XLOGShmemInit();
CLOGShmemInit();
SUBTRANSShmemInit();
MultiXactShmemInit();
InitBufferPool();
/*
* Set up lock manager
*/
InitLocks();
/*
* Set up predicate lock manager
*/
InitPredicateLocks();
/*
* Set up process table
*/
if (!IsUnderPostmaster)
InitProcGlobal();
CreateSharedProcArray();
CreateSharedBackendStatus();
TwoPhaseShmemInit();
BackgroundWorkerShmemInit();
/*
* Set up shared-inval messaging
*/
CreateSharedInvalidationState();
/*
* Set up interprocess signaling mechanisms
*/
PMSignalShmemInit();
ProcSignalShmemInit();
CheckpointerShmemInit();
AutoVacuumShmemInit();
ReplicationSlotsShmemInit();
WalSndShmemInit();
WalRcvShmemInit();
/*
* Set up other modules that need some shared memory space
*/
BTreeShmemInit();
SyncScanShmemInit();
AsyncShmemInit();
#ifdef EXEC_BACKEND
/*
* Alloc the win32 shared backend array
*/
if (!IsUnderPostmaster)
ShmemBackendArrayAllocation();
#endif
/* Initialize dynamic shared memory facilities. */
if (!IsUnderPostmaster)
dsm_postmaster_startup();
/*
* Now give loadable modules a chance to set up their shmem allocations
*/
if (shmem_startup_hook)
shmem_startup_hook();
}
/*
* CreateSharedMemoryAndSemaphores
* Creates and initializes shared memory and semaphores.
*
* This is called by the postmaster or by a standalone backend.
* It is also called by a backend forked from the postmaster in the
* EXEC_BACKEND case. In the latter case, the shared memory segment
* already exists and has been physically attached to, but we have to
* initialize pointers in local memory that reference the shared structures,
* because we didn't inherit the correct pointer values from the postmaster
* as we do in the fork() scenario. The easiest way to do that is to run
* through the same code as before. (Note that the called routines mostly
* check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
* This is a bit code-wasteful and could be cleaned up.)
*
* If "makePrivate" is true then we only need private memory, not shared
* memory. This is true for a standalone backend, false for a postmaster.
*/
void
CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
{
if (!IsUnderPostmaster)
{
PGShmemHeader *seghdr;
Size size;
int numSemas;
/*
* Size of the Postgres shared-memory block is estimated via
* moderately-accurate estimates for the big hogs, plus 100K for the
* stuff that's too small to bother with estimating.
*
* We take some care during this phase to ensure that the total size
* request doesn't overflow size_t. If this gets through, we don't
* need to be so careful during the actual allocation phase.
*/
size = 150000;
size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
sizeof(ShmemIndexEnt)));
size = add_size(size, BufferShmemSize());
size = add_size(size, LockShmemSize());
size = add_size(size, workfile_mgr_shmem_size());
if (Gp_role == GP_ROLE_DISPATCH)
{
size = add_size(size, AppendOnlyWriterShmemSize());
if(ResourceScheduler)
{
size = add_size(size, ResSchedulerShmemSize());
size = add_size(size, ResPortalIncrementShmemSize());
}
}
size = add_size(size, ProcGlobalShmemSize());
size = add_size(size, XLOGShmemSize());
size = add_size(size, DistributedLog_ShmemSize());
size = add_size(size, CLOGShmemSize());
size = add_size(size, ChangeTrackingShmemSize());
size = add_size(size, SUBTRANSShmemSize());
size = add_size(size, TwoPhaseShmemSize());
size = add_size(size, MultiXactShmemSize());
size = add_size(size, LWLockShmemSize());
size = add_size(size, ProcArrayShmemSize());
size = add_size(size, BackendStatusShmemSize());
size = add_size(size, SharedSnapshotShmemSize());
size = add_size(size, SInvalShmemSize());
size = add_size(size, PMSignalShmemSize());
size = add_size(size, ProcSignalShmemSize());
size = add_size(size, primaryMirrorModeShmemSize());
size = add_size(size, FreeSpaceShmemSize());
//size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, FtsShmemSize());
size = add_size(size, tmShmemSize());
size = add_size(size, SeqServerShmemSize());
size = add_size(size, PersistentFileSysObj_ShmemSize());
size = add_size(size, PersistentFilespace_ShmemSize());
size = add_size(size, PersistentTablespace_ShmemSize());
size = add_size(size, PersistentDatabase_ShmemSize());
size = add_size(size, PersistentRelation_ShmemSize());
size = add_size(size, Pass2Recovery_ShmemSize());
/*Add shared memory for PT verification checks*/
if (Gp_role == GP_ROLE_DISPATCH && debug_persistent_ptcat_verification)
{
size = add_size(size, Persistent_PostDTMRecv_ShmemSize());
}
if (GPAreFileReplicationStructuresRequired()) {
size = add_size(size, FileRep_SubProcShmemSize());
size = add_size(size, FileRep_ShmemSize());
size = add_size(size, FileRepAck_ShmemSize());
size = add_size(size, FileRepAckPrimary_ShmemSize());
size = add_size(size, FileRepResync_ShmemSize());
size = add_size(size, FileRepIpc_ShmemSize());
size = add_size(size, FileRepLog_ShmemSize());
size = add_size(size, FileRepStats_ShmemSize());
}
#ifdef FAULT_INJECTOR
size = add_size(size, FaultInjector_ShmemSize());
#endif
#ifdef EXEC_BACKEND
size = add_size(size, ShmemBackendArraySize());
#endif
#ifdef USE_TEST_UTILS
if (gp_simex_init)
{
// initialize SimEx
simex_init();
size = add_size(size, SyncBitVector_ShmemSize(simex_get_subclass_count()));
}
#endif
/* This elog happens before we know the name of the log file we are supposed to use */
elog(DEBUG1, "Size not including the buffer pool %lu",
(unsigned long) size);
size = add_size(size, BgWriterShmemSize());
size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, BTreeShmemSize());
size = add_size(size, SyncScanShmemSize());
size = add_size(size, CheckpointShmemSize());
size = add_size(size, WalSndShmemSize());
size = add_size(size, WalRcvShmemSize());
/* freeze the addin request size and include it */
addin_request_allowed = false;
size = add_size(size, total_addin_request);
/* might as well round it off to a multiple of a typical page size */
size = add_size(size, BLCKSZ - (size % BLCKSZ));
/* Consider the size of the SessionState array */
size = add_size(size, SessionState_ShmemSize());
/*
* Create the shmem segment
*/
seghdr = PGSharedMemoryCreate(size, makePrivate, port);
InitShmemAccess(seghdr);
/*
* Create semaphores
*/
numSemas = ProcGlobalSemas();
numSemas += SpinlockSemas();
if (GPAreFileReplicationStructuresRequired())
{
numSemas += FileRepSemas();
}
elog(DEBUG3,"reserving %d semaphores",numSemas);
PGReserveSemaphores(numSemas, port);
}
else
{
/*
* We are reattaching to an existing shared memory segment. This
* should only be reached in the EXEC_BACKEND case, and even then only
* with makePrivate == false.
*/
#ifdef EXEC_BACKEND
Assert(!makePrivate);
#else
elog(PANIC, "should be attached to shared memory already");
#endif
}
/*
* Set up shared memory allocation mechanism
*/
if (!IsUnderPostmaster)
InitShmemAllocation();
/*
* Now initialize LWLocks, which do shared memory allocation and are
* needed for InitShmemIndex.
*/
if (!IsUnderPostmaster)
CreateLWLocks();
/*
* Set up shmem.c index hashtable
*/
InitShmemIndex();
primaryMirrorModeShmemInit();
/*
* Set up xlog, clog, and buffers
*/
XLOGShmemInit();
CLOGShmemInit();
ChangeTrackingShmemInit();
DistributedLog_ShmemInit();
SUBTRANSShmemInit();
TwoPhaseShmemInit();
MultiXactShmemInit();
FtsShmemInit();
tmShmemInit();
InitBufferPool();
/*
* Set up lock manager
*/
InitLocks();
/*
* Set up append only writer
*/
if (Gp_role == GP_ROLE_DISPATCH)
InitAppendOnlyWriter();
PersistentFileSysObj_ShmemInit();
PersistentFilespace_ShmemInit();
PersistentTablespace_ShmemInit();
PersistentDatabase_ShmemInit();
PersistentRelation_ShmemInit();
Pass2Recovery_ShmemInit();
if (Gp_role == GP_ROLE_DISPATCH && debug_persistent_ptcat_verification)
Persistent_PostDTMRecv_ShmemInit();
/*
* Set up resource schedular
*/
if (Gp_role == GP_ROLE_DISPATCH && ResourceScheduler)
{
InitResScheduler();
InitResPortalIncrementHash();
}
if (!IsUnderPostmaster)
{
/* Set up process table */
InitProcGlobal(PostmasterGetMppLocalProcessCounter());
}
/* Initialize SessionState shared memory array */
SessionState_ShmemInit();
/* Initialize vmem protection */
GPMemoryProtect_ShmemInit();
CreateSharedProcArray();
CreateSharedBackendStatus();
/*
* Set up Shared snapshot slots
*
* TODO: only need to do this if we aren't the QD. for now we are just
* doing it all the time and wasting shemem on the QD. This is
* because this happens at postmaster startup time when we don't
* know who we are.
*/
CreateSharedSnapshotArray();
/*
* Set up shared-inval messaging
*/
CreateSharedInvalidationState();
/*
* Set up free-space map
*/
InitFreeSpaceMap();
/*
* Set up interprocess signaling mechanisms
*/
PMSignalShmemInit();
ProcSignalShmemInit();
BgWriterShmemInit();
CheckpointShmemInit();
WalSndShmemInit();
WalRcvShmemInit();
//AutoVacuumShmemInit();
SeqServerShmemInit();
if (GPAreFileReplicationStructuresRequired()) {
FileRep_SubProcShmemInit();
FileRep_ShmemInit();
FileRepAck_ShmemInit();
FileRepAckPrimary_ShmemInit();
FileRepResync_ShmemInit();
FileRepIpc_ShmemInit();
FileRepLog_ShmemInit();
FileRepStats_ShmemInit();
}
#ifdef FAULT_INJECTOR
FaultInjector_ShmemInit();
#endif
#ifdef USE_TEST_UTILS
if (gp_simex_init)
{
// initialize shmem segment for SimEx
simex_set_sync_bitvector_container(
SyncBitVector_ShmemInit("SimEx bit vector container", simex_get_subclass_count()));
}
#endif /* USE_TEST_UTILS */
/*
* Set up other modules that need some shared memory space
*/
BTreeShmemInit();
SyncScanShmemInit();
workfile_mgr_cache_init();
#ifdef EXEC_BACKEND
/*
* Alloc the win32 shared backend array
*/
if (!IsUnderPostmaster)
ShmemBackendArrayAllocation();
#endif
BackoffStateInit();
if (gp_resqueue_memory_policy != RESQUEUE_MEMORY_POLICY_NONE)
{
SPI_InitMemoryReservation();
}
/*
* Now give loadable modules a chance to set up their shmem allocations
*/
if (shmem_startup_hook)
shmem_startup_hook();
}
void test()
{
double *a, start=1., end=-1.;
int len=100;
long size = len*sizeof(double);
long idlist[SHMIDLEN];
int numlock=10, i;
lockset_t lockid;
/* shared memory test */
if(me==0){
printf("Test shared memory\n");
a=(double*)Create_Shared_Region(idlist+1,size,idlist);
assert(a);
a[0]= start;
a[len-1]=end;
}
MPI_Bcast(idlist,SHMIDLEN,MPI_LONG,0,MPI_COMM_WORLD);
if(me){
a=(double*)Attach_Shared_Region(idlist+1,size,idlist[0]);
assert(a);
}
if(me==nproc-1){
printf("%d: start=%f end=%f\n",me,a[0],a[len-1]);
if(a[0]== start && a[len-1]== end) printf("Works!\n");
}
/*printf("%d: a=%x\n",me,a); */
MPI_Barrier(MPI_COMM_WORLD);
/* allocate locks */
if(me == 0){
a[0]=0.;
CreateInitLocks(numlock, &lockid);
printf("\nMutual exclusion test\n");
}
MPI_Bcast(&lockid,sizeof(lockid),MPI_BYTE,0,MPI_COMM_WORLD);
if(me)InitLocks(numlock, lockid);
/* mutual exclusion test:
* everybody increments shared variable 1000 times
*/
# define TIMES 1000
MPI_Barrier(MPI_COMM_WORLD);
for(i=0;i<TIMES; i++){
NATIVE_LOCK(0);
a[0]++;
NATIVE_UNLOCK(0);
}
MPI_Barrier(MPI_COMM_WORLD);
if(me==nproc-1){
printf("value of shared variable =%f should be %f\n",
a[0],1.0*nproc*TIMES);
if(a[0]==1.0*nproc*TIMES ) printf("Works!\n\n");
}
/* cleanup of IPC resources */
if(me==0){
DeleteLocks(lockid);
Delete_All_Regions();
}
MPI_Barrier(MPI_COMM_WORLD);
}