Loading...
Searching...
No Matches
ServeRpcServer.cpp
Go to the documentation of this file.
1/*
2** This file is part of eOn.
3**
4** SPDX-License-Identifier: BSD-3-Clause
5**
6** Copyright (c) 2010--present, eOn Development Team
7** All rights reserved.
8**
9** Repo:
10** https://github.com/TheochemUI/eOn
11*/
12
24
25#include "eon/ServeRpcServer.h"
27#include "RpcServerHandshake.h"
28#include "eon/BaseStructures.h"
29#include "eon/EonLogger.h"
30
31#include <atomic>
32#include <capnp/ez-rpc.h>
33#include <capnp/rpc-twoparty.h>
34#include <kj/async-io.h>
35#include <kj/debug.h>
36#include <mutex>
37
38// Cap'n Proto generated header (from Potentials.capnp).
39// This defines `class Potential` -- which collides with eOn's Potential class,
40// hence the separate translation unit.
41#include "rgpot/rpc/Potentials.capnp.h"
42
43#ifndef EON_BUILD_VERSION
44#define EON_BUILD_VERSION ""
45#endif
46#ifndef EON_BUILD_REVISION
47#define EON_BUILD_REVISION ""
48#endif
49
50namespace eonc {
51
52namespace {
53
62void fillServerCapabilities(::Capabilities::Builder caps) {
63 caps.setProtocolFamily(eonc::rpc::kProtocolFamily);
64 caps.setProtocolMajor(eonc::rpc::kProtocolMajor);
65 caps.setProtocolMinor(eonc::rpc::kProtocolMinor);
66 caps.setSchemaId(eonc::rpc::kSchemaId);
67 caps.setBridgeAbiMajor(eonc::rpc::kBridgeAbiMajor);
68 caps.setBridgeAbiMinor(eonc::rpc::kBridgeAbiMinor);
69 caps.setBridgeLayout(eonc::rpc::kBridgeLayout);
70 caps.setDlpackMajor(eonc::rpc::kDlpackMajor);
71 caps.setDlpackMinor(eonc::rpc::kDlpackMinor);
72 caps.setBridgeFeatures(eonc::rpc::kBridgeFeatures);
73 caps.setBackendName(eonc::rpc::kBackendName);
74 caps.setBackendVersion(EON_BUILD_VERSION);
75 caps.setAvailable(true);
76 caps.setBuildVersion(EON_BUILD_VERSION);
77 caps.setBuildRevision(EON_BUILD_REVISION);
78 auto ops = caps.initOperations(2);
79 ops.set(0, ::Capabilities::Operation::ENERGY);
80 ops.set(1, ::Capabilities::Operation::FORCES);
81}
82
83ForceCallback noopCallback() {
84 return [](long, const double *, const int *, double *, double *,
85 const double *) {};
86}
87
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();
97
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;
116 }
117 if (op == ::Capabilities::Operation::FORCES) {
118 view.servesForces = true;
119 }
120 }
121 return view;
122}
123
124} // namespace
125
126namespace {
127
135class CallbackPotImpl final : public Potential::Server {
136public:
137 explicit CallbackPotImpl(ForceCallback cb)
138 : m_callback(std::move(cb)) {}
139
140 kj::Promise<void> getCapabilities(GetCapabilitiesContext context) override {
141 fillServerCapabilities(context.getResults().initCapabilities());
142 return kj::READY_NOW;
143 }
144
145 kj::Promise<void> calculate(CalculateContext context) override {
146 auto fip = context.getParams().getFip();
147 const size_t numAtoms = fip.getPos().size() / 3;
148
149 KJ_REQUIRE(fip.getAtmnrs().size() == numAtoms, "AtomNumbers size mismatch");
150
151 // Extract flat arrays from capnp
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];
156 }
157
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];
162 }
163
164 double box[9] = {};
165 auto capnpBox = fip.getBox();
166 for (size_t i = 0; i < 9 && i < capnpBox.size(); ++i) {
167 box[i] = capnpBox[i];
168 }
169
170 // Call the force callback
171 std::vector<double> forces(numAtoms * 3, 0.0);
172 double energy = 0.0;
173 m_callback(static_cast<long>(numAtoms), positions.data(), atomicNrs.data(),
174 forces.data(), &energy, box);
175
176 // Serialize result back to capnp
177 auto result = context.getResults();
178 auto pres = result.initResult();
179 pres.setEnergy(energy);
180
181 auto forcesList = pres.initForces(numAtoms * 3);
182 for (size_t i = 0; i < numAtoms * 3; ++i) {
183 forcesList.set(i, forces[i]);
184 }
185
186 return kj::READY_NOW;
187 }
188
189private:
190 ForceCallback m_callback;
191};
192
193} // anonymous namespace
194
195void startRpcServer(ForceCallback callback, const std::string &host,
196 uint16_t port) {
197 EONC_LOG_INFO("Starting Cap'n Proto RPC server on {}:{}", host, port);
198
199 capnp::EzRpcServer server(kj::heap<CallbackPotImpl>(std::move(callback)),
200 host, port);
201
202 auto &waitScope = server.getWaitScope();
203 EONC_LOG_INFO("Server ready on port {}. Ctrl+C to stop.", port);
204 kj::NEVER_DONE.wait(waitScope);
205}
206
207// ---------------------------------------------------------------------------
208// Pooled (round-robin gateway) server
209// ---------------------------------------------------------------------------
210
211namespace {
212
217class PooledCallbackPotImpl final : public Potential::Server {
218public:
219 explicit PooledCallbackPotImpl(std::vector<ForceCallback> pool)
220 : m_pool(std::move(pool)),
221 m_mutexes(m_pool.size()),
222 m_next(0) {}
223
224 kj::Promise<void> getCapabilities(GetCapabilitiesContext context) override {
225 fillServerCapabilities(context.getResults().initCapabilities());
226 return kj::READY_NOW;
227 }
228
229 kj::Promise<void> calculate(CalculateContext context) override {
230 size_t idx = m_next.fetch_add(1, std::memory_order_relaxed) % m_pool.size();
231
232 auto fip = context.getParams().getFip();
233 const size_t numAtoms = fip.getPos().size() / 3;
234
235 KJ_REQUIRE(fip.getAtmnrs().size() == numAtoms, "AtomNumbers size mismatch");
236
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];
241 }
242
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];
247 }
248
249 double box[9] = {};
250 auto capnpBox = fip.getBox();
251 for (size_t i = 0; i < 9 && i < capnpBox.size(); ++i) {
252 box[i] = capnpBox[i];
253 }
254
255 std::vector<double> forces(numAtoms * 3, 0.0);
256 double energy = 0.0;
257
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);
261
262 auto result = context.getResults();
263 auto pres = result.initResult();
264 pres.setEnergy(energy);
265
266 auto forcesList = pres.initForces(numAtoms * 3);
267 for (size_t i = 0; i < numAtoms * 3; ++i) {
268 forcesList.set(i, forces[i]);
269 }
270
271 return kj::READY_NOW;
272 }
273
274private:
275 std::vector<ForceCallback> m_pool;
276 std::vector<std::mutex> m_mutexes;
277 std::atomic<size_t> m_next;
278};
279
280} // anonymous namespace
281
282void startPooledRpcServer(std::vector<ForceCallback> pool,
283 const std::string &host, uint16_t port) {
284 EONC_LOG_INFO("Starting pooled RPC gateway on {}:{} with {} instances", host,
285 port, pool.size());
286
287 capnp::EzRpcServer server(kj::heap<PooledCallbackPotImpl>(std::move(pool)),
288 host, port);
289
290 auto &waitScope = server.getWaitScope();
291 EONC_LOG_INFO("Gateway ready on port {}. Ctrl+C to stop.", port);
292 kj::NEVER_DONE.wait(waitScope);
293}
294
296 auto io = kj::setupAsyncIo();
298 out.callbackServer = readOne(io, kj::heap<CallbackPotImpl>(noopCallback()));
299 std::vector<ForceCallback> pool;
300 pool.push_back(noopCallback());
301 out.pooledServer =
302 readOne(io, kj::heap<PooledCallbackPotImpl>(std::move(pool)));
303 return out;
304}
305
306} // namespace eonc
#define EONC_LOG_INFO(...)
Definition EonLogger.h:316
#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.