clang-format: Add .clang-format

Add and apply .clang-format to all *.cpp and *.h files.

Signed-off-by: Eylon Toledano <[email protected]>

Author: etoledano

.clang-format

@@ -0,0 +1,42 @@
+---
+BasedOnStyle: Google
+
+IndentWidth: 4
+ColumnLimit: 100
+ContinuationIndentWidth: 8
+UseTab: Never
+MaxEmptyLinesToKeep: 2
+
+SortIncludes: true
+CompactNamespaces: false
+ReflowComments: true
+
+DerivePointerAlignment: false
+PointerAlignment: Left
+
+AllowShortIfStatementsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Inline
+
+AccessModifierOffset: -4
+
+AllowShortBlocksOnASingleLine: true
+ReferenceAlignment: Right
+AlignConsecutiveDeclarations: Consecutive
+AlwaysBreakAfterReturnType: None
+AlignAfterOpenBracket: Align
+BreakBeforeBraces: Linux
+BraceWrapping:
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: false
+  AfterUnion: false
+  BeforeCatch: true
+
+BinPackArguments: true
+BinPackParameters: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+
+IndentCaseLabels: true

examples/cpp/nixl_example.cpp

@@ -14,42 +14,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <iostream>
-#include <cassert>
-
 #include <sys/time.h>
 
+#include <cassert>
+#include <iostream>
+
 #include "nixl.h"
 #include "ucx_backend.h"
 
 std::string agent1("Agent001");
 std::string agent2("Agent002");
 
-void check_buf(void* buf, size_t len) {
-
+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);
-    }
+    for (size_t i = 0; i < len; i++) { assert(((uint8_t*)buf)[i] == 0xbb); }
 }
 
