Fragment * Parser::nt_curly_block(Fragment *preceding, int depth) { logtrace << depth << ") nt_curly_block: begin."; Token& tok = next_token(); assert( matchSymbol('{') ); pushExpectedSymbol("}"); Fragment *block = new Fragment(Fragment::Kind::block); block->push_token(&tok); block->set_previous_fragment( preceding ); if (preceding != nullptr) preceding->set_next_fragment( block ); while(true) { nt_whatever(block, depth+1); tok = next_token(); if (tok.is_symbol('}')) { logdebug << depth << ") nt_curly_block: matched expected '}' symbol" "– end-of-block – ok, returning to caller."; break; } } logtrace << depth << ") nt_curly_block: end."; return block; }
/// As per http://wiki.shopify.com/Divided_by static Fragment* DividedBy(Fragment* input, std::vector<Fragment*>& arguments) { // Check for arguments if ((arguments.size() < 1) || ((input->GetType() != FragmentTypeInteger) && (input->GetType() != FragmentTypeFloat)) || ((arguments[0]->GetType() != FragmentTypeInteger) && (arguments[0]->GetType() != FragmentTypeFloat))) return new NullFragment(); Fragment* operand = arguments[0]; FragmentType inputType = input->GetType(), operandType = operand->GetType(); // Handle depending on input type if ((inputType == FragmentTypeInteger) && (operandType == FragmentTypeInteger)) { int64_t a = reinterpret_cast<IntegerFragment*>(input)->GetValue(), b = reinterpret_cast<IntegerFragment*>(operand)->GetValue(); return new IntegerFragment(b == 0 ? 0 : a / b); } double a = (inputType == FragmentTypeInteger ? double(reinterpret_cast<IntegerFragment*>(input)->GetValue()) : reinterpret_cast<FloatFragment*>(input)->GetValue()), b = (operandType == FragmentTypeInteger ? double(reinterpret_cast<IntegerFragment*>(operand)->GetValue()) : reinterpret_cast<FloatFragment*>(operand)->GetValue()); return new FloatFragment(b == 0 ? 0 : a / b); }
Node* CylinderSurfaceModule::evaluate(Context* ctx) { NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0)); decimal h=1.0; if(heightValue) h=heightValue->getNumber(); NumberValue* rValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1)); decimal r=1.0; if(rValue) r=rValue->getNumber(); Value* centerValue=getParameterArgument(ctx,2); bool center=false; if(centerValue) center=centerValue->isTrue(); decimal z1,z2; z1 = 0.0; z2 = h; Fragment* fg = Fragment::createFragment(ctx); int f = fg->getFragments(r); delete fg; QList<Point> c1=getCircle(r,f,z1); QList<Point> c2=getCircle(r,f,z2); PrimitiveNode* p=new PrimitiveNode(reporter); p->setChildren(ctx->getInputNodes()); foreach(Point pt,c1) { p->createVertex(pt); }
ZTPManager::ResultState ZTPManager::SendOneZtp(ZTPprotocol& ztp,const QHostAddress &host,quint16 port) { ztp.genarate(); quint16 identifier = QDateTime::currentMSecsSinceEpoch()&0xffff; //用utc的低16位作为分片标识 quint16 fragment_count = ztp.getRwaData().length()/MTU+1; quint16 fragment_offset = 1; for(int i = 0;i < fragment_count;i++) { Fragment fragment; fragment.identifier = identifier; //用utc的低16位作为分片标识 fragment.fragment_count = fragment_count; fragment.fragment_offset = fragment_offset++; fragment.data = ztp.getRwaData().left(MTU); ztp.getRwaData().remove(0,MTU); fragment.len = fragment.data.length(); fragment.generate(); int sendLen = _Socketlistener.writeDatagram(fragment.rawPkg,host,port); if(sendLen != fragment.rawPkg.length()) { qDebug("send ZTP data error: has data %d bytes and actually send %d bytes!!\n", fragment.len,sendLen); return FAILED; } // qDebug()<<"send---fragment : "<<fragment.identifier<<" "<<fragment.checksum<<" "<<fragment.fragment_count<<" "<<fragment.fragment_offset<<" "<<fragment.data.length(); msleep(1); } return SUCCESS; }
void EhFrame::moveInputFragments(EhFrame& pInFrame, CIE& pInCIE, CIE* pOutCIE) { SectionData& in_sd = *pInFrame.getSectionData(); SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList(); SectionData& out_sd = *getSectionData(); SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList(); if (!pOutCIE) { // Newly inserted Fragment* frag = in_frag_list.remove(SectionData::iterator(pInCIE)); out_frag_list.push_back(frag); frag->setParent(&out_sd); for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) { frag = in_frag_list.remove(SectionData::iterator(**i)); out_frag_list.push_back(frag); frag->setParent(&out_sd); } return; } SectionData::iterator cur_iter(*pOutCIE); assert (cur_iter != out_frag_list.end()); for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) { Fragment* frag = in_frag_list.remove(SectionData::iterator(**i)); cur_iter = out_frag_list.insertAfter(cur_iter, frag); frag->setParent(&out_sd); } }
void EhFrame::addFragment(Fragment& pFrag) { uint32_t offset = 0; if (!m_pSectionData->empty()) offset = m_pSectionData->back().getOffset() + m_pSectionData->back().size(); m_pSectionData->getFragmentList().push_back(&pFrag); pFrag.setParent(m_pSectionData); pFrag.setOffset(offset); }
Fragment Fragment::concatenate(Fragment e1, Fragment e2) { //! +----+ +----+ //! >| e1 |-->| e2 |--> //! +----+ +----+ e1.patch(e2.start()); return Fragment(e1.start(), e2.dangling()); }
/// As per http://wiki.shopify.com/Times static Fragment* Times(Fragment* input, std::vector<Fragment*>& arguments) { // Check for arguments if ((arguments.size() < 1) || ((input->GetType() != FragmentTypeInteger) && (input->GetType() != FragmentTypeFloat) && (input->GetType() != FragmentTypeString)) || ((arguments[0]->GetType() != FragmentTypeInteger) && (arguments[0]->GetType() != FragmentTypeFloat))) return new NullFragment(); Fragment* operand = arguments[0]; FragmentType inputType = input->GetType(), operandType = operand->GetType(); // String multiplication if (inputType == FragmentTypeString) { if (operandType == FragmentTypeInteger) { std::string inputString = reinterpret_cast<StringFragment*>(input)->GetValue(), result; int64_t times = reinterpret_cast<IntegerFragment*>(operand)->GetValue(), current = 0; while (current < times) { result += inputString; current++; } return new StringFragment(result); } else return new NullFragment(); } // Number multiplication if ((inputType == FragmentTypeInteger) && (operandType == FragmentTypeInteger)) return new IntegerFragment(reinterpret_cast<IntegerFragment*>(input)->GetValue() * reinterpret_cast<IntegerFragment*>(operand)->GetValue()); double a = (inputType == FragmentTypeInteger ? double(reinterpret_cast<IntegerFragment*>(input)->GetValue()) : reinterpret_cast<FloatFragment*>(input)->GetValue()), b = (operandType == FragmentTypeInteger ? double(reinterpret_cast<IntegerFragment*>(operand)->GetValue()) : reinterpret_cast<FloatFragment*>(operand)->GetValue()); return new FloatFragment(a * b); }
void EhFrame::moveInputFragments(EhFrame& pInFrame) { SectionData& in_sd = *pInFrame.getSectionData(); SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList(); SectionData& out_sd = *getSectionData(); SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList(); while (!in_frag_list.empty()) { Fragment* frag = in_frag_list.remove(in_frag_list.begin()); out_frag_list.push_back(frag); frag->setParent(&out_sd); } }
Fragment Fragment::optional(Fragment e1) { //! +----+ //! +-->| e1 |--> //! | +----+ //! >O-----------> State* state = new State; state->what = State::Split; state->out[0] = e1.start(); return Fragment(state, e1.dangling(), { &state->out[1] }); }
void ImageCache::CleanUp(int min_size_free) { Fragment *f = (Fragment *)cache.Last(); while (f && pixelcount + min_size_free > cachesize) { OpBitmap *bm = f->GetFragment(); pixelcount -= bm->Width() * bm->Height(); Fragment *prev = (Fragment *)f->Pred(); f->Out(); OP_DELETE(f); f = prev; } }
Fragment Fragment::loopone(Fragment e1) { //! +-----+ //! v | //! +----+ | //! >| e1 |-->O--> //! +----+ State* state = new State; state->what = State::Split; state->out[0] = e1.start(); e1.patch(state); return Fragment(e1.start(), { &state->out[1] }); }
void ImageCache::Add(OpBitmap *original, OpBitmap *fragment, int scaled_width, int scaled_height, int x_off, int y_off) { //printf("ImageCache::Add: Disabled\n"); //OP_DELETE(fragment); //return; if (Find(original, scaled_width, scaled_height, x_off, y_off, fragment->Width(), fragment->Height())) { // Already in cache. OP_ASSERT(FALSE); return; } int this_size = fragment->Width() * fragment->Height(); if (this_size * 3 / 2 > cachesize) { // Very big image. Don't cache it. OP_DELETE(fragment); return; } if (pixelcount + this_size > cachesize) { // Cache too full. Try to clean up. CleanUp(this_size); } if (pixelcount + this_size > cachesize) { // No room in cache... not even after cleanup. OP_DELETE(fragment); return; } // Since we got this far, it means that the scaling should be cached. Fragment *elm = OP_NEW(Fragment, (original, fragment, scaled_width, scaled_height, x_off, y_off)); if (!elm) { // Non-critical OOM OP_DELETE(fragment); return; } elm->IntoStart(&cache); pixelcount += this_size; }
bool WorkerView::recieveObject(Transmittable * const obj, const unsigned int nTries){ char *buf; unsigned int size; FragmentDrive drive; int failCount = 0; while(failCount < nTries) if((buf = worker_socket.syncRead((int&)size, 1000)) == nullptr || !drive.deserialize(buf, size)){ if(buf != nullptr) delete [] buf; failCount++; } else{ delete [] buf; break; } if(failCount == nTries) return false; vector<bool> filled(drive.FragmentCount, false); char *serial = new char[drive.MessageSize]; Fragment Frag; for(drive.NextFragmentID = 0; drive.NextFragmentID < drive.FragmentCount; ){ for(int i = 0; i < FragmentDrive::BatchCount && drive.NextFragmentID + i < drive.FragmentCount; i++){ if((buf = worker_socket.syncRead((int&)size, 500)) != nullptr && Frag.deserialize(buf, size) && Frag.MessageID == drive.MessageID){ if(!filled[Frag.FragmentID]) memcpy(serial + Frag.FragmentID * FragmentDrive::MaxFragmentSize, Frag.Payload, Frag.FragmentSize); filled[Frag.FragmentID] = true; failCount -= failCount > 0; } else failCount++; if(buf != nullptr) delete [] buf; } while(drive.NextFragmentID < drive.FragmentCount && filled[drive.NextFragmentID]) drive.NextFragmentID++; drive.FragmentDriveID++; buf = drive.serialize(size); failCount += worker_socket.asyncWrite(buf, size) < 0; delete [] buf; if(failCount >= nTries * FragmentDrive::BatchCount){ delete [] serial; return false; } } if(!obj->deserialize(serial, drive.MessageSize)){ cout << "A7eh" << endl; delete [] serial; return false; } delete [] serial; return true; }
Fragment Fragment::loop(Fragment e1) { //! +----+ //! +-->| e1 |--+ //! | +----+ | //! >O<----------+ //! | //! +------------> State* state = new State; state->what = State::Split; state->out[0] = e1.start(); e1.patch(state); return Fragment(state, { &state->out[1] }); }
void WldModel::readModel(const char* modelId) { WLD* wld = m_wld; Frag14* f14 = nullptr; for (Fragment* frag : wld->getFragsByType(0x14)) { const char* name = wld->getFragName(frag->nameRef()); if (strcmp(name, modelId) == 0) { f14 = (Frag14*)frag; break; } } if (!f14) throw 1; //fixme // f14 -> f11 -> f10 -> f13 -> f12 // |-> f2d -> f36 // OR // f14 -> f2d -> f36 // Is this an animated model? Fragment* frag = wld->getFrag(f14->firstRef()); if (!frag) throw 2; //fixme if (frag->type() == 0x11) { readAnimatedModel((Frag11*)frag); return; } else if (frag->type() != 0x2d) { throw 6; //fixme } Frag2d* f2d = (Frag2d*)frag; Frag36* f36 = (Frag36*)wld->getFrag(f2d->ref); if (!f36 || f36->type() != 0x36) throw 7; //fixme readMaterials(f36); readMesh(f36); }
void AArch64GNULDBackend::scanErrata(Module& pModule, IRBuilder& pBuilder, size_t& num_new_stubs, size_t& stubs_strlen) { // TODO: Implement AArch64 ErrataStubFactory to create the specific erratum // stub and simplify the logics. for (Module::iterator sect = pModule.begin(), sectEnd = pModule.end(); sect != sectEnd; ++sect) { if (((*sect)->kind() == LDFileFormat::TEXT) && (*sect)->hasSectionData()) { SectionData* sd = (*sect)->getSectionData(); for (SectionData::iterator it = sd->begin(), ie = sd->end(); it != ie; ++it) { Fragment* frag = llvm::dyn_cast<RegionFragment>(it); if (frag != NULL) { FragmentRef* frag_ref = FragmentRef::Create(*frag, 0); for (unsigned offset = 0; offset < frag->size(); offset += AArch64InsnHelpers::InsnSize) { Stub* stub = getStubFactory()->create(*frag_ref, pBuilder, *getBRIslandFactory()); if (stub != NULL) { // A stub symbol should be local assert(stub->symInfo() != NULL && stub->symInfo()->isLocal()); const AArch64CA53ErratumStub* erratum_stub = reinterpret_cast<const AArch64CA53ErratumStub*>(stub); assert(erratum_stub != NULL); // Rewrite the erratum instruction as a branch to the stub. uint64_t offset = frag_ref->offset() + erratum_stub->getErratumInsnOffset(); Relocation* reloc = Relocation::Create(llvm::ELF::R_AARCH64_JUMP26, *(FragmentRef::Create(*frag, offset)), /* pAddend */0); reloc->setSymInfo(stub->symInfo()); reloc->target() = AArch64InsnHelpers::buildBranchInsn(); addExtraRelocation(reloc); ++num_new_stubs; stubs_strlen += stub->symInfo()->nameSize() + 1; } frag_ref->assign(*frag, offset + AArch64InsnHelpers::InsnSize); } // for each INSN } } // for each FRAGMENT } } // for each TEXT section }
//===----------------------------------------------------------------------===// // Helper Functions //===----------------------------------------------------------------------===// /// compunteFragmentSize - compute the specific Fragment size uint64_t mcld::computeFragmentSize(const Layout& pLayout, const Fragment& pFrag) { switch (pFrag.getKind()) { case Fragment::Fillment: return static_cast<const FillFragment&>(pFrag).getSize(); case Fragment::Alignment: { uint64_t offset = pLayout.getOutputOffset(pFrag); const AlignFragment& align_frag = llvm::cast<AlignFragment>(pFrag); uint64_t size = llvm::OffsetToAlignment(offset, align_frag.getAlignment()); if (size > align_frag.getMaxBytesToEmit()) return 0; return size; } case Fragment::Region: return llvm::cast<RegionFragment>(pFrag).getRegion().size(); case Fragment::Target: return llvm::cast<TargetFragment>(pFrag).getSize(); case Fragment::Relocation: assert(0 && "the size of FT_Reloc fragment is handled by backend"); return 0; default: assert(0 && "invalid fragment kind"); return 0; } }
void ImageCache::Remove(OpBitmap *bitmap) { Fragment *f = (Fragment *)cache.First(); while (f) { Fragment *next = (Fragment *)f->Suc(); if (f->GetOriginal() == bitmap) { OpBitmap *bm = f->GetFragment(); pixelcount -= bm->Width() * bm->Height(); f->Out(); OP_DELETE(f); } f = next; } }
Fragment Fragment::alternate(Fragment e1, Fragment e2) { //! +----+ //! +-->| e1 |--> //! | +----+ //! >O //! | +----+ //! +-->| e2 |--> //! +----+ State* state = new State; state->what = State::Split; state->out[0] = e1.start(); state->out[1] = e2.start(); return Fragment(state, e1.dangling(), e2.dangling()); }
BOOL ImageCache::RemoveSharedMemoryBitmap() { Fragment *f = (Fragment *)cache.Last(); while (f) { X11OpBitmap* bm = (X11OpBitmap*)f->GetFragment(); if( bm->HasSharedMemory() ) { f->Out(); OP_DELETE(f); return TRUE; } f = (Fragment *)f->Pred(); } return FALSE; }
void Parser::debug_print_ast(std::ostream& os) { loginfo << "Parser::debug_print_ast(): START."; Fragment *current = fragments_; do { os << "FRAGMENT KIND: " << (int)current->kind() << " {" << std::endl; auto tokens = current->tokens(); for(Token *tok : tokens) { os << '[' << tok->text() << ']'; } os << "} [" << (int)current->kind() << "]" << std::endl; } while( (current = current->next()) != nullptr ); loginfo << "Parser::debug_print_ast(): END."; }
Fragment * Molecule::addRing(unsigned long id) { Q_D(Molecule); Fragment *ring = new Fragment(this); if (id >= d->rings.size()) d->rings.resize(id+1,0); d->rings[id] = ring; d->ringList.push_back(ring); ring->setId(id); ring->setIndex(d->ringList.size()-1); // now that the id is correct, emit the signal connect(ring, SIGNAL(updated()), this, SLOT(updatePrimitive())); // emit primitiveAdded(ring); return(ring); }
void Fragmento::clearFrags() { // reclaim any dangling native pages _assm->pageReset(); while (!_frags->isEmpty()) { Fragment *f = _frags->removeLast(); Fragment *peer = f->peer; while (peer) { Fragment *next = peer->peer; peer->releaseTreeMem(this); delete peer; peer = next; } f->releaseTreeMem(this); delete f; } verbose_only( enterCounts->clear();)
// // generate_default_instance_configs // void Locality_Manager:: generate_default_instance_configs (GAME::Xml::Fragment parent, PICML::CollocationGroup_in group) { Fragment configProperty = parent.append_element ("configProperty"); configProperty.append_simple_content ("name", "edu.vanderbilt.dre.DAnCE.LocalityManager.ProcessName"); Fragment value = configProperty.append_element ("value"); Fragment type = value.append_element ("type"); type.append_simple_content ("kind", "tk_string"); Fragment inner_value = value.append_element ("value"); inner_value.append_simple_content ("string", group->name ()); }
/// Create - create a fragment reference for a given fragment. /// /// @param pFrag - the given fragment /// @param pOffset - the offset, can be larger than the fragment, but can not /// be larger than the section size. /// @return if the offset is legal, return the fragment reference. Otherwise, /// return NULL. FragmentRef* FragmentRef::Create(Fragment& pFrag, uint64_t pOffset) { int64_t offset = pOffset; Fragment* frag = &pFrag; while (frag != NULL) { offset -= frag->size(); if (offset <= 0) break; frag = frag->getNextNode(); } if ((frag != NULL) && (frag->size() != 0)) { if (offset == 0) frag = frag->getNextNode(); else offset += frag->size(); } if (frag == NULL) return Null(); FragmentRef* result = g_FragRefFactory->allocate(); new (result) FragmentRef(*frag, offset); return result; }
int main() { Scene* scene = createScene(); System* system = createSystem(scene, createCamera(scene)); system->setBalancer(balancer); size_t nodesNumber = system->size(); size_t id = system->id(); auto split = getInterval(nodesNumber, id, Size::RESOLUTION_Y, FRAGMENTS_NUMBER); if(id == 0) { Fragment* endFragment = new Fragment(ID(-1, -1, -1), 0); for(size_t i = 0; i < nodesNumber; ++i) { auto split = getInterval(nodesNumber, i, Size::RESOLUTION_Y, FRAGMENTS_NUMBER); for(size_t j = 0; j < split.size(); ++j) { endFragment->addNeighbour(ID(i, j, 0), i); } } system->addFragment(endFragment); } vector<Fragment*> fs; size_t count = 0; for(auto& i: split) { Camera* camera = createCamera(scene); size_t b, e; tie(b, e) = i; camera->setPart(0, b, Size::RESOLUTION_X, e); fs.push_back(new Fragment(ID(id, count++, 0), camera)); } for(auto f : fs) { f->addNeighbour(ID(-1, -1, -1), 0); system->addFragment(f); } system->run(); delete system; return 0; }
/// group - group fragments and create islands when needed /// @param pSectionData - the SectionData holds fragments need to be grouped void BranchIslandFactory::group(Module& pModule) { /* FIXME: Currently only support relaxing .text section! */ LDSection* text = pModule.getSection(".text"); if (text != NULL && text->hasSectionData()) { SectionData& sd = *text->getSectionData(); uint64_t group_end = m_MaxFwdBranchRange; for (SectionData::iterator it = sd.begin(), ie = sd.end(); it != ie; ++it) { if ((*it).getOffset() + (*it).size() > group_end) { Fragment* frag = (*it).getPrevNode(); while (frag != NULL && frag->getKind() == Fragment::Alignment) { frag = frag->getPrevNode(); } if (frag != NULL) { produce(*frag); group_end = (*it).getOffset() + m_MaxFwdBranchRange; } } } if (getIslands(sd.back()).first == NULL) produce(sd.back()); } }
/// getIsland - find fwd and bwd islands for the fragment /// @param pFragment - the fragment needs a branch island std::pair<BranchIsland*, BranchIsland*> BranchIslandFactory::getIslands( const Fragment& pFragment) { BranchIsland* fwd = NULL; BranchIsland* bwd = NULL; for (iterator it = begin(), ie = end(), prev = ie; it != ie; prev = it, ++it) { if ((pFragment.getOffset() < (*it).offset()) && ((pFragment.getOffset() + m_MaxFwdBranchRange) >= (*it).offset())) { fwd = &*it; if (prev != ie) { int64_t bwd_off = (int64_t)pFragment.getOffset() + m_MaxBwdBranchRange; if ((pFragment.getOffset() > (*prev).offset()) && (bwd_off <= (int64_t)(*prev).offset())) { bwd = &*prev; } } break; } } return std::make_pair(fwd, bwd); }
Fragment * Parser::nt_whatever(Fragment *previous, int depth) { logtrace << depth << ") nt_whatever: start."; Fragment *first_fragment = new Fragment(); Fragment *current = first_fragment; while(true) { while (true) { Token& tok = next_token(); if (isExpected(tok)) { rewind_token(); logdebug << depth << ") nt_whatever: matched an expected token: " << tok.kind_as_text() << " [RETURNING TO CALLER]" ; goto my_first_goto_in_a_while; } current->push_token(&tok); // if (tok.is_blank()) { // loginfo << "nt_whatever(): skipping blank(s) token." // << tok.text(); // } // ';' terminated => STATEMENT if (tok.is_symbol(';')) { current->set_kind(Fragment::Kind::statement); logtrace << depth << ") nt_whatever: got one fragment !"; break; } // {...} BLOCK "ANTECEDENT" else if (tok.is_symbol('{')) { current->set_kind(Fragment::Kind::block_antecedent); current->pop_token(); rewind_token(); current = nt_curly_block(current, depth+1); break; } previous = current; } // Create a new fragment for accumulating tokens. current = new Fragment(); current->set_previous_fragment(previous); previous->set_next_fragment(current); } my_first_goto_in_a_while: logtrace << depth << ") nt_whatever: finished."; return first_fragment; }