TupleSchema* TupleSchema::createTupleSchema(const std::vector<ValueType>& columnTypes, const std::vector<int32_t>& columnSizes, const std::vector<bool>& allowNull, const std::vector<bool>& columnInBytes, const std::vector<ValueType>& hiddenColumnTypes, const std::vector<int32_t>& hiddenColumnSizes, const std::vector<bool>& hiddenAllowNull, const std::vector<bool>& hiddenColumnInBytes) { const uint16_t uninlineableObjectColumnCount = TupleSchema::countUninlineableObjectColumns(columnTypes, columnSizes, columnInBytes); const uint16_t columnCount = static_cast<uint16_t>(columnTypes.size()); const uint16_t hiddenColumnCount = static_cast<uint16_t>(hiddenColumnTypes.size()); int memSize = memSizeForTupleSchema(columnCount, uninlineableObjectColumnCount, hiddenColumnCount); // allocate the set amount of memory and cast it to a tuple pointer TupleSchema *retval = reinterpret_cast<TupleSchema*>(new char[memSize]); // clear all the offset values memset(retval, 0, memSize); retval->m_columnCount = columnCount; retval->m_uninlinedObjectColumnCount = uninlineableObjectColumnCount; retval->m_hiddenColumnCount = hiddenColumnCount; retval->m_isHeaderless = false; uint16_t uninlinedObjectColumnIndex = 0; for (uint16_t ii = 0; ii < columnCount; ii++) { const ValueType type = columnTypes[ii]; const uint32_t length = columnSizes[ii]; const bool columnAllowNull = allowNull[ii]; const bool inBytes = columnInBytes[ii]; retval->setColumnMetaData(ii, type, length, columnAllowNull, uninlinedObjectColumnIndex, inBytes); } for (uint16_t ii = 0; ii < hiddenColumnCount; ++ii) { const ValueType type = hiddenColumnTypes[ii]; const uint32_t length = hiddenColumnSizes[ii]; const bool columnAllowNull = hiddenAllowNull[ii]; const bool inBytes = hiddenColumnInBytes[ii]; // We can't allow uninlineable data in hidden columns yet if (! isInlineable(type, length, inBytes)) { throwFatalLogicErrorStreamed("Attempt to create uninlineable hidden column"); } retval->setColumnMetaData(static_cast<uint16_t>(columnCount + ii), type, length, columnAllowNull, uninlinedObjectColumnIndex, inBytes); } return retval; }
void TupleSchema::setColumnMetaData(uint16_t index, ValueType type, const int32_t length, bool allowNull, uint16_t &uninlinedObjectColumnIndex, bool inBytes) { assert(length <= COLUMN_MAX_VALUE_LENGTH); uint32_t offset = 0; // set the type ColumnInfo *columnInfo = getColumnInfoPrivate(index); columnInfo->type = static_cast<char>(type); columnInfo->allowNull = (char)(allowNull ? 1 : 0); columnInfo->length = length; columnInfo->inBytes = inBytes; if (type == VALUE_TYPE_VARCHAR || type == VALUE_TYPE_VARBINARY) { if (length == 0) { throwFatalLogicErrorStreamed("Zero length for object type " << valueToString((ValueType)type)); } if (isInlineable(type, length, inBytes)) { columnInfo->inlined = true; // If the length was specified in characters, convert to bytes. int32_t factor = (type == VALUE_TYPE_VARCHAR && !inBytes) ? MAX_BYTES_PER_UTF8_CHARACTER : 1; // inlined variable length columns have a size prefix (1 byte) offset = static_cast<uint32_t>(SHORT_OBJECT_LENGTHLENGTH + (length * factor)); } else { columnInfo->inlined = false; // Set the length to the size of a String pointer since it won't be inlined. offset = static_cast<uint32_t>(NValue::getTupleStorageSize(type)); setUninlinedObjectColumnInfoIndex(uninlinedObjectColumnIndex++, index); } } else { // All values are inlined if they aren't strings. columnInfo->inlined = true; // don't trust the planner since it can be avoided offset = static_cast<uint32_t>(NValue::getTupleStorageSize(type)); } // make the column offsets right for all columns past this one int oldsize = columnLengthPrivate(index); ColumnInfo *nextColumnInfo = NULL; for (int i = index + 1; i <= totalColumnCount(); i++) { nextColumnInfo = getColumnInfoPrivate(i); nextColumnInfo->offset = static_cast<uint32_t>(nextColumnInfo->offset + offset - oldsize); } assert(index == 0 ? columnInfo->offset == 0 : true); }
/* * Returns the number of variable-length columns that can't be inlined. */ uint16_t TupleSchema::countUninlineableObjectColumns( const std::vector<ValueType> columnTypes, const std::vector<int32_t> columnSizes, const std::vector<bool> columnInBytes) { const uint16_t numColumns = static_cast<uint16_t>(columnTypes.size()); uint16_t numUninlineableObjects = 0; for (int ii = 0; ii < numColumns; ii++) { ValueType vt = columnTypes[ii]; if (! isInlineable(vt, columnSizes[ii], columnInBytes[ii])) { numUninlineableObjects++; } } return numUninlineableObjects; }
int32_t OMR::RecognizedCallTransformer::perform() { TR::NodeChecklist visited(comp()); for (auto treetop = comp()->getMethodSymbol()->getFirstTreeTop(); treetop != NULL; treetop = treetop->getNextTreeTop()) { if (treetop->getNode()->getNumChildren() > 0) { auto node = treetop->getNode()->getFirstChild(); if (node && node->getOpCode().isCall() && !visited.contains(node)) { if (isInlineable(treetop) && performTransformation(comp(), "%s Transforming recognized call node [" POINTER_PRINTF_FORMAT "]\n", optDetailString(), node)) { visited.add(node); transform(treetop); } } } } return 0; }