-bool equal_buf (void* buf1, void* buf2, size_t len) {
-
+bool equal_buf(void* buf1, void* buf2, size_t len)
+{
     // Do some checks on the data.
-    for (size_t i = 0; i<len; i++)
-        if (((uint8_t*) buf1)[i] != ((uint8_t*) buf2)[i])
-            return false;
+    for (size_t i = 0; i < len; i++)
+        if (((uint8_t*)buf1)[i] != ((uint8_t*)buf2)[i]) return false;
     return true;
 }
 
-void printParams(const nixl_b_params_t& params, const nixl_mem_list_t& mems) {
+void printParams(const nixl_b_params_t &params, const nixl_mem_list_t &mems)
+{
     if (params.empty()) {
         std::cout << "Parameters: (empty)" << std::endl;
         return;
     }
 
     std::cout << "Parameters:" << std::endl;
-    for (const auto& pair : params) {
+    for (const auto &pair : params) {
         std::cout << "  " << pair.first << " = " << pair.second << std::endl;
     }
 
@@ -59,15 +57,15 @@ void printParams(const nixl_b_params_t& params, const nixl_mem_list_t& mems) {
     }
 
     std::cout << "Mems:" << std::endl;
-    for (const auto& elm : mems) {
+    for (const auto &elm : mems) {
         std::cout << "  " << nixlEnumStrings::memTypeStr(elm) << std::endl;
     }
 }
 
 int main()
 {
     nixl_status_t ret1, ret2;
-    std::string ret_s1, ret_s2;
+    std::string   ret_s1, ret_s2;
 
     // Example: assuming two agents running on the same machine,
     // with separate memory regions in DRAM
@@ -83,39 +81,38 @@ int main()
     std::vector<nixl_backend_t> plugins;
 
     ret1 = A1.getAvailPlugins(plugins);
-    assert (ret1 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
 
     std::cout << "Available plugins:\n";
 
-    for (nixl_backend_t b: plugins)
-        std::cout << b << "\n";
+    for (nixl_backend_t b : plugins) std::cout << b << "\n";
 
     ret1 = A1.getPluginParams("UCX", mems1, init1);
     ret2 = A2.getPluginParams("UCX", mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     std::cout << "Params before init:\n";
     printParams(init1, mems1);
     printParams(init2, mems2);
 
-    nixlBackendH* ucx1, *ucx2;
+    nixlBackendH *ucx1, *ucx2;
     ret1 = A1.createBackend("UCX", init1, ucx1);
     ret2 = A2.createBackend("UCX", init2, ucx2);
 
     nixl_opt_args_t extra_params1, extra_params2;
     extra_params1.backends.push_back(ucx1);
     extra_params2.backends.push_back(ucx2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     ret1 = A1.getBackendParams(ucx1, mems1, init1);
     ret2 = A2.getBackendParams(ucx2, mems2, init2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     std::cout << "Params after init:\n";
     printParams(init1, mems1);
@@ -130,22 +127,22 @@ int main()
 
     // User allocates memories, and passes the corresponding address
     // and length to register with the backend
-    nixlBlobDesc buff1, buff2, buff3;
+    nixlBlobDesc     buff1, buff2, buff3;
     nixl_reg_dlist_t dlist1(DRAM_SEG), dlist2(DRAM_SEG);
-    size_t len = 256;
-    void* addr1 = calloc(1, len);
-    void* addr2 = calloc(1, len);
+    size_t           len = 256;
+    void*            addr1 = calloc(1, len);
+    void*            addr2 = calloc(1, len);
 
     memset(addr1, 0xbb, len);
     memset(addr2, 0, len);
 
-    buff1.addr   = (uintptr_t) addr1;
-    buff1.len    = len;
+    buff1.addr = (uintptr_t)addr1;
+    buff1.len = len;
     buff1.devId = 0;
     dlist1.addDesc(buff1);
 
-    buff2.addr   = (uintptr_t) addr2;
-    buff2.len    = len;
+    buff2.addr = (uintptr_t)addr2;
+    buff2.len = len;
     buff2.devId = 0;
     dlist2.addDesc(buff2);
 
@@ -156,85 +153,86 @@ int main()
     ret1 = A1.registerMem(dlist1, &extra_params1);
     ret2 = A2.registerMem(dlist2, &extra_params2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     std::string meta1;
     ret1 = A1.getLocalMD(meta1);
     std::string meta2;
     ret2 = A2.getLocalMD(meta2);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     std::cout << "Agent1's Metadata: " << meta1 << "\n";
     std::cout << "Agent2's Metadata: " << meta2 << "\n";
 
-    ret1 = A1.loadRemoteMD (meta2, ret_s1);
+    ret1 = A1.loadRemoteMD(meta2, ret_s1);
 
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
     size_t req_size = 8;
     size_t dst_offset = 8;
 
-    nixl_xfer_dlist_t req_src_descs (DRAM_SEG);
-    nixlBasicDesc req_src;
-    req_src.addr     = (uintptr_t) (((char*) addr1) + 16); //random offset
-    req_src.len      = req_size;
-    req_src.devId   = 0;
+    nixl_xfer_dlist_t req_src_descs(DRAM_SEG);
+    nixlBasicDesc     req_src;
+    req_src.addr = (uintptr_t)(((char*)addr1) + 16);  // random offset
+    req_src.len = req_size;
+    req_src.devId = 0;
     req_src_descs.addDesc(req_src);
 
-    nixl_xfer_dlist_t req_dst_descs (DRAM_SEG);
-    nixlBasicDesc req_dst;
-    req_dst.addr   = (uintptr_t) ((char*) addr2) + dst_offset; //random offset
-    req_dst.len    = req_size;
+    nixl_xfer_dlist_t req_dst_descs(DRAM_SEG);
+    nixlBasicDesc     req_dst;
+    req_dst.addr = (uintptr_t)((char*)addr2) + dst_offset;  // random offset
+    req_dst.len = req_size;
     req_dst.devId = 0;
     req_dst_descs.addDesc(req_dst);
 
     std::cout << "Transfer request from " << addr1 << " to " << addr2 << "\n";
-    nixlXferReqH *req_handle;
+    nixlXferReqH* req_handle;
 
     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);
+    ret1 = A1.createXferReq(NIXL_WRITE, req_src_descs, req_dst_descs, agent2, req_handle,
+                            &extra_params1);
+    assert(ret1 == NIXL_SUCCESS);
 
     nixl_status_t status = A1.postXferReq(req_handle);
 
     std::cout << "Transfer was posted\n";
 
     nixl_notifs_t notif_map;
-    int n_notifs = 0;
+    int           n_notifs = 0;
 
     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);
+        assert(status >= 0);
+        assert(ret2 == NIXL_SUCCESS);
         n_notifs = notif_map.size();
     }
 
     std::vector<std::string> agent1_notifs = notif_map[agent1];
-    assert (agent1_notifs.size() == 1);
-    assert (agent1_notifs.front() == "notification");
-    notif_map[agent1].clear(); // Redundant, for testing
+    assert(agent1_notifs.size() == 1);
+    assert(agent1_notifs.front() == "notification");
+    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);
+    assert(ret1 == NIXL_SUCCESS);
 
     ret1 = A1.deregisterMem(dlist1, &extra_params1);
     ret2 = A2.deregisterMem(dlist2, &extra_params2);
-    assert (ret1 == NIXL_SUCCESS);
-    assert (ret2 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
+    assert(ret2 == NIXL_SUCCESS);
 
-    //only initiator should call invalidate
+    // only initiator should call invalidate
     ret1 = A1.invalidateRemoteMD(agent2);
-    assert (ret1 == NIXL_SUCCESS);
+    assert(ret1 == NIXL_SUCCESS);
 
     free(addr1);
     free(addr2);