C++ (Cpp) bitList Examples

Example #1

File: drm-info.c Project: fritschy/drm-utils

static void printEncoders(int fd, uint32_t* ids, uint32_t count) {
	int i;

	for (i = 0; i < count; i++) {
		drmModeEncoder *enc;
		enc = drmModeGetEncoder(fd, ids[i]);
		fprintf(stdout, "      Encoder %u:\n", enc->encoder_id);
		fprintf(stdout, "        Type: %s\n", getEncoderType(enc->encoder_type));
		fprintf(stdout, "        CRTC: %u\n", enc->crtc_id);
		fprintf(stdout, "        Possible CRTCs: %1$u, %1$#08x, %1$#016o, %2$s\n", enc->possible_crtcs, bitList(enc->possible_crtcs));
		fprintf(stdout, "        Possible Clones: %1$u, %1$#08x, %1$#016o, %2$s\n", enc->possible_clones, bitList(enc->possible_clones));
		fprintf(stdout, "\n");
		drmModeFreeEncoder(enc);
	}
}

Example #2

File: checkpoint_service.cpp Project: Applied-Duality/griddb_nosql

/*!
	@brief Executes operations of a Checkpoint for transaction thread.
*/
void CheckpointOperationHandler::operator()(EventContext &ec, Event &ev) {
	try {
		util::StackAllocator &alloc = ec.getAllocator();
		util::StackAllocator::Scope scope(alloc);

		EventByteInStream in = ev.getInStream();

		const PartitionId pId = ev.getPartitionId();
		const PartitionGroupId pgId =
			checkpointService_->getPGConfig().getPartitionGroupId(pId);

		int32_t mode;
		CheckpointId cpId;
		in >> mode;
		in >> cpId;

		const bool checkpointReady =
			dataStore_->isRestored(pId) && chunkManager_->existPartition(pId);

		WATCHER_START;
		switch (ev.getType()) {
		case CLEANUP_CP_DATA:
			chunkManager_->cleanCheckpointData(pgId);
			break;


		case PARTITION_GROUP_START:

			checkpointService_->setCurrentCpGrpId(pgId);

			chunkManager_->startCheckpoint(pgId, cpId);
			logManager_->prepareCheckpoint(pgId, cpId);
			break;

		case PARTITION_START:

			checkpointService_->setCurrentCpPId(pId);

			if (checkpointReady) {
				chunkManager_->startCheckpoint(pId);
			}
			writeCheckpointStartLog(alloc, mode, pgId, pId, cpId);
			writeChunkMetaDataLog(
				alloc, mode, pgId, pId, cpId, checkpointReady);
			break;

		case COPY_CHUNK:
			chunkManager_->copyChunk(pId);
			break;

		case PARTITION_END:
			chunkManager_->endCheckpoint(pId);

			checkpointService_->setCurrentCpPId(UNDEF_PARTITIONID);

			checkpointService_->setCurrentCheckpointId(
				pId, logManager_->getLastCheckpointId(pgId));
			if (cpId == 0) {
				logManager_->setAvailableStartLSN(pId, cpId);
			}

			break;

		case PARTITION_GROUP_END: {
			util::XArray<uint8_t> bitList(alloc);
			util::XArray<uint8_t> binaryLogBuf(alloc);

			chunkManager_->endCheckpoint(pgId, cpId);
			chunkManager_->flush(pgId);

			checkpointService_->setCurrentCpGrpId(UINT32_MAX);


			BitArray &validBitArray = chunkManager_->getCheckpointBit(pgId);

			{
				const PartitionId startPId =
					checkpointService_->getPGConfig().getGroupBeginPartitionId(
						pgId);
				const PartitionId endPId =
					checkpointService_->getPGConfig().getGroupEndPartitionId(
						pgId);
				for (PartitionId pId = startPId; pId < endPId; pId++) {
					checkpointService_->lsnInfo_.setLsn(
						pId, logManager_->getLSN(pId));  
				}
			}
			logManager_->putCheckpointEndLog(binaryLogBuf,
				checkpointService_->getPGConfig().getGroupBeginPartitionId(
					pgId),
				validBitArray);

			logManager_->writeBuffer(pgId);
			logManager_->flushFile(pgId);
			logManager_->postCheckpoint(
				pgId);  

			{
				PartitionTable *pt = checkpointService_->getPartitionTable();
				util::XArray<uint8_t> binaryLogRecords(alloc);
				CheckpointId cpId = logManager_->getFirstCheckpointId(pgId);
				logManager_->updateAvailableStartLsn(
					pt, pgId, binaryLogRecords, cpId);

				const PartitionId startPId =
					checkpointService_->getPGConfig().getGroupBeginPartitionId(
						pgId);
				const PartitionId endPId =
					checkpointService_->getPGConfig().getGroupEndPartitionId(
						pgId);
				clusterService_->requestUpdateStartLsn(
					ec, ec.getAllocator(), startPId, endPId);
			}

			if (mode == CP_SHUTDOWN) {
				logManager_->writeBuffer(
					pgId);  
				logManager_->flushFile(
					pgId);  
			}
		} break;
		}
		WATCHER_END_3(getEventTypeName(ev.getType()), pId, pgId);
	}
	catch (std::exception &e) {
		clusterService_->setError(ec, &e);
		GS_RETHROW_SYSTEM_ERROR(e, "Group checkpoint failed. (reason="
									   << GS_EXCEPTION_MESSAGE(e) << ")");
	}
}