firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-02-02 10:00:38 +01:00
Code Issues

Improve allocation of request impure space, specially statements, to not waste alignment space (CORE-6330).

Browse Source
This commit is contained in:
Adriano dos Santos Fernandes 2020-06-11 12:55:00 -03:00
parent 98054a2093
commit 1951362a73
35 changed files with 119 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/dsql/AggNodes.cpp
View File

@ -351,7 +351,7 @@ AggNode* AggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value_ex));
impureOffset = csb->allocImpure<impure_value_ex>();
return this;
}
@ -653,7 +653,7 @@ AggNode* AvgAggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
nodFlags |= FLAG_DOUBLE;
// We need a second descriptor in the impure area for AVG.
tempImpure = CMP_impure(csb, sizeof(impure_value_ex));
tempImpure = csb->allocImpure<impure_value_ex>();
return this;
}
@ -1416,7 +1416,7 @@ AggNode* StdDevAggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
impure2Offset = CMP_impure(csb, sizeof(StdDevImpure));
impure2Offset = csb->allocImpure<StdDevImpure>();
return this;
}
@ -1625,7 +1625,7 @@ AggNode* CorrAggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
impure2Offset = CMP_impure(csb, sizeof(CorrImpure));
impure2Offset = csb->allocImpure<CorrImpure>();
return this;
}
@ -1901,7 +1901,7 @@ AggNode* RegrAggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
impure2Offset = CMP_impure(csb, sizeof(RegrImpure));
impure2Offset = csb->allocImpure<RegrImpure>();
return this;
}

4
src/dsql/BoolNodes.cpp
View File

