void CConParser::work( const bool bTrain , const CTwoStringVector &sentence , CSentenceParsed *retval , const CSentenceParsed &correct , int nBest , SCORE_TYPE *scores ) {
static CStateItem lattice[(MAX_SENTENCE_SIZE*(2+UNARY_MOVES)+2)*(AGENDA_SIZE+1)+1000000];
static CStateItem *lattice_index[MAX_SENTENCE_SIZE*(2+UNARY_MOVES)+2+1000000];
#ifdef DEBUG
clock_t total_start_time = clock();
#endif
const int length = sentence.size() ;
const static CStateItem *pGenerator ;
const static CStateItem *pBestGen;
const static CStateItem *correctState ;
static bool bCorrect ; // used in learning for early update
static int tmp_i, tmp_j;
static CAction correct_action;
static CScoredStateAction scored_correct_action;
static bool correct_action_scored;
static std::vector<CAction> actions; // actions to apply for a candidate
static CAgendaSimple<CScoredStateAction> beam(AGENDA_SIZE);
static CScoredStateAction scored_action; // used rank actions
ASSERT(nBest=1, "currently only do 1 best parse");
static unsigned index;
static bool bSkipLast;
#ifdef SCALE
bool bAllTerminated;
#endif
static CPackedScoreType<SCORE_TYPE, CAction::MAX> packedscores;
assert(length<MAX_SENTENCE_SIZE);
TRACE("Initialising the decoding process ... ") ;
// initialise word cache
m_lCache.clear();
m_lWordLen.clear();
for ( tmp_i=0; tmp_i<length; tmp_i++ ) {
if(sentence[tmp_i].first != "-NONE-")
{
m_lCache.push_back( CTaggedWord<CTag, TAG_SEPARATOR>(sentence[tmp_i].first , sentence[tmp_i].second) );
m_lWordLen.push_back( getUTF8StringLength(sentence[tmp_i].first) );
}
}
// initialise agenda
lattice_index[0] = lattice;
lattice_index[0]->clear();
lattice_index[0]->m_lCache = &m_lCache;
lattice_index[0]->m_lEmptyWords = m_lEmptyWords;
#ifdef TRAIN_LOSS
lattice_index[0]->bTrain = m_bTrain;
getLabeledBrackets(correct, lattice_index[0]->gold_lb);
TRACE(lattice_index[0]->gold_lb << std::endl);
#endif
#ifndef EARLY_UPDATE
if (bTrain) bSkipLast = false;
#endif
lattice_index[1] = lattice+1;
if (bTrain) {
correctState = lattice_index[0];
}
index=0;
TRACE("Decoding start ... ") ;
while (true) { // for each step
++index;
lattice_index[index+1] = lattice_index[index];
beam.clear();
pBestGen = 0;
if (bTrain) {
bCorrect = false;
correctState->StandardMove(correct, correct_action);
correct_action_scored = false;
}
for (pGenerator=lattice_index[index-1]; pGenerator!=lattice_index[index]; ++pGenerator) { // for each generator
#ifndef EARLY_UPDATE
if (bTrain && bSkipLast && pGenerator == lattice_index[index]-1) {
getOrUpdateStackScore(static_cast<CWeight*>(m_weights), packedscores, pGenerator);
scored_correct_action.load(correct_action, pGenerator, packedscores[correct_action.code()]);
correct_action_scored = true;
break;
}
#endif
// load context
m_Context.load(pGenerator, m_lCache, m_lWordLen, false);
// get actions
m_rule.getActions(*pGenerator, actions);
if (actions.size() > 0)
getOrUpdateStackScore(static_cast<CWeight*>(m_weights), packedscores, pGenerator);
for (tmp_j=0; tmp_j<actions.size(); ++tmp_j) {
scored_action.load(actions[tmp_j], pGenerator, packedscores[actions[tmp_j].code()]);
beam.insertItem(&scored_action);
if (bTrain && pGenerator == correctState && actions[tmp_j] == correct_action) {
scored_correct_action = scored_action;
correct_action_scored = true;
}
}
} // done iterating generator item
#ifdef SCALE
bAllTerminated = true;
#endif
// insertItems
for (tmp_j=0; tmp_j<beam.size(); ++tmp_j) { // insert from
pGenerator = beam.item(tmp_j)->item;
pGenerator->Move(lattice_index[index+1], beam.item(tmp_j)->action);
lattice_index[index+1]->score = beam.item(tmp_j)->score;
#ifdef SCALE
if ( ! lattice_index[index+1]->IsTerminated() )
bAllTerminated = false;
#endif
if ( pBestGen == 0 || lattice_index[index+1]->score > pBestGen->score ) {
pBestGen = lattice_index[index+1];
}
// update bestgen
if (bTrain) {
if ( pGenerator == correctState && beam.item(tmp_j)->action == correct_action ) {
correctState = lattice_index[index+1];
assert (correctState->unaryreduces()<=UNARY_MOVES) ;
bCorrect = true;
}
}
++lattice_index[index+1];
}
#ifdef SCALE
if (bAllTerminated)
break; // while
#else
if (pBestGen->IsTerminated())
break; // while
#endif
// update items if correct item jump out of the agenda
if (bTrain) {
if (!bCorrect ) {
// note that if bCorrect == true then the correct state has
// already been updated, and the new value is one of the new states
// among the newly produced from lattice[index+1].
correctState->Move(lattice_index[index+1], correct_action);
correctState = lattice_index[index+1];
lattice_index[index+1]->score = scored_correct_action.score;
++lattice_index[index+1];
assert(correct_action_scored); // scored_correct_act valid
#ifdef EARLY_UPDATE
// if (!bCorrect ) {
TRACE("Error at the "<<correctState->current_word<<"th word; total is "<<m_lCache.size())
// update
#ifdef TRAIN_MULTI
updateScoresForMultipleStates(lattice_index[index], lattice_index[index+1], candidate_outout, correctState) ;
#else
// trace
correctState->trace(&sentence);
pBestGen->trace(&sentence);
// updateScoresByLoss(pBestGen, correctState) ;
updateScoresForStates(pBestGen, correctState) ;
#endif // TRAIN_MULTI
return ;
// } // bCorrect
#else // EARLY UDPATE
bSkipLast = true;
#endif
} // bCorrect
} // bTrain
} // while
if (bTrain) {
// make sure that the correct item is stack top finally
if ( pBestGen != correctState ) {
if (!bCorrect) {
correctState->Move(lattice_index[index+1], correct_action);
correctState = lattice_index[index+1];
lattice_index[index+1]->score = scored_correct_action.score;
assert(correct_action_scored); // scored_correct_act valid
}
TRACE("The best item is not the correct one")
#ifdef TRAIN_MULTI
updateScoresForMultipleStates(lattice_index[index], lattice_index[index+1], pBestGen, correctState) ;
#else // TRAIN_MULTI
correctState->trace(&sentence);
pBestGen->trace(&sentence);
// updateScoresByLoss(pBestGen, correctState) ;
updateScoresForStates(pBestGen, correctState) ;
#endif // TRAIN_MULTI
return ;
}
else {
TRACE("correct");
correctState->trace(&sentence);
pBestGen->trace(&sentence);
}
}
if (!retval)
return;
TRACE("Outputing sentence");
pBestGen->GenerateTree( sentence, retval[0] );
if (scores) scores[0] = pBestGen->score;
TRACE("Done, the highest score is: " << pBestGen->score ) ;
TRACE("The total time spent: " << double(clock() - total_start_time)/CLOCKS_PER_SEC) ;
}
inline void CConParser::getOrUpdateStackScore( CWeight *cast_weights, CPackedScoreType<SCORE_TYPE, CAction::MAX> &retval, const CStateItem *item, const CAction &action, SCORE_TYPE amount , int round ) {
retval.reset();
if (m_Context.stacksize==0) return;
static unsigned long j;
static CCFGSet s0ts1tbt;
s0ts1tbt.copy(m_Context.s0ts1tbt);
#ifdef _CHINESE_CFG_H
// static unsigned long s0c_bracket_action;
// static unsigned long s1c_bracket_action;
// static unsigned long n0t_bracket_action;
// static unsigned long s0cs1c_bracket_action;
// static unsigned long s0cn0t_bracket_action;
#endif
// static unsigned long s0cs1c_distaction;
#ifdef _CHINESE_CFG_H
// s0c_bracket_action = encodeAction(action, m_Context.s0c_bracket);
// s1c_bracket_action = encodeAction(action, m_Context.s1c_bracket);
// n0t_bracket_action = encodeAction(action, m_Context.n0t_bracket);
// s0cs1c_bracket_action = encodeAction(action, m_Context.s0cs1c_bracket);
// s0cn0t_bracket_action = encodeAction(action, m_Context.s0cn0t_bracket);
#endif
// s0cs1c_distaction = encodeAction(action, m_Context.s0cs1c_dist);
static CTuple2<CWord, CConstituent> word_constituent;
static CTuple2<CTag, CConstituent> tag_constituent;
static CTuple2<CTwoWords, CCFGSet> twoword_cfgset;
static CTuple2<CWord, CCFGSet> word_cfgset;
static CActionType actionType;
actionType.code = action.type();
const CAction &a1 = item->action;
const CAction &a2 = item->statePtr->action;
static CTuple2<CAction, CAction> tuple_action2;
// CWeight* cast_weights = (amount&&(round!=-1)) ? m_delta : static_cast<CWeight*>(m_weights);
// S0
cast_weights->m_mapS0w.getOrUpdateScore(retval, *(m_Context.s0wt), action.code(), m_nScoreIndex, amount, round);
if (!m_Context.s0c.empty()) cast_weights->m_mapS0c.getOrUpdateScore(retval, m_Context.s0c, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s0t), &(m_Context.s0c));
cast_weights->m_mapS0tc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s0w, &(m_Context.s0c));
cast_weights->m_mapS0wc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
// S1
if (m_Context.s1!=0) {
cast_weights->m_mapS1w.getOrUpdateScore(retval, *(m_Context.s1wt), action.code(), m_nScoreIndex, amount, round);
if (!m_Context.s1c.empty()) cast_weights->m_mapS1c.getOrUpdateScore(retval, m_Context.s1c, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s1t), &(m_Context.s1c));
cast_weights->m_mapS1tc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s1w, &(m_Context.s1c));
cast_weights->m_mapS1wc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S2
if (m_Context.s2!=0) {
// cast_weights->m_mapS2w.getOrUpdateScore(retval, *(m_Context.s2w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapS2c.getOrUpdateScore(retval, s2c_action, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s2t), &(m_Context.s2c));
cast_weights->m_mapS2tc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s2w, &(m_Context.s2c));
cast_weights->m_mapS2wc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S3
if (m_Context.s3!=0) {
// cast_weights->m_mapS3w.getOrUpdateScore(retval, *(m_Context.s3w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapS3c.getOrUpdateScore(retval, s3c_action, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s3t), &(m_Context.s3c));
cast_weights->m_mapS3tc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s3w, &(m_Context.s3c));
cast_weights->m_mapS3wc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// N0
if (m_Context.n0!=-1) {
// cast_weights->m_mapN0w.getOrUpdateScore(retval, *(m_Context.n0w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapN0t.getOrUpdateScore(retval, n0t_action, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapN0wt.getOrUpdateScore(retval, *(m_Context.n0wt), action.code(), m_nScoreIndex, amount, round);
}
// N1
if (m_Context.n1!=-1) {
// cast_weights->m_mapN1w.getOrUpdateScore(retval, *(m_Context.n1w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapN1t.getOrUpdateScore(retval, n1t_action, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapN1wt.getOrUpdateScore(retval, *(m_Context.n1wt), action.code(), m_nScoreIndex, amount, round);
}
// N2
if (m_Context.n2!=-1) {
// cast_weights->m_mapN2w.getOrUpdateScore(retval, *(m_Context.n2w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapN2t.getOrUpdateScore(retval, n2t_action, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapN2wt.getOrUpdateScore(retval, *(m_Context.n2wt), action.code(), m_nScoreIndex, amount, round);
}
// N3
if (m_Context.n3!=-1) {
// cast_weights->m_mapN3w.getOrUpdateScore(retval, *(m_Context.n3w), action.code(), m_nScoreIndex, amount, round);
// cast_weights->m_mapN3t.getOrUpdateScore(retval, n3t_action, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapN3wt.getOrUpdateScore(retval, *(m_Context.n3wt), action.code(), m_nScoreIndex, amount, round);
}
// S0L
if (m_Context.s0l!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s0lt), &(m_Context.s0lc));
cast_weights->m_mapS0Ltc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s0lw, &(m_Context.s0lc));
cast_weights->m_mapS0Lwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S0R
if (m_Context.s0r!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s0rt), &(m_Context.s0rc));
cast_weights->m_mapS0Rtc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s0rw, &(m_Context.s0rc));
cast_weights->m_mapS0Rwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S0U
if (m_Context.s0u!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s0ut), &(m_Context.s0uc));
cast_weights->m_mapS0Utc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s0uw, &(m_Context.s0uc));
cast_weights->m_mapS0Uwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S1L
if (m_Context.s1l!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s1lt), &(m_Context.s1lc));
cast_weights->m_mapS1Ltc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s1lw, &(m_Context.s1lc));
cast_weights->m_mapS1Lwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S1R
if (m_Context.s1r!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s1rt), &(m_Context.s1rc));
cast_weights->m_mapS1Rtc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s1rw, &(m_Context.s1rc));
cast_weights->m_mapS1Rwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S1U
if (m_Context.s1u!=0) {
refer_or_allocate_tuple2(tag_constituent, &(m_Context.s1ut), &(m_Context.s1uc));
cast_weights->m_mapS1Utc.getOrUpdateScore(retval, tag_constituent, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_constituent, m_Context.s1uw, &(m_Context.s1uc));
cast_weights->m_mapS1Uwc.getOrUpdateScore(retval, word_constituent, action.code(), m_nScoreIndex, amount, round);
}
// S0 S1
if (m_Context.s1!=0) {
refer_or_allocate_tuple2(twoword_cfgset, &(m_Context.s0ws1w), &(m_Context.s0cs1c));
cast_weights->m_mapS0wcS1wc.getOrUpdateScore(retval, twoword_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s1w, &(m_Context.s0cs1c));
cast_weights->m_mapS0cS1w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s0cs1c));
cast_weights->m_mapS0wS1c.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0cS1c.getOrUpdateScore(retval, m_Context.s0cs1c, action.code(), m_nScoreIndex, amount, round);
}
// S0 N0
if (m_Context.n0!=-1) {
refer_or_allocate_tuple2(twoword_cfgset, &(m_Context.s0wn0w), &(m_Context.s0cn0t));
cast_weights->m_mapS0wN0w.getOrUpdateScore(retval, twoword_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.s0cn0t));
cast_weights->m_mapS0cN0w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s0cn0t));
cast_weights->m_mapS0wN0t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0cN0t.getOrUpdateScore(retval, m_Context.s0cn0t, action.code(), m_nScoreIndex, amount, round);
}
// S1 N0
if (m_Context.s1!=0 && m_Context.n0!=-1) {
refer_or_allocate_tuple2(twoword_cfgset, &(m_Context.s1wn0w), &(m_Context.s1cn0t));
cast_weights->m_mapS1wN0w.getOrUpdateScore(retval, twoword_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.s1cn0t));
cast_weights->m_mapS1cN0w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s1w, &(m_Context.s1cn0t));
cast_weights->m_mapS1wN0t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS1cN0t.getOrUpdateScore(retval, m_Context.s1cn0t, action.code(), m_nScoreIndex, amount, round);
}
// N0 N1
if (m_Context.n1!=-1) {
refer_or_allocate_tuple2(twoword_cfgset, &(m_Context.n0wn1w), &(m_Context.n0tn1t));
cast_weights->m_mapN0wN1w.getOrUpdateScore(retval, twoword_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n1w, &(m_Context.n0tn1t));
cast_weights->m_mapN0tN1w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.n0tn1t));
cast_weights->m_mapN0wN1t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapN0tN1t.getOrUpdateScore(retval, m_Context.n0tn1t, action.code(), m_nScoreIndex, amount, round);
}
#ifdef _CHINESE_CFG_H
/* BRACKET PUNC */
#endif
// S0 S1 N0
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s0cs1cn0t));
cast_weights->m_mapS0wS1cN0t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
if (m_Context.s1!=0) {
refer_or_allocate_tuple2(word_cfgset, m_Context.s1w, &(m_Context.s0cs1cn0t));
cast_weights->m_mapS0cS1wN0t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
if (m_Context.n0!=-1) {
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.s0cs1cn0t));
cast_weights->m_mapS0cS1cN0w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
cast_weights->m_mapS0cS1cN0t.getOrUpdateScore(retval, m_Context.s0cs1cn0t, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0tS1tN0t.getOrUpdateScore(retval, m_Context.s0ts1tn0t, action.code(), m_nScoreIndex, amount, round);
// S0 N0 N1
if (m_Context.n0!=-1) {
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s0cn0tn1t));
cast_weights->m_mapS0wN0tN1t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.s0cn0tn1t));
cast_weights->m_mapS0cN0wN1t.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
if (m_Context.n1!=-1) {
refer_or_allocate_tuple2(word_cfgset, m_Context.n1w, &(m_Context.s0cn0tn1t));
cast_weights->m_mapS0cN0tN1w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
cast_weights->m_mapS0cN0tN1t.getOrUpdateScore(retval, m_Context.s0cn0tn1t, action.code(), m_nScoreIndex, amount, round); // m_Context.n0
cast_weights->m_mapS0tN0tN1t.getOrUpdateScore(retval, m_Context.s0tn0tn1t, action.code(), m_nScoreIndex, amount, round); // m_Context.n0
}
// S0 S1 S2
if (m_Context.s1!=0) {
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s0cs1cs2c));
cast_weights->m_mapS0wS1cS2c.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s1w, &(m_Context.s0cs1cs2c));
cast_weights->m_mapS0cS1wS2c.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
if (m_Context.s2!=0) {
refer_or_allocate_tuple2(word_cfgset, m_Context.s2w, &(m_Context.s0cs1cs2c));
cast_weights->m_mapS0cS1cS2w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
cast_weights->m_mapS0cS1cS2c.getOrUpdateScore(retval, m_Context.s0cs1cs2c, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0tS1tS2t.getOrUpdateScore(retval, m_Context.s0ts1ts2t, action.code(), m_nScoreIndex, amount, round);
}
if (m_Context.n0!=-1 && m_Context.s0r!=0) {
cast_weights->m_mapS0cS0RcN0t.getOrUpdateScore(retval, m_Context.s0cs0rcn0t, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0cS0RjN0t.getOrUpdateScore(retval, m_Context.s0cs0rjn0t, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.n0w, &(m_Context.s0cs0rc));
cast_weights->m_mapS0cS0RcN0w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
// S0 S0LRUS1
if (m_Context.s1!=0 && m_Context.s0l!=0) {
cast_weights->m_mapS0cS0LcS1c.getOrUpdateScore(retval, m_Context.s0cs0lcs1c, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0cS0LjS1j.getOrUpdateScore(retval, m_Context.s0cs0ljs1j, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s1w, &(m_Context.s0cs0lc));
cast_weights->m_mapS0cS0LcS1w.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
if (m_Context.s1 != 0 && m_Context.s1r != 0) {
cast_weights->m_mapS0cS1cS1Rc.getOrUpdateScore(retval, m_Context.s0cs1cs1rc, action.code(), m_nScoreIndex, amount, round);
cast_weights->m_mapS0jS1cS1Rj.getOrUpdateScore(retval, m_Context.s0js1cs1rj, action.code(), m_nScoreIndex, amount, round);
refer_or_allocate_tuple2(word_cfgset, m_Context.s0w, &(m_Context.s1cs1rc));
cast_weights->m_mapS0wS1cS1Rc.getOrUpdateScore(retval, word_cfgset, action.code(), m_nScoreIndex, amount, round);
}
// cast_weights->m_mapA1.getOrUpdateScore(retval, a1, action.code(), m_nScoreIndex, amount, round);
// refer_or_allocate_tuple2(tuple_action2, &a1, &a2);
// cast_weights->m_mapA1A2.getOrUpdateScore(retval, tuple_action2, action.code(), m_nScoreIndex, amount, round);
}