32#include <capnp/ez-rpc.h>
33#include <capnp/rpc-twoparty.h>
34#include <kj/async-io.h>
41#include "rgpot/rpc/Potentials.capnp.h"
43#ifndef EON_BUILD_VERSION
44#define EON_BUILD_VERSION ""
46#ifndef EON_BUILD_REVISION
47#define EON_BUILD_REVISION ""
62void fillServerCapabilities(::Capabilities::Builder caps) {
75 caps.setAvailable(
true);
78 auto ops = caps.initOperations(2);
79 ops.set(0, ::Capabilities::Operation::ENERGY);
80 ops.set(1, ::Capabilities::Operation::FORCES);
84 return [](long,
const double *,
const int *,
double *,
double *,
88RpcCapabilitiesView readOne(kj::AsyncIoContext &io,
89 capnp::Capability::Client bootstrap) {
90 auto pipe = io.provider->newTwoWayPipe();
91 capnp::TwoPartyClient serverSide(*pipe.ends[0], kj::mv(bootstrap),
92 capnp::rpc::twoparty::Side::SERVER);
93 capnp::TwoPartyClient clientSide(*pipe.ends[1]);
94 auto pot = clientSide.bootstrap().castAs<Potential>();
95 auto response = pot.getCapabilitiesRequest().send().wait(io.waitScope);
96 auto caps = response.getCapabilities();
98 RpcCapabilitiesView view;
99 view.protocolFamily = caps.getProtocolFamily().cStr();
100 view.protocolMajor = caps.getProtocolMajor();
101 view.protocolMinor = caps.getProtocolMinor();
102 view.schemaId = caps.getSchemaId().cStr();
103 view.bridgeAbiMajor = caps.getBridgeAbiMajor();
104 view.bridgeAbiMinor = caps.getBridgeAbiMinor();
105 view.bridgeLayout = caps.getBridgeLayout();
106 view.dlpackMajor = caps.getDlpackMajor();
107 view.dlpackMinor = caps.getDlpackMinor();
108 view.bridgeFeatures = caps.getBridgeFeatures();
109 view.backendName = caps.getBackendName().cStr();
110 view.available = caps.getAvailable();
111 view.buildVersion = caps.getBuildVersion().cStr();
112 view.buildRevision = caps.getBuildRevision().cStr();
113 for (
auto op : caps.getOperations()) {
114 if (op == ::Capabilities::Operation::ENERGY) {
115 view.servesEnergy =
true;
117 if (op == ::Capabilities::Operation::FORCES) {
118 view.servesForces =
true;
135class CallbackPotImpl final :
public Potential::Server {
138 : m_callback(std::move(cb)) {}
140 kj::Promise<void> getCapabilities(GetCapabilitiesContext context)
override {
141 fillServerCapabilities(context.getResults().initCapabilities());
142 return kj::READY_NOW;
145 kj::Promise<void> calculate(CalculateContext context)
override {
146 auto fip = context.getParams().getFip();
147 const size_t numAtoms = fip.getPos().size() / 3;
149 KJ_REQUIRE(fip.getAtmnrs().size() == numAtoms,
"AtomNumbers size mismatch");
152 std::vector<double> positions(numAtoms * 3);
153 auto capnpPos = fip.getPos();
154 for (
size_t i = 0; i < numAtoms * 3; ++i) {
155 positions[i] = capnpPos[i];
158 std::vector<int> atomicNrs(numAtoms);
159 auto capnpAtmnrs = fip.getAtmnrs();
160 for (
size_t i = 0; i < numAtoms; ++i) {
161 atomicNrs[i] = capnpAtmnrs[i];
165 auto capnpBox = fip.getBox();
166 for (
size_t i = 0; i < 9 && i < capnpBox.size(); ++i) {
167 box[i] = capnpBox[i];
171 std::vector<double> forces(numAtoms * 3, 0.0);
173 m_callback(
static_cast<long>(numAtoms), positions.data(), atomicNrs.data(),
174 forces.data(), &energy, box);
177 auto result = context.getResults();
178 auto pres = result.initResult();
179 pres.setEnergy(energy);
181 auto forcesList = pres.initForces(numAtoms * 3);
182 for (
size_t i = 0; i < numAtoms * 3; ++i) {
183 forcesList.set(i, forces[i]);
186 return kj::READY_NOW;
197 EONC_LOG_INFO(
"Starting Cap'n Proto RPC server on {}:{}", host, port);
199 capnp::EzRpcServer server(kj::heap<CallbackPotImpl>(std::move(callback)),
202 auto &waitScope = server.getWaitScope();
203 EONC_LOG_INFO(
"Server ready on port {}. Ctrl+C to stop.", port);
204 kj::NEVER_DONE.wait(waitScope);
217class PooledCallbackPotImpl final :
public Potential::Server {
219 explicit PooledCallbackPotImpl(std::vector<ForceCallback> pool)
220 : m_pool(std::move(pool)),
221 m_mutexes(m_pool.size()),
224 kj::Promise<void> getCapabilities(GetCapabilitiesContext context)
override {
225 fillServerCapabilities(context.getResults().initCapabilities());
226 return kj::READY_NOW;
229 kj::Promise<void> calculate(CalculateContext context)
override {
230 size_t idx = m_next.fetch_add(1, std::memory_order_relaxed) % m_pool.size();
232 auto fip = context.getParams().getFip();
233 const size_t numAtoms = fip.getPos().size() / 3;
235 KJ_REQUIRE(fip.getAtmnrs().size() == numAtoms,
"AtomNumbers size mismatch");
237 std::vector<double> positions(numAtoms * 3);
238 auto capnpPos = fip.getPos();
239 for (
size_t i = 0; i < numAtoms * 3; ++i) {
240 positions[i] = capnpPos[i];
243 std::vector<int> atomicNrs(numAtoms);
244 auto capnpAtmnrs = fip.getAtmnrs();
245 for (
size_t i = 0; i < numAtoms; ++i) {
246 atomicNrs[i] = capnpAtmnrs[i];
250 auto capnpBox = fip.getBox();
251 for (
size_t i = 0; i < 9 && i < capnpBox.size(); ++i) {
252 box[i] = capnpBox[i];
255 std::vector<double> forces(numAtoms * 3, 0.0);
258 std::lock_guard<std::mutex> lock(m_mutexes[idx]);
259 m_pool[idx](
static_cast<long>(numAtoms), positions.data(), atomicNrs.data(),
260 forces.data(), &energy, box);
262 auto result = context.getResults();
263 auto pres = result.initResult();
264 pres.setEnergy(energy);
266 auto forcesList = pres.initForces(numAtoms * 3);
267 for (
size_t i = 0; i < numAtoms * 3; ++i) {
268 forcesList.set(i, forces[i]);
271 return kj::READY_NOW;
275 std::vector<ForceCallback> m_pool;
276 std::vector<std::mutex> m_mutexes;
277 std::atomic<size_t> m_next;
283 const std::string &host, uint16_t port) {
284 EONC_LOG_INFO(
"Starting pooled RPC gateway on {}:{} with {} instances", host,
287 capnp::EzRpcServer server(kj::heap<PooledCallbackPotImpl>(std::move(pool)),
290 auto &waitScope = server.getWaitScope();
291 EONC_LOG_INFO(
"Gateway ready on port {}. Ctrl+C to stop.", port);
292 kj::NEVER_DONE.wait(waitScope);
296 auto io = kj::setupAsyncIo();
298 out.
callbackServer = readOne(
io, kj::heap<CallbackPotImpl>(noopCallback()));
299 std::vector<ForceCallback> pool;
300 pool.push_back(noopCallback());
302 readOne(
io, kj::heap<PooledCallbackPotImpl>(std::move(pool)));
#define EONC_LOG_INFO(...)
#define EON_BUILD_VERSION
#define EON_BUILD_REVISION
constexpr std::uint64_t kBridgeFeatures
This server does not advertise eindir bridge feature bits.
constexpr std::uint16_t kBridgeAbiMinor
constexpr std::uint16_t kBridgeAbiMajor
constexpr std::uint16_t kProtocolMinor
constexpr const char * kBackendName
constexpr const char * kSchemaId
constexpr std::uint16_t kProtocolMajor
constexpr std::uint32_t kBridgeLayout
constexpr std::uint16_t kDlpackMajor
constexpr const char * kProtocolFamily
Handshake values that Potential.getCapabilities reports.
constexpr std::uint16_t kDlpackMinor
RAII resource manager for the ARTn C library with global synchronization.
RpcServerCapabilitiesPair readRpcServerCapabilities()
Call getCapabilities on both server classes through an in-process RPC.
std::function< void(long nAtoms, const double *positions, const int *atomicNrs, double *forces, double *energy, const double *box)> ForceCallback
Callback type for potential energy/force evaluation.
void startPooledRpcServer(std::vector< ForceCallback > pool, const std::string &host, uint16_t port)
Start a blocking Cap'n Proto RPC server backed by a pool of force callbacks dispatched round-robin.
void startRpcServer(ForceCallback callback, const std::string &host, uint16_t port)
Start a blocking Cap'n Proto RPC server using a force callback.
RpcCapabilitiesView pooledServer
RpcCapabilitiesView callbackServer