@ -636,7 +636,7 @@ void ComparativeBoolNode::pass2Boolean2(thread_db* tdbb, CompilerScratch* csb)
if (nodFlags & FLAG_INVARIANT)
{
// This may currently happen for nod_like, nod_contains and nod_similar
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
}
}
@ -1753,7 +1753,7 @@ void RseBoolNode::pass2Boolean1(thread_db* tdbb, CompilerScratch* csb)
void RseBoolNode::pass2Boolean2(thread_db* tdbb, CompilerScratch* csb)
{
if (nodFlags & FLAG_INVARIANT)
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
RecordSource* const rsb = CMP_post_rse(tdbb, csb, rse);

69
src/dsql/ExprNodes.cpp
View File

@ -1805,7 +1805,7 @@ ValueExprNode* ArithmeticNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -3181,7 +3181,7 @@ ValueExprNode* AtNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -3299,7 +3299,7 @@ ValueExprNode* BoolAsValueNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -3518,7 +3518,7 @@ ValueExprNode* CastNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -3890,7 +3890,7 @@ ValueExprNode* ConcatenateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -4123,7 +4123,7 @@ ValueExprNode* CurrentDateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -4228,7 +4228,7 @@ ValueExprNode* CurrentTimeNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -4343,7 +4343,7 @@ ValueExprNode* CurrentTimeStampNode::pass2(thread_db* tdbb, CompilerScratch* csb
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -4437,7 +4437,7 @@ ValueExprNode* CurrentRoleNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -4531,7 +4531,7 @@ ValueExprNode* CurrentUserNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -5411,7 +5411,7 @@ ValueExprNode* ExtractNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -6771,7 +6771,7 @@ ValueExprNode* FieldNode::pass2(thread_db* tdbb, CompilerScratch* csb)
if (csb->csb_rpt[fieldStream].csb_relation || csb->csb_rpt[fieldStream].csb_procedure)
format = CMP_format(tdbb, csb, fieldStream);
impureOffset = CMP_impure(csb, sizeof(impure_value_ex));
impureOffset = csb->allocImpure<impure_value_ex>();
cursorNumber = csb->csb_rpt[fieldStream].csb_cursor_number;
return this;
@ -7023,7 +7023,7 @@ ValueExprNode* GenIdNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -7217,7 +7217,7 @@ ValueExprNode* InternalInfoNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -8025,7 +8025,7 @@ ValueExprNode* LocalTimeNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -8128,7 +8128,7 @@ ValueExprNode* LocalTimeStampNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -8735,7 +8735,7 @@ ValueExprNode* NegateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -9608,7 +9608,11 @@ ValueExprNode* ParameterNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, (nodFlags & FLAG_VALUE) ? sizeof(impure_value_ex) : sizeof(dsc));
if (nodFlags & FLAG_VALUE)
impureOffset = csb->allocImpure<impure_value_ex>();
else
impureOffset = csb->allocImpure<dsc>();
return this;
}
@ -10146,7 +10150,7 @@ ValueExprNode* RecordKeyNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -10333,7 +10337,7 @@ ValueExprNode* ScalarNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -10547,7 +10551,7 @@ ValueExprNode* StrCaseNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -10762,7 +10766,7 @@ ValueExprNode* StrLenNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -11187,7 +11191,7 @@ ValueExprNode* SubQueryNode::pass2(thread_db* tdbb, CompilerScratch* csb)
ValueExprNode::pass2(tdbb, csb);
impureOffset = CMP_impure(csb, sizeof(impure_value_ex));
impureOffset = csb->allocImpure<impure_value_ex>();
{
dsc desc;
@ -11539,7 +11543,7 @@ ValueExprNode* SubstringNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -11843,7 +11847,7 @@ ValueExprNode* SubstringSimilarNode::pass2(thread_db* tdbb, CompilerScratch* csb
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -12100,7 +12104,7 @@ ValueExprNode* SysFuncCallNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -12356,7 +12360,7 @@ ValueExprNode* TrimNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -12771,20 +12775,20 @@ ValueExprNode* UdfCallNode::pass2(thread_db* tdbb, CompilerScratch* csb)
dsc desc;
getDesc(tdbb, csb, &desc);
impureOffset = CMP_impure(csb, sizeof(Impure));
impureOffset = csb->allocImpure<Impure>();
if (function->isDefined() && !function->fun_entrypoint)
{
if (function->getInputFormat() && function->getInputFormat()->fmt_count)
{
fb_assert(function->getInputFormat()->fmt_length);
CMP_impure(csb, function->getInputFormat()->fmt_length);
csb->allocImpure(FB_ALIGNMENT, function->getInputFormat()->fmt_length);
}
fb_assert(function->getOutputFormat()->fmt_count == 3);
fb_assert(function->getOutputFormat()->fmt_length);
CMP_impure(csb, function->getOutputFormat()->fmt_length);
csb->allocImpure(FB_ALIGNMENT, function->getOutputFormat()->fmt_length);
}
return this;
@ -13438,7 +13442,10 @@ ValueExprNode* VariableNode::pass2(thread_db* tdbb, CompilerScratch* csb)
ValueExprNode::pass2(tdbb, csb);
impureOffset = CMP_impure(csb, (nodFlags & FLAG_VALUE) ? sizeof(impure_value_ex) : sizeof(dsc));
if (nodFlags & FLAG_VALUE)
impureOffset = csb->allocImpure<impure_value_ex>();
else
impureOffset = csb->allocImpure<dsc>();
return this;
}

23
src/dsql/StmtNodes.cpp
View File

@ -632,7 +632,7 @@ BlockNode* BlockNode::pass2(thread_db* tdbb, CompilerScratch* csb)
doPass2(tdbb, csb, action.getAddress(), this);
doPass2(tdbb, csb, handlers.getAddress(), this);
impureOffset = CMP_impure(csb, sizeof(SavNumber));
impureOffset = csb->allocImpure<SavNumber>();
return this;
}
@ -976,7 +976,7 @@ CompoundStmtNode* CompoundStmtNode::pass2(thread_db* tdbb, CompilerScratch* csb)
for (NestConst<StmtNode>* i = statements.begin(); i != statements.end(); ++i)
doPass2(tdbb, csb, i->getAddress(), this);
impureOffset = CMP_impure(csb, sizeof(impure_state));
impureOffset = csb->allocImpure<impure_state>();
for (NestConst<StmtNode>* i = statements.begin(); i != statements.end(); ++i)
{
@ -2248,7 +2248,7 @@ DeclareVariableNode* DeclareVariableNode::pass1(thread_db* tdbb, CompilerScratch
DeclareVariableNode* DeclareVariableNode::pass2(thread_db* /*tdbb*/, CompilerScratch* csb)
{
impureOffset = CMP_impure(csb, sizeof(impure_value));
impureOffset = csb->allocImpure<impure_value>();
return this;
}
@ -3736,7 +3736,7 @@ ExecStatementNode* ExecStatementNode::pass2(thread_db* tdbb, CompilerScratch* cs
}
}
impureOffset = CMP_impure(csb, sizeof(EDS::Statement*));
impureOffset = csb->allocImpure<EDS::Statement*>();
return this;
}
@ -3992,7 +3992,7 @@ InAutonomousTransactionNode* InAutonomousTransactionNode::pass1(thread_db* tdbb,
InAutonomousTransactionNode* InAutonomousTransactionNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
impureOffset = CMP_impure(csb, sizeof(Impure));
impureOffset = csb->allocImpure<Impure>();
doPass2(tdbb, csb, action.getAddress(), this);
return this;
}
@ -5046,7 +5046,10 @@ StmtNode* ForNode::pass2(thread_db* tdbb, CompilerScratch* csb)
if (rse->flags & RseNode::FLAG_WRITELOCK)
withLock = true;
impureOffset = CMP_impure(csb, isMerge ? sizeof(ImpureMerge) : sizeof(Impure));
if (isMerge)
impureOffset = csb->allocImpure<ImpureMerge>();
else
impureOffset = csb->allocImpure<Impure>();
return this;
}
@ -6031,8 +6034,8 @@ MessageNode* MessageNode::pass2(thread_db* /*tdbb*/, CompilerScratch* csb)
{
fb_assert(format);
impureOffset = CMP_impure(csb, FB_ALIGN(format->fmt_length, 2));
impureFlags = CMP_impure(csb, sizeof(USHORT) * format->fmt_count);
impureOffset = csb->allocImpure(FB_ALIGNMENT, FB_ALIGN(format->fmt_length, 2));
impureFlags = csb->allocImpure(FB_ALIGNMENT, sizeof(USHORT) * format->fmt_count);
return this;
}
@ -6527,7 +6530,7 @@ ModifyNode* ModifyNode::pass2(thread_db* tdbb, CompilerScratch* csb)
if (!(marks & StmtNode::MARK_POSITIONED))
forNode = pass2FindForNode(parentStmt, orgStream);
impureOffset = CMP_impure(csb, sizeof(impure_state));
impureOffset = csb->allocImpure<impure_state>();
return this;
}
@ -7441,7 +7444,7 @@ StoreNode* StoreNode::pass2(thread_db* tdbb, CompilerScratch* csb)
ExprNode::doPass2(tdbb, csb, i->value.getAddress());
}
impureOffset = CMP_impure(csb, sizeof(impure_state));
impureOffset = csb->allocImpure<impure_state>();
return this;
}

