/* * Helper for the freeLocalsHelpers which does the actual work of decrementing * a value's refcount or releasing it. * * This helper is reached via call from the various freeLocalHelpers. It * expects `tv' to be the address of a TypedValue with refcounted type `type' * (though it may be static, and we will do nothing in that case). * * The `live' registers must be preserved across any native calls (and * generally left untouched). */ static TCA emitDecRefHelper(CodeBlock& cb, DataBlock& data, CGMeta& fixups, PhysReg tv, PhysReg type, RegSet live) { return vwrap(cb, data, fixups, [&] (Vout& v) { // Set up frame linkage to avoid an indirect fixup. v << pushp{rlr(), rfp()}; v << copy{rsp(), rfp()}; // We use the first argument register for the TV data because we might pass // it to the native release call. It's not live when we enter the helper. auto const data = rarg(0); v << load{tv[TVOFF(m_data)], data}; auto const sf = v.makeReg(); v << cmplim{1, data[FAST_REFCOUNT_OFFSET], sf}; ifThen(v, CC_NL, sf, [&] (Vout& v) { // The refcount is positive, so the value is refcounted. We need to // either decref or release. ifThen(v, CC_NE, sf, [&] (Vout& v) { // The refcount is greater than 1; decref it. v << declm{data[FAST_REFCOUNT_OFFSET], v.makeReg()}; // Pop FP/LR and return v << popp{rfp(), rlr()}; v << ret{live}; }); // Note that the stack is aligned since we called to this helper from an // stack-unaligned stub. PhysRegSaver prs{v, live}; // The refcount is exactly 1; release the value. // Avoid 'this' pointer overwriting by reserving it as an argument. v << callm{lookupDestructor(v, type), arg_regs(1)}; // Between where %rsp is now and the saved RIP of the call into the // freeLocalsHelpers stub, we have all the live regs we pushed, plus the // saved RIP of the call from the stub to this helper. v << syncpoint{makeIndirectFixup(prs.dwordsPushed())}; // fallthru }); // Either we did a decref, or the value was static. // Pop FP/LR and return v << popp{rfp(), rlr()}; v << ret{live}; }); }
/* * Helper for the freeLocalsHelpers which does the actual work of decrementing * a value's refcount or releasing it. * * This helper is reached via call from the various freeLocalHelpers. It * expects `tv' to be the address of a TypedValue with refcounted type `type' * (though it may be static, and we will do nothing in that case). * * The `live' registers must be preserved across any native calls (and * generally left untouched). */ static TCA emitDecRefHelper(CodeBlock& cb, DataBlock& data, CGMeta& fixups, PhysReg tv, PhysReg type, RegSet live) { return vwrap(cb, data, fixups, [&] (Vout& v) { // Set up frame linkage to avoid an indirect fixup. v << stublogue{true}; v << copy{rsp(), rfp()}; // We use the first argument register for the TV data because we might pass // it to the native release call. It's not live when we enter the helper. auto const data = rarg(0); v << load{tv[TVOFF(m_data)], data}; auto destroy = [&](Vout& v) { // Note that the stack is aligned since we called to this helper from an // stack-unaligned stub. PhysRegSaver prs{v, live}; // The refcount is exactly 1; release the value. // Avoid 'this' pointer overwriting by reserving it as an argument. // There's no need for a fixup, because we setup a frame on the c++ // stack. v << callm{lookupDestructor(v, type), arg_regs(1)}; // fallthru }; auto const sf = emitCmpRefCount(v, OneReference, data); if (one_bit_refcount) { ifThen(v, CC_E, sf, destroy); } else { ifThen(v, CC_NL, sf, [&] (Vout& v) { // The refcount is positive, so the value is refcounted. We need to // either decref or release. ifThen(v, CC_NE, sf, [&] (Vout& v) { // The refcount is greater than 1; decref it. emitDecRefCount(v, data); v << stubret{live, true}; }); destroy(v); }); } // Either we did a decref, or the value was static. v << stubret{live, true}; }); }
static int restoreProc( const SubCmd::Args &args ) { if ( args.size() != 3 ) { printf( "gitfs restore tag dest\n" ); return 1; } path_init( args[1] ); boost::spirit::classic::file_iterator<char> fi( args[1] ); if ( !fi ) std::cout << "error" << std::endl; else { std::auto_ptr<GitbkFs> rfp( fromItem( &*fi, args[2] ) ); RunMt( rfp.get( ) ); } return 0; }
Function simpleIRK(Function f, int N, int order, const std::string& scheme, const std::string& solver, const Dict& solver_options) { // Consistency check casadi_assert_message(N>=1, "Parameter N (number of steps) must be at least 1, but got " << N << "."); casadi_assert_message(f.n_in()==2, "Function must have two inputs: x and p"); casadi_assert_message(f.n_out()==1, "Function must have one outputs: dot(x)"); // Obtain collocation points std::vector<double> tau_root = collocation_points(order, scheme); tau_root.insert(tau_root.begin(), 0); // Retrieve collocation interpolating matrices std::vector < std::vector <double> > C; std::vector < double > D; collocationInterpolators(tau_root, C, D); // Inputs of constructed function MX x0 = MX::sym("x0", f.sparsity_in(0)); MX p = MX::sym("p", f.sparsity_in(1)); MX h = MX::sym("h"); // Time step MX dt = h/N; // Implicitly defined variables MX v = MX::sym("v", repmat(x0.sparsity(), order)); std::vector<MX> x = vertsplit(v, x0.size1()); x.insert(x.begin(), x0); // Collect the equations that implicitly define v std::vector<MX> V_eq, f_in(2), f_out; for (int j=1; j<order+1; ++j) { // Expression for the state derivative at the collocation point MX xp_j = 0; for (int r=0; r<=order; ++r) xp_j+= C[j][r]*x[r]; // Collocation equations f_in[0] = x[j]; f_in[1] = p; f_out = f(f_in); V_eq.push_back(dt*f_out.at(0)-xp_j); } // Root-finding function Function rfp("rfp", {v, x0, p, h}, {vertcat(V_eq)}); // Create a implicit function instance to solve the system of equations Function ifcn = rootfinder("ifcn", solver, rfp, solver_options); // Get state at end time MX xf = x0; for (int k=0; k<N; ++k) { std::vector<MX> ifcn_out = ifcn({repmat(xf, order), xf, p, h}); x = vertsplit(ifcn_out[0], x0.size1()); // State at end of step xf = D[0]*x0; for (int i=1; i<=order; ++i) { xf += D[i]*x[i-1]; } } // Form discrete-time dynamics return Function("F", {x0, p, h}, {xf}, {"x0", "p", "h"}, {"xf"}); }
TCA emitFreeLocalsHelpers(CodeBlock& cb, DataBlock& data, UniqueStubs& us) { // The address of the first local is passed in the second argument register. // We use the third and fourth as scratch registers. auto const local = rarg(1); auto const last = rarg(2); auto const type = rarg(3); CGMeta fixups; TCA freeLocalsHelpers[kNumFreeLocalsHelpers]; TCA freeManyLocalsHelper; // This stub is very hot; keep it cache-aligned. align(cb, &fixups, Alignment::CacheLine, AlignContext::Dead); auto const release = emitDecRefHelper(cb, data, fixups, local, type, local | last); auto const decref_local = [&] (Vout& v) { auto const sf = v.makeReg(); // We can't use emitLoadTVType() here because it does a byte load, and we // need to sign-extend since we use `type' as a 32-bit array index to the // destructor table. v << loadzbl{local[TVOFF(m_type)], type}; emitCmpTVType(v, sf, KindOfRefCountThreshold, type); ifThen(v, CC_G, sf, [&] (Vout& v) { v << call{release, arg_regs(3)}; }); }; auto const next_local = [&] (Vout& v) { v << addqi{static_cast<int>(sizeof(TypedValue)), local, local, v.makeReg()}; }; alignJmpTarget(cb); freeManyLocalsHelper = vwrap(cb, data, [&] (Vout& v) { // We always unroll the final `kNumFreeLocalsHelpers' decrefs, so only loop // until we hit that point. v << lea{rvmfp()[localOffset(kNumFreeLocalsHelpers - 1)], last}; // Set up frame linkage to avoid an indirect fixup. v << copy{rsp(), rfp()}; doWhile(v, CC_NZ, {}, [&] (const VregList& in, const VregList& out) { auto const sf = v.makeReg(); decref_local(v); next_local(v); v << cmpq{local, last, sf}; return sf; } ); }); for (auto i = kNumFreeLocalsHelpers - 1; i >= 0; --i) { freeLocalsHelpers[i] = vwrap(cb, data, [&] (Vout& v) { decref_local(v); if (i != 0) next_local(v); }); } // All the stub entrypoints share the same ret. vwrap(cb, data, fixups, [] (Vout& v) { v << popp{rfp(), rlr()}; v << ret{}; }); // Create a table of branches us.freeManyLocalsHelper = vwrap(cb, data, [&] (Vout& v) { v << pushp{rlr(), rfp()}; // rvmfp() is needed by the freeManyLocalsHelper stub above, so frame // linkage setup is deferred until after its use in freeManyLocalsHelper. v << jmpi{freeManyLocalsHelper}; }); for (auto i = kNumFreeLocalsHelpers - 1; i >= 0; --i) { us.freeLocalsHelpers[i] = vwrap(cb, data, [&] (Vout& v) { // We set up frame linkage to avoid an indirect fixup. v << pushp{rlr(), rfp()}; v << copy{rsp(), rfp()}; v << jmpi{freeLocalsHelpers[i]}; }); } // FIXME: This stub is hot, so make sure to keep it small. #if 0 always_assert(Stats::enabled() || (cb.frontier() - release <= 4 * x64::cache_line_size())); #endif fixups.process(nullptr); return release; }
Protein* PeptideBuilder::construct() { if (fragment_db_ == 0) { Log.warn() << "PeptideBuilder::construct(): no FragmengDB given!" << std::endl; return 0; } if (sequence_.empty()) { Log.warn() << "PeptideBuilder::construct(): no amino acid sequence specified." << std::endl; return 0; } int id = 1; Protein *protein = new Protein(proteinname_); Chain *chain = new Chain(chainname_); // create the first residue Residue* residue = createResidue_(sequence_[0].getType(), id); chain->insert(*residue); Residue* residueold = residue; std::vector<AminoAcidDescriptor>::iterator i = sequence_.begin(); ++id; // consistency check for empty sequences and sequences of length < 2!! // loop for the remaining residues ; for (++i; i != sequence_.end(); ++i) { // We have to take care of two special cases: // - the residue we are looking at is proline // - the last residue was proline String type = (i-1)->getType(); type.toUpper(); // special case: residue is a proline type = i->getType(); type.toUpper(); is_proline_ = (type == "PRO") ? true : false; Residue* residue2 = createResidue_(i->getType(), id); insert_(*residue2, *residueold); chain->insert(*residue2); // set the torsion angle transform_(i->getPhi(), (i-1)->getPsi(),*residueold, *residue2); peptide_(*residueold,*residue2); // set the peptide bond angle omega setOmega_(*residueold, *residue2, i->getOmega()); residueold=residue2; ++id; } protein->insert(*chain); // read the names for a unique nomenclature protein->apply(fragment_db_->normalize_names); // add missing bonds and atoms (including side chains!) ReconstructFragmentProcessor rfp(*fragment_db_); protein->apply(rfp); protein->apply(fragment_db_->build_bonds); return protein; }