/** * Add user name to buffer. * * @param user Pointer to user name. * @param length Length of user name (without \0 termination). */ void add_user(const char* user, const string_size_type length) { object().set_user_size(length + 1); add_size(append(user, length) + append_zero()); add_padding(true); }
/* * 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, LocalDistribXact_ShmemSize()); 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(); LocalDistribXact_ShmemCreate(); 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 add_item(const osmium::memory::Item* item) { unsigned char* target = m_buffer.reserve_space(item->padded_size()); std::copy_n(reinterpret_cast<const unsigned char*>(item), item->padded_size(), target); add_size(item->padded_size()); }
/* * 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, 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, 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, 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=%lu)", (unsigned long) 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. */ if (!IsUnderPostmaster) 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(); /* * Set up shared-inval messaging */ CreateSharedInvalidationState(); /* * Set up interprocess signaling mechanisms */ PMSignalShmemInit(); ProcSignalShmemInit(); CheckpointerShmemInit(); AutoVacuumShmemInit(); 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 /* * Now give loadable modules a chance to set up their shmem allocations */ if (shmem_startup_hook) shmem_startup_hook(); }
// write function, should use at/near construction void input_buffer::assign(const byte* t, uint s) { check(current_, get_capacity()); add_size(s); memcpy(&buffer_[current_], t, s); }
int transmit(void) { // Hide the cursor, and make sure it comes back before exiting. set_cursor(false); signal(SIGINT, sigint_handler); // Set up the keyboard listener. long time_unit = calibrate_listener(); if (time_unit == EOF) { return 0; } if (!spawn_listener()) { print_error("error creating thread"); return 1; } // Set up the circular buffers. int buf_size = number_of_columns(); char code_buf[buf_size]; char text_buf[buf_size]; struct Circle code_circ, text_circ; init_empty(&code_circ, code_buf, buf_size); init_empty(&text_circ, text_buf, buf_size); append(&code_circ, '*'); // Begin the main loop. Code code = 0; int code_size = 0; bool done = false; long time = current_millis(); enum { NONE, CHAR, WORD } wait_mode = NONE; while (!done) { // Check the state of the keyboard listener. long time_now = current_millis(); enum ListenerState state = get_listener_state(time_now); switch (state) { case LS_EOF: done = true; continue; case LS_NONE: break; case LS_DOWN: insert(&code_circ, '.'); wait_mode = NONE; code <<= 1; code_size++; break; case LS_REPEAT: insert(&code_circ, '-'); code |= 1; break; case LS_HOLD: case LS_HOLD_R: break; case LS_UP: append(&code_circ, '*'); time = time_now; wait_mode = CHAR; break; } // Check if enough time has passed to start a new character or word. long elapsed = time_now - time; switch (wait_mode) { case NONE: break; case CHAR: if (elapsed > TIME_BETWEEN_CHARS) { insert(&code_circ, ' '); append(&code_circ, '*'); wait_mode = WORD; char ch = INVALID_CODE; if (code_size <= MAX_SIZE) { code = add_size(code, code_size); char decoded = code_to_char(code); if (decoded) { ch = decoded; } } append(&text_circ, ch); code = 0; code_size = 0; } break; case WORD: if (elapsed > TIME_BETWEEN_WORDS) { insert(&code_circ, '/'); append(&code_circ, ' '); append(&code_circ, '*'); wait_mode = NONE; append(&text_circ, ' '); } break; } // Print the contents of both buffers. putchar('\r'); print_circle(&code_circ); fputs(" \n", stdout); print_circle(&text_circ); fputs(" \x1B[F", stdout); fflush(stdout); usleep(SLEEP_TIME_US); } cleanup(); return 0; }
/* * 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) { PGShmemHeader *shim = NULL; if (!IsUnderPostmaster) { PGShmemHeader *seghdr; Size size = 0; int numSemas; Size new_size; /* * 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. */ int i; for (i = 0; PgShmemComponentSizes[i].component_name; i++) { struct pg_component_shmem_size *shm_size = &PgShmemComponentSizes[i]; new_size = shm_size->size_func(); elog(DEBUG3, "SHMEM_ADD: %s - %zu", shm_size->component_name, new_size); size = add_size(size, new_size); } /* freeze the addin request size and include it */ addin_request_allowed = false; new_size = total_addin_request; size = add_size(size, new_size); elog(DEBUG3, "SHMEM_ADD: %s - %zu", "total_addin_request", new_size); /* might as well round it off to a multiple of a typical page size */ new_size = BLCKSZ - (size % BLCKSZ); elog(DEBUG3, "SHMEM_ADD: %s - %zu", "Rounding", new_size); size = add_size(size, new_size); elog(DEBUG3, "invoking IpcMemoryCreate(size=%zu)", size); /* * Create the shmem segment */ seghdr = PGSharedMemoryCreate(size, makePrivate, port, &shim); 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(); CommitTsShmemInit(); 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(); ReplicationOriginShmemInit(); 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(shim); /* * Now give loadable modules a chance to set up their shmem allocations */ if (shmem_startup_hook) shmem_startup_hook(); }