6
src/dsql/WinNodes.cpp
View File

@ -142,7 +142,7 @@ ValueExprNode* RankWinNode::copy(thread_db* tdbb, NodeCopier& /*copier*/) const
AggNode* RankWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
tempImpure = CMP_impure(csb, sizeof(impure_value_ex));
tempImpure = csb->allocImpure<impure_value_ex>();
return this;
}
@ -218,7 +218,7 @@ ValueExprNode* PercentRankWinNode::copy(thread_db* tdbb, NodeCopier& /*copier*/)
AggNode* PercentRankWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
tempImpure = CMP_impure(csb, sizeof(impure_value_ex));
tempImpure = csb->allocImpure<impure_value_ex>();
return this;
}
@ -803,7 +803,7 @@ ValueExprNode* NTileWinNode::copy(thread_db* tdbb, NodeCopier& copier) const
AggNode* NTileWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
{
AggNode::pass2(tdbb, csb);
thisImpureOffset = CMP_impure(csb, sizeof(ThisImpure));
thisImpureOffset = csb->allocImpure<ThisImpure>();
return this;
}

13
src/jrd/JrdStatement.cpp
View File

@ -45,6 +45,19 @@ template <typename T> static void makeSubRoutines(thread_db* tdbb, JrdStatement*
CompilerScratch* csb, T& subs);
ULONG CompilerScratch::allocImpure(ULONG align, ULONG size)
{
const ULONG offset = FB_ALIGN(csb_impure, align);
if (offset + size > JrdStatement::MAX_REQUEST_SIZE)
IBERROR(226); // msg 226: request size limit exceeded
csb_impure = offset + size;
return offset;
}
// Start to turn a parsed scratch into a statement. This is completed by makeStatement.
JrdStatement::JrdStatement(thread_db* tdbb, MemoryPool* p, CompilerScratch* csb)
: pool(p),

