GC step 5. Add large tests and fix bugs. (f3cd38f2) · Commits · e / os / android_packages_inputmethods_LatinIME

native/jni/src/suggest/policyimpl/dictionary/bigram/bigram_list_read_write_utils.cpp

+40 −7

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,7 @@

	#include "suggest/policyimpl/dictionary/bigram/bigram_list_read_write_utils.h"		#include "suggest/policyimpl/dictionary/bigram/bigram_list_read_write_utils.h"

			#include "suggest/policyimpl/dictionary/dynamic_patricia_trie_reading_utils.h"
	#include "suggest/policyimpl/dictionary/utils/byte_array_utils.h"		#include "suggest/policyimpl/dictionary/utils/byte_array_utils.h"
	#include "suggest/policyimpl/dictionary/utils/buffer_with_extendable_buffer.h"		#include "suggest/policyimpl/dictionary/utils/buffer_with_extendable_buffer.h"

	@@ -78,8 +79,10 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;
	offset = ByteArrayUtils::readUint24AndAdvancePosition(bigramsBuf, pos);		offset = ByteArrayUtils::readUint24AndAdvancePosition(bigramsBuf, pos);
	break;		break;
	}		}
	if (offset == 0) {		if (offset == DynamicPatriciaTrieReadingUtils::DICT_OFFSET_INVALID) {
	return NOT_A_DICT_POS;		return NOT_A_DICT_POS;
			} else if (offset == DynamicPatriciaTrieReadingUtils::DICT_OFFSET_ZERO_OFFSET) {
			return origin;
	}		}
	if (isOffsetNegative(flags)) {		if (isOffsetNegative(flags)) {
	return origin - offset;		return origin - offset;
	@@ -88,6 +91,24 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;
	}		}
	}		}

			/* static */ bool BigramListReadWriteUtils::setHasNextFlag(
			BufferWithExtendableBuffer *const buffer, const bool hasNext, const int entryPos) {
			const bool usesAdditionalBuffer = buffer->isInAdditionalBuffer(entryPos);
			int readingPos = entryPos;
			if (usesAdditionalBuffer) {
			readingPos -= buffer->getOriginalBufferSize();
			}
			BigramFlags bigramFlags = ByteArrayUtils::readUint8AndAdvancePosition(
			buffer->getBuffer(usesAdditionalBuffer), &readingPos);
			if (hasNext) {
			bigramFlags = bigramFlags \| FLAG_ATTRIBUTE_HAS_NEXT;
			} else {
			bigramFlags = bigramFlags & (~FLAG_ATTRIBUTE_HAS_NEXT);
			}
			int writingPos = entryPos;
			return buffer->writeUintAndAdvancePosition(bigramFlags, 1 /* size */, &writingPos);
			}

	/* static */ bool BigramListReadWriteUtils::createAndWriteBigramEntry(		/* static */ bool BigramListReadWriteUtils::createAndWriteBigramEntry(
	BufferWithExtendableBuffer *const buffer, const int targetPos, const int probability,		BufferWithExtendableBuffer *const buffer, const int targetPos, const int probability,
	const bool hasNext, int *const writingPos) {		const bool hasNext, int *const writingPos) {
	@@ -101,10 +122,9 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;
	/* static */ bool BigramListReadWriteUtils::writeBigramEntry(		/* static */ bool BigramListReadWriteUtils::writeBigramEntry(
	BufferWithExtendableBuffer *const bufferToWrite, const BigramFlags flags,		BufferWithExtendableBuffer *const bufferToWrite, const BigramFlags flags,
	const int targetPtNodePos, int *const writingPos) {		const int targetPtNodePos, int *const writingPos) {
	const int offset = (targetPtNodePos != NOT_A_DICT_POS) ?		const int offset = getBigramTargetOffset(targetPtNodePos, *writingPos);
	targetPtNodePos - (*writingPos + 1) : 0;
	const BigramFlags flagsToWrite = (offset < 0) ?		const BigramFlags flagsToWrite = (offset < 0) ?
	(flags \| FLAG_ATTRIBUTE_OFFSET_NEGATIVE) : flags;		(flags \| FLAG_ATTRIBUTE_OFFSET_NEGATIVE) : (flags & ~FLAG_ATTRIBUTE_OFFSET_NEGATIVE);
	if (!bufferToWrite->writeUintAndAdvancePosition(flagsToWrite, 1 /* size */, writingPos)) {		if (!bufferToWrite->writeUintAndAdvancePosition(flagsToWrite, 1 /* size */, writingPos)) {
	return false;		return false;
	}		}
	@@ -116,14 +136,13 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;

	// Returns true if the bigram entry is valid and put entry flags into out*.		// Returns true if the bigram entry is valid and put entry flags into out*.
	/* static */ bool BigramListReadWriteUtils::createAndGetBigramFlags(const int entryPos,		/* static */ bool BigramListReadWriteUtils::createAndGetBigramFlags(const int entryPos,
	const int targetPos, const int probability, const bool hasNext,		const int targetPtNodePos, const int probability, const bool hasNext,
	BigramFlags *const outBigramFlags) {		BigramFlags *const outBigramFlags) {
	BigramFlags flags = probability & MASK_ATTRIBUTE_PROBABILITY;		BigramFlags flags = probability & MASK_ATTRIBUTE_PROBABILITY;
	if (hasNext) {		if (hasNext) {
	flags \|= FLAG_ATTRIBUTE_HAS_NEXT;		flags \|= FLAG_ATTRIBUTE_HAS_NEXT;
	}		}
	const int targetFieldPos = entryPos + 1;		const int offset = getBigramTargetOffset(targetPtNodePos, entryPos);
	const int offset = (targetPos != NOT_A_DICT_POS) ? targetPos - targetFieldPos : 0;
	if (offset < 0) {		if (offset < 0) {
	flags \|= FLAG_ATTRIBUTE_OFFSET_NEGATIVE;		flags \|= FLAG_ATTRIBUTE_OFFSET_NEGATIVE;
	}		}
	@@ -146,4 +165,18 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;
	return true;		return true;
	}		}

			/* static */ int BigramListReadWriteUtils::getBigramTargetOffset(const int targetPtNodePos,
			const int entryPos) {
			if (targetPtNodePos == NOT_A_DICT_POS) {
			return DynamicPatriciaTrieReadingUtils::DICT_OFFSET_INVALID;
			} else {
			const int offset = targetPtNodePos - (entryPos + 1 /* bigramFlagsField */);
			if (offset == 0) {
			return DynamicPatriciaTrieReadingUtils::DICT_OFFSET_ZERO_OFFSET;
			} else {
			return offset;
			}
			}
			}

	} // namespace latinime		} // namespace latinime

native/jni/src/suggest/policyimpl/dictionary/bigram/bigram_list_read_write_utils.h

+4 −3

Original line number	Original line	Diff line number	Diff line
	@@ -59,9 +59,8 @@ public:
	*/		*/
	}		}

	static AK_FORCE_INLINE BigramFlags setHasNextFlag(const BigramFlags flags) {		static bool setHasNextFlag(BufferWithExtendableBuffer *const buffer,
	return flags \| FLAG_ATTRIBUTE_HAS_NEXT;		const bool hasNext, const int entryPos);
	}

	static AK_FORCE_INLINE BigramFlags setProbabilityInFlags(const BigramFlags flags,		static AK_FORCE_INLINE BigramFlags setProbabilityInFlags(const BigramFlags flags,
	const int probability) {		const int probability) {
	@@ -96,6 +95,8 @@ private:

	static int getBigramAddressAndAdvancePosition(const uint8_t *const bigramsBuf,		static int getBigramAddressAndAdvancePosition(const uint8_t *const bigramsBuf,
	const BigramFlags flags, int *const pos);		const BigramFlags flags, int *const pos);

			static int getBigramTargetOffset(const int targetPtNodePos, const int entryPos);
	};		};
	} // namespace latinime		} // namespace latinime
	#endif // LATINIME_BIGRAM_LIST_READ_WRITE_UTILS_H		#endif // LATINIME_BIGRAM_LIST_READ_WRITE_UTILS_H

