chore: Include tests and examples in release builds (#872)

Lets build these for release builds. In release builds there is some
optimization added that might help with running tests and seeing
performance numbers. The asserts are removed in release builds so a new
macro was added to check for return status' of the API calls.

Introduced new macro to validate API return statuses (since assert is disabled in release builds).
Added Meson options to toggle building of tests and examples.
Fixed numerous issues with tests and examples to ensure compatibility with release builds.

Signed-off-by: Adit Ranadive <[email protected]>

Author: aranadive

examples/cpp/meson.build

@@ -15,15 +15,15 @@
 
 nixl_example = executable('nixl_example',
         'nixl_example.cpp',
-        dependencies: [nixl_dep, nixl_infra, nixl_common_deps],
+        dependencies: [nixl_dep, nixl_infra, nixl_common_deps, nixl_test_utils_dep],
         include_directories: [nixl_inc_dirs, utils_inc_dirs],
         link_with: [serdes_lib],
         install: true)
 
 if etcd_dep.found()
     etcd_example = executable('nixl_etcd_example',
                'nixl_etcd_example.cpp',
-               dependencies: [nixl_dep, nixl_infra, nixl_common_deps],
+               dependencies: [nixl_dep, nixl_infra, nixl_common_deps, nixl_test_utils_dep],
                include_directories: [nixl_inc_dirs, utils_inc_dirs],
                link_with: [serdes_lib],
                install: true)

examples/cpp/nixl_etcd_example.cpp

@@ -15,12 +15,13 @@
  * limitations under the License.
  */
 #include <iostream>
-#include <cassert>
 #include <thread>
 #include <chrono>
 #include <cstring>
 
 #include "nixl.h"
+#include "test_utils.h"
+
 
 // Change these values to match your etcd setup
 const std::string ETCD_ENDPOINT = "http://localhost:2379";
@@ -130,7 +131,7 @@ int main() {
     std::vector<nixl_backend_t> plugins;
 
     ret1 = A1.getAvailPlugins(plugins);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get available plugins", AGENT1_NAME);
 
     std::cout << "Available plugins:\n";
 
@@ -140,8 +141,8 @@ int main() {
     ret1 = A1.getPluginParams("UCX", mems1, init1);
     ret2 = A2.getPluginParams("UCX", mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get plugin params for UCX", AGENT1_NAME);
+    nixl_exit_on_failure(ret2, "Failed to get plugin params for UCX", AGENT2_NAME);
 
     std::cout << "Params before init:\n";
     printParams(init1, mems1);
@@ -151,25 +152,25 @@ int main() {
     nixlBackendH* ucx1, *ucx2;
     ret1 = A1.createBackend("UCX", init1, ucx1);
     ret2 = A2.createBackend("UCX", init2, ucx2);
-
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to create UCX backend", AGENT1_NAME);
+    nixl_exit_on_failure(ret2, "Failed to create UCX backend", AGENT2_NAME);
 
     ret1 = A1.getBackendParams(ucx1, mems1, init1);
     ret2 = A2.getBackendParams(ucx2, mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get UCX backend params", AGENT1_NAME);
+    nixl_exit_on_failure(ret2, "Failed to get UCX backend params", AGENT2_NAME);
+
 
     std::cout << "Params after init:\n";
     printParams(init1, mems1);
     printParams(init2, mems2);
 
     // Register memory with both agents
     status = registerMemory(&addr1, &A1, &dlist1, &extra_params1, ucx1, 0xaa);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to register memory", AGENT1_NAME);
     status = registerMemory(&addr2, &A2, &dlist2, &extra_params2, ucx2, 0xbb);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to register memory", AGENT2_NAME);
 
     std::cout << "\nEtcd Metadata Exchange Demo\n";
     std::cout << "==========================\n";
@@ -179,10 +180,10 @@ int main() {
 
     // Both agents send their metadata to etcd
     status = A1.sendLocalMD();
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local MD", AGENT1_NAME);
 
     status = A2.sendLocalMD();
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local MD", AGENT2_NAME);
 
     // Give etcd time to process
     std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -192,11 +193,11 @@ int main() {
 
     // Agent1 fetches metadata for Agent2
     status = A1.fetchRemoteMD(AGENT2_NAME);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to fetch remote MD", AGENT1_NAME);
 
     // Agent2 fetches metadata for Agent1
     status = A2.fetchRemoteMD(AGENT1_NAME);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to fetch remote MD", AGENT2_NAME);
 
     // Do transfer from Agent 1 to Agent 2
     size_t req_size = 8;
@@ -229,8 +230,10 @@ int main() {
     extra_params1.hasNotif = true;
     ret1 = A1.createXferReq(NIXL_WRITE, req_src_descs, req_dst_descs, AGENT2_NAME, req_handle, &extra_params1);
     std::cout << "Xfer request created, status: " << nixlEnumStrings::statusStr(ret1) << std::endl;
+    nixl_exit_on_failure(ret1, "Failed to create Xfer Req", AGENT1_NAME);
 
     status = A1.postXferReq(req_handle);
+    nixl_exit_on_failure((status >= NIXL_SUCCESS), "Failed to post Xfer Req", AGENT1_NAME);
 
     std::cout << "Transfer was posted\n";
 
@@ -240,20 +243,20 @@ int main() {
     while (status != NIXL_SUCCESS || n_notifs == 0) {
         if (status != NIXL_SUCCESS) status = A1.getXferStatus(req_handle);
         if (n_notifs == 0) ret2 = A2.getNotifs(notif_map);
-        assert (status >= 0);
-        assert (ret2 == NIXL_SUCCESS);
+        nixl_exit_on_failure((status >= NIXL_SUCCESS), "Failed to get Xfer status", AGENT1_NAME);
+        nixl_exit_on_failure(ret2, "Failed to get notifs", AGENT2_NAME);
         n_notifs = notif_map.size();
     }
 
     std::cout << "Transfer verified\n";
 
     ret1 = A1.releaseXferReq(req_handle);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to release Xfer Req", AGENT1_NAME);
 
     ret1 = A1.deregisterMem(dlist1, &extra_params1);
     ret2 = A2.deregisterMem(dlist2, &extra_params2);
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to deregister memory", AGENT1_NAME);
+    nixl_exit_on_failure(ret2, "Failed to deregister memory", AGENT2_NAME);
 
     // 3. Partial Metadata Exchange
     std::cout << "\n3. Sending partial metadata to etcd...\n";
@@ -274,36 +277,36 @@ int main() {
 
     // Send partial metadata
     status = A1.sendLocalPartialMD(empty_dlist1, &conn_params1);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local partial MD", AGENT1_NAME);
 
     status = A2.sendLocalPartialMD(empty_dlist2, &conn_params2);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local partial MD", AGENT2_NAME);
 
     // Send once partial with different label
     conn_params1.metadataLabel = PARTIAL_LABEL_2;
     status = A1.sendLocalPartialMD(empty_dlist1, &conn_params1);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local partial MD", AGENT1_NAME);
 
     conn_params2.metadataLabel = PARTIAL_LABEL_2;
     status = A2.sendLocalPartialMD(empty_dlist2, &conn_params2);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to send local partial MD", AGENT2_NAME);
 
     nixl_opt_args_t fetch_params;
     fetch_params.metadataLabel = PARTIAL_LABEL_1;
     status = A1.fetchRemoteMD(AGENT2_NAME, &fetch_params);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to fetch remote MD", AGENT1_NAME);
 
     status = A2.fetchRemoteMD(AGENT1_NAME, &fetch_params);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to fetch remote MD", AGENT2_NAME);
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
 
     // 4. Invalidate Metadata
     std::cout << "\n4. Invalidating metadata in etcd...\n";
 
-    // Invalidate agent1's metadata
+    // Invalidate AGENT1_NAME's metadata
     status = A1.invalidateLocalMD();
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to invalidate local MD", AGENT1_NAME);
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
 
@@ -316,14 +319,14 @@ int main() {
     // Try invalidating again, this should log a debug message
     std::cout << "Trying to invalidate again...\n";
     status = A1.invalidateLocalMD();
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to invalidate local MD", AGENT1_NAME);
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
 
     // 5. Fetch metadata with invalid label. This should not block forever and print error message.
     std::cout << "\n5. Fetching metadata with invalid label...\n";
     status = A2.fetchRemoteMD("INVALID_AGENT", &fetch_params);
-    assert(status == NIXL_SUCCESS);
+    nixl_exit_on_failure(status, "Failed to fetch remote MD", AGENT2_NAME);
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
 

examples/cpp/nixl_example.cpp

@@ -21,6 +21,8 @@
 #include <sys/time.h>
 
 #include "nixl.h"
+#include "test_utils.h"
+
 
 std::string agent1("Agent001");
 std::string agent2("Agent002");
@@ -29,7 +31,7 @@ void check_buf(void* buf, size_t len) {
 
     // Do some checks on the data.
     for(size_t i = 0; i<len; i++){
-        assert (((uint8_t*) buf)[i] == 0xbb);
+        nixl_exit_on_failure((((uint8_t *)buf)[i] == 0xbb), "Data mismatch!", agent1);
     }
 }
 
@@ -89,7 +91,7 @@ main(int argc, char **argv) {
     std::vector<nixl_backend_t> plugins;
 
     ret1 = A1.getAvailPlugins(plugins);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get available plugins", agent1);
 
     std::cout << "Available plugins:\n";
 
@@ -100,8 +102,8 @@ main(int argc, char **argv) {
     ret1 = A1.getPluginParams(backend, mems1, init1);
     ret2 = A2.getPluginParams(backend, mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get plugin params", agent1);
+    nixl_exit_on_failure(ret2, "Failed to get plugin params", agent2);
 
     std::cout << "Params before init:\n";
     printParams(init1, mems1);
@@ -115,14 +117,14 @@ main(int argc, char **argv) {
     extra_params1.backends.push_back(bknd1);
     extra_params2.backends.push_back(bknd2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to create " + backend + " backend", agent1);
+    nixl_exit_on_failure(ret2, "Failed to create " + backend + " backend", agent2);
 
     ret1 = A1.getBackendParams(bknd1, mems1, init1);
     ret2 = A2.getBackendParams(bknd2, mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get " + backend + " backend params", agent1);
+    nixl_exit_on_failure(ret2, "Failed to get " + backend + " backend params", agent2);
 
     std::cout << "Params after init:\n";
     printParams(init1, mems1);
@@ -161,25 +163,22 @@ main(int argc, char **argv) {
 
     ret1 = A1.registerMem(dlist1, &extra_params1);
     ret2 = A2.registerMem(dlist2, &extra_params2);
-
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to register memory", agent1);
+    nixl_exit_on_failure(ret2, "Failed to register memory", agent2);
 
     std::string meta1;
     ret1 = A1.getLocalMD(meta1);
     std::string meta2;
     ret2 = A2.getLocalMD(meta2);
-
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to get local MD", agent1);
+    nixl_exit_on_failure(ret2, "Failed to get local MD", agent2);
 
     std::cout << "Agent1's Metadata: " << meta1 << "\n";
     std::cout << "Agent2's Metadata: " << meta2 << "\n";
 
     ret1 = A1.loadRemoteMD (meta2, ret_s1);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to load remote MD", agent1);
 
     size_t req_size = 8;
     size_t dst_offset = 8;
@@ -204,9 +203,10 @@ main(int argc, char **argv) {
     extra_params1.notifMsg = "notification";
     extra_params1.hasNotif = true;
     ret1 = A1.createXferReq(NIXL_WRITE, req_src_descs, req_dst_descs, agent2, req_handle, &extra_params1);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to create Xfer Req", agent1);
 
     nixl_status_t status = A1.postXferReq(req_handle);
+    nixl_exit_on_failure((status >= NIXL_SUCCESS), "Failed to post Xfer Req", agent1);
 
     std::cout << "Transfer was posted\n";
 
@@ -216,31 +216,33 @@ main(int argc, char **argv) {
     while (status != NIXL_SUCCESS || n_notifs == 0) {
         if (status != NIXL_SUCCESS) status = A1.getXferStatus(req_handle);
         if (n_notifs == 0) ret2 = A2.getNotifs(notif_map);
-        assert (status >= 0);
-        assert (ret2 == NIXL_SUCCESS);
+        nixl_exit_on_failure((status >= NIXL_SUCCESS), "Failed to post Xfer Req", agent1);
+        nixl_exit_on_failure(ret2, "Failed to get notifs", agent2);
         n_notifs = notif_map.size();
     }
 
     std::vector<std::string> agent1_notifs = notif_map[agent1];
-    assert (agent1_notifs.size() == 1);
-    assert (agent1_notifs.front() == "notification");
+    nixl_exit_on_failure((agent1_notifs.size() == 1), "Incorrect notif size", agent1);
+    nixl_exit_on_failure(
+        (agent1_notifs.front() == "notification"), "Incorrect notification", agent1);
+
     notif_map[agent1].clear(); // Redundant, for testing
     notif_map.clear();
     n_notifs = 0;
 
     std::cout << "Transfer verified\n";
 
     ret1 = A1.releaseXferReq(req_handle);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to release Xfer Req", agent1);
 
     ret1 = A1.deregisterMem(dlist1, &extra_params1);
     ret2 = A2.deregisterMem(dlist2, &extra_params2);
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to deregister memory", agent1);
+    nixl_exit_on_failure(ret2, "Failed to deregister memory", agent2);
 
     //only initiator should call invalidate
     ret1 = A1.invalidateRemoteMD(agent2);
-    assert (ret1 == NIXL_SUCCESS);
+    nixl_exit_on_failure(ret1, "Failed to invalidate remote MD", agent1);
 
     free(addr1);
     free(addr2);

meson.build

@@ -251,10 +251,11 @@ plugins_inc_dirs = include_directories('src/plugins')
 utils_inc_dirs = include_directories('src/utils')
 
 subdir('src')
-
-if get_option('buildtype') != 'release'
-  subdir('test')
-  subdir('examples')
+if get_option('build_tests')
+    subdir('test')
+endif
+if get_option('build_examples')
+    subdir('examples')
 endif
 
 if get_option('install_headers')

meson_options.txt

@@ -30,4 +30,6 @@ option('log_level', type: 'combo', choices: ['trace', 'debug', 'info', 'warning'
 option('rust', type: 'boolean', value: false, description: 'Build Rust bindings')
 
 # Tests
+option('build_tests', type: 'boolean', value: true, description: 'Build all tests')
+option('build_examples', type: 'boolean', value: true, description: 'Build all examples')
 option('test_all_plugins', type: 'boolean', value: false, description: 'Testing all plugins in addition to the mocks..')

src/infra/meson.build

@@ -21,3 +21,6 @@ nixl_build_lib = library('nixl_build',
                         install: true)
 
 nixl_infra = declare_dependency(link_with: nixl_build_lib)
+
+# Test utilities library that can depend on nixl_dep (created after nixl_dep is defined)
+# This will be defined in a separate meson file to avoid circular dependencies