8
src/jrd/Optimizer.cpp
View File

@ -110,7 +110,7 @@ namespace
cast = FB_NEW_POOL(csb->csb_pool) CastNode(csb->csb_pool);
cast->source = value;
cast->castDesc = desc;
cast->impureOffset = CMP_impure(csb, sizeof(impure_value));
cast->impureOffset = csb->allocImpure<impure_value>();
}
value = cast;
@ -140,7 +140,7 @@ namespace
FB_NEW_POOL(csb->csb_pool) BoolAsValueNode(csb->csb_pool);
newValue->boolean = cmpNode;
newValue->impureOffset = CMP_impure(csb, sizeof(impure_value));
newValue->impureOffset = csb->allocImpure<impure_value>();
return newValue;
}
@ -1361,7 +1361,7 @@ InversionNode* OptimizerRetrieval::makeIndexScanNode(IndexScratch* indexScratch)
// mark the index as utilized for the purposes of this compile
idx->idx_runtime_flags |= idx_used;
const ULONG impure = csb ? CMP_impure(csb, sizeof(impure_inversion)) : 0;
const ULONG impure = csb ? csb->allocImpure<impure_inversion>() : 0;
return FB_NEW_POOL(pool) InversionNode(retrieval, impure);
}
@ -2195,7 +2195,7 @@ InversionCandidate* OptimizerRetrieval::matchDbKey(BoolExprNode* boolean) const
fb_assert(lower == upper);
InversionNode* const inversion = FB_NEW_POOL(pool) InversionNode(lower, n);
inversion->impure = CMP_impure(csb, sizeof(impure_inversion));
inversion->impure = csb->allocImpure<impure_inversion>();
invCandidate->inversion = inversion;
}
else

2
src/jrd/RecordSourceNodes.cpp
View File