native/jni/src/suggest/policyimpl/dictionary/bigram/dynamic_bigram_list_policy.cpp

+14 −4

Original line number	Original line	Diff line number	Diff line
	@@ -70,6 +70,7 @@ bool DynamicBigramListPolicy::copyAllBigrams(BufferWithExtendableBuffer *const b
	*outBigramsCount = 0;		*outBigramsCount = 0;
	BigramListReadWriteUtils::BigramFlags bigramFlags;		BigramListReadWriteUtils::BigramFlags bigramFlags;
	int bigramEntryCount = 0;		int bigramEntryCount = 0;
			int lastWrittenEntryPos = NOT_A_DICT_POS;
	do {		do {
	if (++bigramEntryCount > BIGRAM_ENTRY_COUNT_IN_A_BIGRAM_LIST_LIMIT) {		if (++bigramEntryCount > BIGRAM_ENTRY_COUNT_IN_A_BIGRAM_LIST_LIMIT) {
	AKLOGE("Too many bigram entries. Entry count: %d, Limit: %d",		AKLOGE("Too many bigram entries. Entry count: %d, Limit: %d",
	@@ -90,6 +91,11 @@ bool DynamicBigramListPolicy::copyAllBigrams(BufferWithExtendableBuffer *const b
	originalBigramPos += mBuffer->getOriginalBufferSize();		originalBigramPos += mBuffer->getOriginalBufferSize();
	}		}
	const int bigramPos = followBigramLinkAndGetCurrentBigramPtNodePos(originalBigramPos);		const int bigramPos = followBigramLinkAndGetCurrentBigramPtNodePos(originalBigramPos);
			if (bigramPos == NOT_A_DICT_POS) {
			// Target PtNode has been invalidated.
			continue;
			}
			lastWrittenEntryPos = *toPos;
	if (!BigramListReadWriteUtils::createAndWriteBigramEntry(bufferToWrite, bigramPos,		if (!BigramListReadWriteUtils::createAndWriteBigramEntry(bufferToWrite, bigramPos,
	BigramListReadWriteUtils::getProbabilityFromFlags(bigramFlags),		BigramListReadWriteUtils::getProbabilityFromFlags(bigramFlags),
	BigramListReadWriteUtils::hasNext(bigramFlags), toPos)) {		BigramListReadWriteUtils::hasNext(bigramFlags), toPos)) {
	@@ -97,6 +103,13 @@ bool DynamicBigramListPolicy::copyAllBigrams(BufferWithExtendableBuffer *const b
	}		}
	(*outBigramsCount)++;		(*outBigramsCount)++;
	} while(BigramListReadWriteUtils::hasNext(bigramFlags));		} while(BigramListReadWriteUtils::hasNext(bigramFlags));
			// Makes the last entry the terminal of the list. Updates the flags.
			if (lastWrittenEntryPos != NOT_A_DICT_POS) {
			if (!BigramListReadWriteUtils::setHasNextFlag(bufferToWrite, false /* hasNext */,
			lastWrittenEntryPos)) {
			return false;
			}
			}
	if (usesAdditionalBuffer) {		if (usesAdditionalBuffer) {
	*fromPos += mBuffer->getOriginalBufferSize();		*fromPos += mBuffer->getOriginalBufferSize();
	}		}
	@@ -240,10 +253,7 @@ bool DynamicBigramListPolicy::addNewBigramEntryToBigramList(const int bigramTarg
	}		}
	// The current last entry is found.		// The current last entry is found.
	// First, update the flags of the last entry.		// First, update the flags of the last entry.
	const BigramListReadWriteUtils::BigramFlags updatedFlags =		if (!BigramListReadWriteUtils::setHasNextFlag(mBuffer, true /* hasNext */, entryPos)) {
	BigramListReadWriteUtils::setHasNextFlag(bigramFlags);
	if (!BigramListReadWriteUtils::writeBigramEntry(mBuffer, updatedFlags, originalBigramPos,
	&entryPos)) {
	return false;		return false;
	}		}
	if (usesAdditionalBuffer) {		if (usesAdditionalBuffer) {

native/jni/src/suggest/policyimpl/dictionary/dynamic_patricia_trie_gc_event_listeners.cpp

+7 −7

Original line number	Original line	Diff line number	Diff line
	@@ -113,11 +113,9 @@ bool DynamicPatriciaTrieGcEventListeners::TraversePolicyToUpdateAllPositionField
	}		}
	}		}
	int writingPos = node->getHeadPos() + DynamicPatriciaTrieWritingUtils::NODE_FLAG_FIELD_SIZE;		int writingPos = node->getHeadPos() + DynamicPatriciaTrieWritingUtils::NODE_FLAG_FIELD_SIZE;
	const int parentPosOffset = (parentPos != NOT_A_DICT_POS) ?
	parentPos - node->getHeadPos() : NOT_A_DICT_POS;
	// Write updated parent offset.		// Write updated parent offset.
	if (!DynamicPatriciaTrieWritingUtils::writeParentOffsetAndAdvancePosition(mBufferToWrite,		if (!DynamicPatriciaTrieWritingUtils::writeParentPosOffsetAndAdvancePosition(mBufferToWrite,
	parentPosOffset, &writingPos)) {		parentPos, node->getHeadPos(), &writingPos)) {
	return false;		return false;
	}		}

	@@ -139,8 +137,10 @@ bool DynamicPatriciaTrieGcEventListeners::TraversePolicyToUpdateAllPositionField
	// Updates bigram target PtNode positions in the bigram list.		// Updates bigram target PtNode positions in the bigram list.
	int bigramsPos = node->getBigramsPos();		int bigramsPos = node->getBigramsPos();
	if (bigramsPos != NOT_A_DICT_POS) {		if (bigramsPos != NOT_A_DICT_POS) {
	mBigramPolicy->updateAllBigramTargetPtNodePositions(&bigramsPos,		if (!mBigramPolicy->updateAllBigramTargetPtNodePositions(&bigramsPos,
	&mDictPositionRelocationMap->mPtNodePositionRelocationMap);		&mDictPositionRelocationMap->mPtNodePositionRelocationMap)) {
			return false;
			}
	}		}

	return true;		return true;

native/jni/src/suggest/policyimpl/dictionary/dynamic_patricia_trie_node_reader.cpp

+4 −3

Original line number	Original line	Diff line number	Diff line
	@@ -40,9 +40,10 @@ void DynamicPatriciaTrieNodeReader::fetchPtNodeInfoFromBufferAndProcessMovedPtNo
	pos -= mBuffer->getOriginalBufferSize();		pos -= mBuffer->getOriginalBufferSize();
	}		}
	mFlags = PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(dictBuf, &pos);		mFlags = PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(dictBuf, &pos);
	const int parentPos =		const int parentPosOffset =
	DynamicPatriciaTrieReadingUtils::getParentPosAndAdvancePosition(dictBuf, &pos);		DynamicPatriciaTrieReadingUtils::getParentPtNodePosOffsetAndAdvancePosition(dictBuf,
	mParentPos = (parentPos != 0) ? ptNodePos + parentPos : NOT_A_DICT_POS;		&pos);
			mParentPos = DynamicPatriciaTrieReadingUtils::getParentPtNodePos(parentPosOffset, mHeadPos);
	if (outCodePoints != 0) {		if (outCodePoints != 0) {
	mCodePointCount = PatriciaTrieReadingUtils::getCharsAndAdvancePosition(		mCodePointCount = PatriciaTrieReadingUtils::getCharsAndAdvancePosition(
	dictBuf, mFlags, maxCodePointCount, outCodePoints, &pos);		dictBuf, mFlags, maxCodePointCount, outCodePoints, &pos);