@ -1949,7 +1949,7 @@ RecordSource* UnionSourceNode::generate(thread_db* tdbb, OptimizerBlk* opt, cons
CompilerScratch* csb = opt->opt_csb;
HalfStaticArray<RecordSource*, OPT_STATIC_ITEMS> rsbs;
const ULONG baseImpure = CMP_impure(csb, 0);
const ULONG baseImpure = csb->allocImpure(FB_ALIGNMENT, 0);
NestConst<RseNode>* ptr = clauses.begin();
NestConst<MapNode>* ptr2 = maps.begin();

32
src/jrd/cmp.cpp
View File

@ -321,38 +321,6 @@ IndexLock* CMP_get_index_lock(thread_db* tdbb, jrd_rel* relation, USHORT id)
}
ULONG CMP_impure(CompilerScratch* csb, ULONG size)
{
/**************************************
*
* C M P _ i m p u r e
*
**************************************
*
* Functional description
* Allocate space (offset) in request.
*
**************************************/
DEV_BLKCHK(csb, type_csb);
if (!csb)
{
return 0;
}
const ULONG offset = FB_ALIGN(csb->csb_impure, FB_ALIGNMENT);
if (offset + size > JrdStatement::MAX_REQUEST_SIZE)
{
IBERROR(226); // msg 226: request size limit exceeded
}
csb->csb_impure = offset + size;
return offset;
}
void CMP_post_access(thread_db* tdbb,
CompilerScratch* csb,
const Firebird::MetaName& security_name,

1
src/jrd/cmp_proto.h
View File

@ -42,7 +42,6 @@ Jrd::jrd_req* CMP_compile2(Jrd::thread_db*, const UCHAR* blr, ULONG blr_length,
Jrd::CompilerScratch::csb_repeat* CMP_csb_element(Jrd::CompilerScratch*, StreamType element);
const Jrd::Format* CMP_format(Jrd::thread_db*, Jrd::CompilerScratch*, StreamType);
Jrd::IndexLock* CMP_get_index_lock(Jrd::thread_db*, Jrd::jrd_rel*, USHORT);
ULONG CMP_impure(Jrd::CompilerScratch*, ULONG);
Jrd::jrd_req* CMP_make_request(Jrd::thread_db*, Jrd::CompilerScratch*, bool);
Jrd::ItemInfo* CMP_pass2_validation(Jrd::thread_db*, Jrd::CompilerScratch*, const Jrd::Item&);

9
src/jrd/exe.h
View File

@ -468,6 +468,15 @@ public:
csb_dbg_info = FB_NEW_POOL(p) Firebird::DbgInfo(p);
}
// Implemented in JrdStatement.cpp
ULONG allocImpure(ULONG align, ULONG size);
template <typename T>
ULONG allocImpure()
{
return allocImpure(alignof(T), sizeof(T));
}
StreamType nextStream(bool check = true)
{
if (csb_n_stream >= MAX_STREAMS && check)

6
src/jrd/opt.cpp
View File

@ -1969,7 +1969,7 @@ void OPT_gen_aggregate_distincts(thread_db* tdbb, CompilerScratch* csb, MapNode*
asb->length += sizeof(ULONG);
sort_key->skd_flags = SKD_ascending;
asb->impure = CMP_impure(csb, sizeof(impure_agg_sort));
asb->impure = csb->allocImpure<impure_agg_sort>();
asb->desc = *desc;
aggNode->asb = asb;
@ -2816,7 +2816,7 @@ static bool gen_equi_join(thread_db* tdbb, OptimizerBlk* opt, RiverList& org_riv
CastNode* cast = FB_NEW_POOL(*tdbb->getDefaultPool()) CastNode(*tdbb->getDefaultPool());
cast->source = node1;
cast->castDesc = result;
cast->impureOffset = CMP_impure(csb, sizeof(impure_value));
cast->impureOffset = csb->allocImpure<impure_value>();
node1 = cast;
}
@ -2825,7 +2825,7 @@ static bool gen_equi_join(thread_db* tdbb, OptimizerBlk* opt, RiverList& org_riv
CastNode* cast = FB_NEW_POOL(*tdbb->getDefaultPool()) CastNode(*tdbb->getDefaultPool());
cast->source = node2;
cast->castDesc = result;
cast->impureOffset = CMP_impure(csb, sizeof(impure_value));
cast->impureOffset = csb->allocImpure<impure_value>();
node2 = cast;
}
}

2
src/jrd/recsrc/AggregatedStream.cpp
View File

@ -48,7 +48,7 @@ BaseAggWinStream<ThisType, NextType>::BaseAggWinStream(thread_db* tdbb, Compiler
m_oneRowWhenEmpty(oneRowWhenEmpty)
{
fb_assert(m_next);
m_impure = CMP_impure(csb, sizeof(typename ThisType::Impure));
m_impure = csb->allocImpure<typename ThisType::Impure>();
}
template <typename ThisType, typename NextType>

2
src/jrd/recsrc/BitmapTableScan.cpp
View File

@ -43,7 +43,7 @@ BitmapTableScan::BitmapTableScan(CompilerScratch* csb, const string& alias,
{
fb_assert(m_inversion);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void BitmapTableScan::open(thread_db* tdbb) const

2
src/jrd/recsrc/BufferedStream.cpp
View File

@ -44,7 +44,7 @@ BufferedStream::BufferedStream(CompilerScratch* csb, RecordSource* next)
{
fb_assert(m_next);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
StreamList streams;
m_next->findUsedStreams(streams);

2
src/jrd/recsrc/ConditionalStream.cpp
View File

@ -45,7 +45,7 @@ ConditionalStream::ConditionalStream(CompilerScratch* csb,
{
fb_assert(m_first && m_second && m_boolean);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void ConditionalStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/Cursor.cpp
View File

@ -100,7 +100,7 @@ Cursor::Cursor(CompilerScratch* csb, const RecordSource* rsb,
{
fb_assert(m_top);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void Cursor::open(thread_db* tdbb) const

2
src/jrd/recsrc/ExternalTableScan.cpp
View File

@ -42,7 +42,7 @@ ExternalTableScan::ExternalTableScan(CompilerScratch* csb, const string& alias,
StreamType stream, jrd_rel* relation)
: RecordStream(csb, stream), m_relation(relation), m_alias(csb->csb_pool, alias)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void ExternalTableScan::open(thread_db* tdbb) const

2
src/jrd/recsrc/FilteredStream.cpp
View File

@ -41,7 +41,7 @@ FilteredStream::FilteredStream(CompilerScratch* csb, RecordSource* next, BoolExp
{
fb_assert(m_next && m_boolean);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void FilteredStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/FirstRowsStream.cpp
View File

@ -41,7 +41,7 @@ FirstRowsStream::FirstRowsStream(CompilerScratch* csb, RecordSource* next, Value
{
fb_assert(m_next && m_value);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void FirstRowsStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/FullOuterJoin.cpp
View File

@ -42,7 +42,7 @@ FullOuterJoin::FullOuterJoin(CompilerScratch* csb, RecordSource* arg1, RecordSou
{
fb_assert(m_arg1 && m_arg2);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void FullOuterJoin::open(thread_db* tdbb) const

2
src/jrd/recsrc/FullTableScan.cpp
View File

@ -44,7 +44,7 @@ FullTableScan::FullTableScan(CompilerScratch* csb, const string& alias,
m_relation(relation),
m_dbkeyRanges(csb->csb_pool, dbkeyRanges)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void FullTableScan::open(thread_db* tdbb) const

2
src/jrd/recsrc/HashJoin.cpp
View File

@ -212,7 +212,7 @@ HashJoin::HashJoin(thread_db* tdbb, CompilerScratch* csb, FB_SIZE_T count,
{
fb_assert(count >= 2);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
m_leader.source = args[0];
m_leader.keys = keys[0];

8
src/jrd/recsrc/IndexTableScan.cpp
View File

@ -49,7 +49,7 @@ IndexTableScan::IndexTableScan(CompilerScratch* csb, const string& alias,
{
fb_assert(m_index);
// Reserve one excess byte for the upper key - in case when length of
// Reserve one excess byte for the upper key - in case when length of
// upper key at retrieval is greater than declared index key length.
// See also comments at openStream().
FB_SIZE_T size = sizeof(Impure) + 2u * m_length + 1u;
@ -57,7 +57,7 @@ IndexTableScan::IndexTableScan(CompilerScratch* csb, const string& alias,
m_offset = size;
size += sizeof(index_desc);
m_impure = CMP_impure(csb, static_cast<ULONG>(size));
m_impure = csb->allocImpure(FB_ALIGNMENT, static_cast<ULONG>(size));
}
void IndexTableScan::open(thread_db* tdbb) const
@ -509,8 +509,8 @@ UCHAR* IndexTableScan::openStream(thread_db* tdbb, Impure* impure, win* window)
temporary_key* limit_ptr = NULL;
if (retrieval->irb_upper_count)
{
// If upper key length is greater than declared key length, we need
// one "excess" byte for correct comparison. Without it there could
// If upper key length is greater than declared key length, we need
// one "excess" byte for correct comparison. Without it there could
// be false equality hits.
impure->irsb_nav_upper_length = MIN(m_length + 1, upper.key_length);
memcpy(impure->irsb_nav_data + m_length, upper.key_data, impure->irsb_nav_upper_length);

2
src/jrd/recsrc/LockedStream.cpp
View File

@ -39,7 +39,7 @@ LockedStream::LockedStream(CompilerScratch* csb, RecordSource* next)
{
fb_assert(m_next);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void LockedStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/MergeJoin.cpp
View File

@ -41,7 +41,7 @@ MergeJoin::MergeJoin(CompilerScratch* csb, FB_SIZE_T count,
: m_args(csb->csb_pool), m_keys(csb->csb_pool)
{
const size_t size = sizeof(struct Impure) + count * sizeof(Impure::irsb_mrg_repeat);
m_impure = CMP_impure(csb, static_cast<ULONG>(size));
m_impure = csb->allocImpure(FB_ALIGNMENT, static_cast<ULONG>(size));
m_args.resize(count);
m_keys.resize(count);

4
src/jrd/recsrc/NestedLoopJoin.cpp
View File

@ -37,7 +37,7 @@ using namespace Jrd;
NestedLoopJoin::NestedLoopJoin(CompilerScratch* csb, FB_SIZE_T count, RecordSource* const* args)
: m_joinType(INNER_JOIN), m_args(csb->csb_pool), m_boolean(NULL)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
m_args.resize(count);
@ -51,7 +51,7 @@ NestedLoopJoin::NestedLoopJoin(CompilerScratch* csb, RecordSource* outer, Record
{
fb_assert(outer && inner);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
m_args.add(outer);
m_args.add(inner);

2
src/jrd/recsrc/ProcedureScan.cpp
View File

@ -45,7 +45,7 @@ ProcedureScan::ProcedureScan(CompilerScratch* csb, const string& alias, StreamTy
: RecordStream(csb, stream, procedure->prc_record_format), m_alias(csb->csb_pool, alias),
m_procedure(procedure), m_sourceList(sourceList), m_targetList(targetList), m_message(message)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
fb_assert(!sourceList == !targetList);

2
src/jrd/recsrc/RecursiveStream.cpp
View File

@ -50,7 +50,7 @@ RecursiveStream::RecursiveStream(CompilerScratch* csb, StreamType stream, Stream
{
fb_assert(m_root && m_inner && m_rootMap && m_innerMap);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
m_saveSize = csb->csb_impure - saveOffset;
m_innerStreams.resize(streamCount);

2
src/jrd/recsrc/SingularStream.cpp
View File

@ -39,7 +39,7 @@ SingularStream::SingularStream(CompilerScratch* csb, RecordSource* next)
m_next->findUsedStreams(m_streams);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void SingularStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/SkipRowsStream.cpp
View File

@ -41,7 +41,7 @@ SkipRowsStream::SkipRowsStream(CompilerScratch* csb, RecordSource* next, ValueEx
{
fb_assert(m_next && m_value);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void SkipRowsStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/SortedStream.cpp
View File

@ -44,7 +44,7 @@ SortedStream::SortedStream(CompilerScratch* csb, RecordSource* next, SortMap* ma
{
fb_assert(m_next && m_map);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void SortedStream::open(thread_db* tdbb) const

2
src/jrd/recsrc/Union.cpp
View File

@ -41,7 +41,7 @@ Union::Union(CompilerScratch* csb, StreamType stream,
{
fb_assert(argCount);
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
m_args.resize(argCount);

2
src/jrd/recsrc/VirtualTableScan.cpp
View File

@ -41,7 +41,7 @@ VirtualTableScan::VirtualTableScan(CompilerScratch* csb, const string& alias,
StreamType stream, jrd_rel* relation)
: RecordStream(csb, stream), m_relation(relation), m_alias(csb->csb_pool, alias)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void VirtualTableScan::open(thread_db* tdbb) const

4
src/jrd/recsrc/WindowedStream.cpp
View File

@ -92,7 +92,7 @@ namespace
BufferedStreamWindow::BufferedStreamWindow(CompilerScratch* csb, BufferedStream* next)
: m_next(next)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
}
void BufferedStreamWindow::open(thread_db* tdbb) const
@ -187,7 +187,7 @@ WindowedStream::WindowedStream(thread_db* tdbb, CompilerScratch* csb,
: m_next(FB_NEW_POOL(csb->csb_pool) BufferedStream(csb, next)),
m_joinedStream(NULL)
{
m_impure = CMP_impure(csb, sizeof(Impure));
m_impure = csb->allocImpure<Impure>();
// Process the unpartioned and unordered map, if existent.