sbcli-pre 1.2.13__zip → 1.3.0__zip

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sbcli-pre
-Version: 1.2.13
+Version: 1.3.0
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/env_var

@@ -1,6 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-pre
-SIMPLY_BLOCK_VERSION=1.2.13
-
+SIMPLY_BLOCK_VERSION=1.3.0
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:pre-release
 

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/sbcli_pre.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sbcli-pre
-Version: 1.2.13
+Version: 1.3.0
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/cluster_ops.py

@@ -15,7 +15,7 @@ from jinja2 import Environment, FileSystemLoader
 
 from simplyblock_core import utils, scripts, constants, mgmt_node_ops, storage_node_ops
 from simplyblock_core.controllers import cluster_events, device_controller
-from simplyblock_core.kv_store import DBController
+from simplyblock_core.kv_store import DBController, KVStore
 from simplyblock_core.models.cluster import Cluster
 from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.models.storage_node import StorageNode
@@ -107,7 +107,6 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     except Exception as e:
         print(e)
 
-    db_controller = DBController()
     if not cli_pass:
         cli_pass = utils.generate_string(10)
 
@@ -181,6 +180,7 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     c.status = Cluster.STATUS_ACTIVE
 
     c.updated_at = int(time.time())
+    db_controller = DBController(KVStore())
     c.write_to_db(db_controller.kv_store)
 
     cluster_events.cluster_create(c)

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/constants.py

@@ -53,11 +53,13 @@ GRAYLOG_CHECK_INTERVAL_SEC = 60
 FDB_CHECK_INTERVAL_SEC = 60
 
 SIMPLY_BLOCK_DOCKER_IMAGE = "simplyblock/simplyblock:pre-release"
-SIMPLY_BLOCK_CLI_NAME = "sbcli"
+SIMPLY_BLOCK_DOCKER_IMAGE_ARM64 = "simplyblock/simplyblock:main-arm64"
+SIMPLY_BLOCK_CLI_NAME = "sbcli-dev"
 TASK_EXEC_INTERVAL_SEC = 30
 TASK_EXEC_RETRY_COUNT = 8
 
 SIMPLY_BLOCK_SPDK_CORE_IMAGE = "simplyblock/spdk-core:latest"
+SIMPLY_BLOCK_SPDK_CORE_IMAGE_ARM64 = "simplyblock/spdk-core:latest-arm64"
 SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:prerelease-latest"
 
 GELF_PORT = 12201

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/controllers/caching_node_controller.py

@@ -422,6 +422,7 @@ def connect(caching_node_id, lvol_id):
         ret, _ = cnode_client.connect_nvme(ip, "4420", subsystem_nqn)
         break
 
+    time.sleep(5)
     cnode_info, _ = cnode_client.info()
     nvme_devs = cnode_info['nvme_devices']
     dev_path = None
@@ -566,8 +567,11 @@ def deploy(ifname):
             time.sleep(2)
 
     logger.info("Creating CachingNodeAPI container")
+    cont_image = constants.SIMPLY_BLOCK_DOCKER_IMAGE
+    if utils.get_host_arch() == "aarch64":
+        cont_image = constants.SIMPLY_BLOCK_DOCKER_IMAGE_ARM64
     container = node_docker.containers.run(
-        constants.SIMPLY_BLOCK_DOCKER_IMAGE,
+        cont_image,
         "python simplyblock_web/caching_node_app.py",
         detach=True,
         privileged=True,
@@ -586,8 +590,10 @@ def deploy(ifname):
         ]
     )
     logger.info("Pulling SPDK images")
-    node_docker.images.pull(constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE)
-    node_docker.images.pull(constants.SIMPLY_BLOCK_SPDK_ULTRA_IMAGE)
+    spdk_core = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE
+    if utils.get_host_arch() == "aarch64":
+        spdk_core = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE_ARM64
+    node_docker.images.pull(spdk_core)
     return f"{dev_ip}:5000"
 
 

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/controllers/device_controller.py

@@ -111,8 +111,15 @@ def _def_create_device_stack(device_obj, snode, force=False):
     alceml_id = device_obj.get_id()
     alceml_name = get_alceml_name(alceml_id)
     logger.info(f"adding {alceml_name}")
-    ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=2,
-                                        dev_cpu_mask=snode.dev_cpu_mask)
+
+    if snode.alceml_cpu_cores:
+        alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+        ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=2,
+                                            alceml_cpu_mask=alceml_cpu_mask)
+        snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+    else:
+        ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=2)
+
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         if not force:
@@ -150,7 +157,7 @@ def _def_create_device_stack(device_obj, snode, force=False):
 
     if hasattr(device_obj, 'jm_bdev') and device_obj.jm_bdev:
         ret = rpc_client.bdev_jm_create(device_obj.jm_bdev, device_obj.alceml_bdev,
-                                        dev_cpu_mask=snode.dev_cpu_mask)
+                                        jm_cpu_mask=snode.jm_cpu_mask)
         if not ret:
             logger.error(f"Failed to create jm bdev: {device_obj.jm_bdev}")
             if not force:

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/controllers/lvol_controller.py

@@ -265,7 +265,7 @@ def add_lvol(name, size, host_id_or_name, pool_id_or_name, use_comp, use_crypto,
 
     # name, vuid, ndcs, npcs, num_blocks, block_size, alloc_names
     ret = rpc_client.bdev_distrib_create(f"distr_{name}", vuid, distr_ndcs, distr_npcs, num_blocks, distr_bs, jm_names,
-                                         distr_chunk_bs, dev_cpu_mask=snode.dev_cpu_mask)
+                                         distr_chunk_bs, distrib_cpu_mask=snode.distrib_cpu_mask)
     bdev_stack.append({"type": "distr", "name": f"distr_{name}"})
     if not ret:
         logger.error("failed to create Distr bdev")
@@ -772,7 +772,7 @@ def _create_bdev_stack(lvol, snode, ha_comm_addrs, ha_inode_self):
             params['jm_names'] = get_jm_names(snode)
             params['ha_comm_addrs'] = ha_comm_addrs
             params['ha_inode_self'] = ha_inode_self
-            params['dev_cpu_mask'] = snode.dev_cpu_mask
+            params['distrib_cpu_mask'] = snode.distrib_cpu_mask
             ret = rpc_client.bdev_distrib_create(**params)
             if ret:
                 ret = distr_controller.send_cluster_map_to_node(snode)

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/controllers/snapshot_controller.py

@@ -66,7 +66,7 @@ def add(lvol_id, snapshot_name):
     ret = rpc_client.bdev_distrib_create(
         base_name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
         lvol.distr_bs, lvol_controller.get_jm_names(snode), lvol.distr_chunk_bs,
-        None, None, lvol.distr_page_size, dev_cpu_mask=snode.dev_cpu_mask)
+        None, None, lvol.distr_page_size, distrib_cpu_mask=snode.distrib_cpu_mask)
     if not ret:
         logger.error("Failed to create Distr bdev")
         return False, "Failed to create Distr bdev"
@@ -260,7 +260,7 @@ def clone(snapshot_id, clone_name, new_size=0):
     ret = rpc_client.bdev_distrib_create(
         name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
         lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size,
-        dev_cpu_mask=snode.dev_cpu_mask)
+        distrib_cpu_mask=snode.distrib_cpu_mask)
     if not ret:
         msg="Failed to create Distr bdev"
         logger.error(msg)

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/kv_store.py

@@ -186,7 +186,9 @@ class DBController:
             for pool in self.get_pools(cluster_id):
                 if pool.cluster_id == cluster_id:
                     for lv_id in pool.lvols:
-                        lvols.append(self.get_lvol_by_id(lv_id))
+                        lv = self.get_lvol_by_id(lv_id)
+                        if lv:
+                            lvols.append(lv)
         else:
             lvols = LVol().read_from_db(self.kv_store)
         return lvols

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/models/storage_node.py

@@ -75,9 +75,12 @@ class StorageNode(BaseModel):
         "spdk_cpu_mask": {"type": str, "default": ""},
         "app_thread_mask": {"type": str, "default": ""},
         "pollers_mask": {"type": str, "default": ""},
-        "os_cores": {"type": str, "default": []},
-        "nvme_pollers_cores": {"type": str, "default": ""},
-        "dev_cpu_mask": {"type": str, "default": ""},
+        "poller_cpu_cores": {"type": str, "default": ""},
+        "jm_cpu_mask": {"type": str, "default": ""},
+        "alceml_cpu_cores": {"type": List[int], "default": []},
+        "alceml_cpu_index": {"type": int, "default": 0},
+        "distrib_cpu_mask": {"type": str, "default": ""},
+
         "spdk_mem": {"type": int, "default": 0},
         "spdk_image": {"type": str, "default": ""},
         "spdk_debug": {"type": bool, "default": False},

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/rpc_client.py

@@ -319,7 +319,7 @@ class RPCClient:
         return self._request2("ultra21_bdev_pass_delete", params)
 
     def bdev_alceml_create(self, alceml_name, nvme_name, uuid, pba_init_mode=3,
-                           dev_cpu_mask=""):
+                           alceml_cpu_mask=""):
         params = {
             "name": alceml_name,
             "cntr_path": nvme_name,
@@ -335,13 +335,13 @@ class RPCClient:
             "use_optimized": True,
             "pba_nbalign": 4096
         }
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask,16)
+        if alceml_cpu_mask:
+            params["bdb_lcpu_mask"] = int(alceml_cpu_mask, 16)
         return self._request("bdev_alceml_create", params)
 
     def bdev_distrib_create(self, name, vuid, ndcs, npcs, num_blocks, block_size, jm_names,
                             chunk_size, ha_comm_addrs=None, ha_inode_self=None, pba_page_size=2097152,
-                            dev_cpu_mask=""):
+                            distrib_cpu_mask=""):
         """"
             // Optional (not specified = no HA)
             // Comma-separated communication addresses, for each node, e.g. "192.168.10.1:45001,192.168.10.1:32768".
@@ -367,8 +367,8 @@ class RPCClient:
         if ha_comm_addrs:
             params['ha_comm_addrs'] = ha_comm_addrs
             params['ha_inode_self'] = ha_inode_self
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask, 16)
+        if distrib_cpu_mask:
+            params["bdb_lcpu_mask"] = int(distrib_cpu_mask, 16)
 
         return self._request("bdev_distrib_create", params)
 
@@ -601,14 +601,14 @@ class RPCClient:
         }
         return self._request("ultra21_lvol_dismount", params)
 
-    def bdev_jm_create(self, name, name_storage1, block_size=4096, dev_cpu_mask=""):
+    def bdev_jm_create(self, name, name_storage1, block_size=4096, jm_cpu_mask=""):
         params = {
             "name": name,
             "name_storage1": name_storage1,
             "block_size": block_size
         }
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask, 16)
+        if jm_cpu_mask:
+            params["bdb_lcpu_mask"] = int(jm_cpu_mask, 16)
         return self._request("bdev_jm_create", params)
 
     def bdev_jm_delete(self, name):

sbcli_pre-1.3.0/simplyblock_core/scripts/db_config_single.sh

@@ -0,0 +1,2 @@
+fdbcli --exec "configure new single ssd" --timeout 100
+sleep 10

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/scripts/install_deps.sh

@@ -15,7 +15,7 @@ sudo yum install hostname pkg-config git wget python3-pip yum-utils docker-ce do
 sudo systemctl enable docker
 sudo systemctl start docker
 
-sudo docker plugin install rexray/efs --grant-all-permissions EFS_TAG=$INSTANCE_ID REXRAY_PREEMPT=true
+#sudo docker plugin install rexray/efs --grant-all-permissions EFS_TAG=$INSTANCE_ID REXRAY_PREEMPT=true
 
 wget https://github.com/apple/foundationdb/releases/download/7.3.3/foundationdb-clients-7.3.3-1.el7.x86_64.rpm -q
 sudo rpm -U foundationdb-clients-7.3.3-1.el7.x86_64.rpm --quiet --reinstall

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/storage_node_ops.py

@@ -241,13 +241,19 @@ def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
     pba_init_mode = 3
     if after_restart:
         pba_init_mode = 2
-    ret = rpc_client.bdev_alceml_create(alceml_name, raid_bdev, str(uuid.uuid4()), pba_init_mode=pba_init_mode)
+    if snode.alceml_cpu_cores:
+        alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+        ret = rpc_client.bdev_alceml_create(alceml_name, raid_bdev, str(uuid.uuid4()), pba_init_mode=pba_init_mode,
+                                            alceml_cpu_mask=alceml_cpu_mask)
+        snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+    else:
+        ret = rpc_client.bdev_alceml_create(alceml_name, raid_bdev, str(uuid.uuid4()), pba_init_mode=pba_init_mode)
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         return False
 
     jm_bdev = f"jm_{snode.get_id()}"
-    ret = rpc_client.bdev_jm_create(jm_bdev, alceml_name)
+    ret = rpc_client.bdev_jm_create(jm_bdev, alceml_name, jm_cpu_mask=snode.jm_cpu_mask)
     if not ret:
         logger.error(f"Failed to create {jm_bdev}")
         return False
@@ -274,13 +280,20 @@ def _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart):
     pba_init_mode = 3
     if after_restart:
         pba_init_mode = 2
-    ret = rpc_client.bdev_alceml_create(alceml_name, nvme.nvme_bdev, alceml_id, pba_init_mode=pba_init_mode)
+    if snode.alceml_cpu_cores:
+        alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+        ret = rpc_client.bdev_alceml_create(alceml_name, nvme.nvme_bdev, alceml_id, pba_init_mode=pba_init_mode,
+                                            alceml_cpu_mask=alceml_cpu_mask)
+        snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+    else:
+        ret = rpc_client.bdev_alceml_create(alceml_name, nvme.nvme_bdev, alceml_id, pba_init_mode=pba_init_mode)
+
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         return False
 
     jm_bdev = f"jm_{snode.get_id()}"
-    ret = rpc_client.bdev_jm_create(jm_bdev, alceml_name)
+    ret = rpc_client.bdev_jm_create(jm_bdev, alceml_name, jm_cpu_mask=snode.jm_cpu_mask)
     if not ret:
         logger.error(f"Failed to create {jm_bdev}")
         return False
@@ -308,8 +321,16 @@ def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
     pba_init_mode = 3
     if after_restart:
         pba_init_mode = 2
-    ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=pba_init_mode,
-                                            dev_cpu_mask=snode.dev_cpu_mask)
+
+    if snode.alceml_cpu_cores:
+        alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+        ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=pba_init_mode,
+                                            alceml_cpu_mask=alceml_cpu_mask)
+        snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+    else:
+        ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=pba_init_mode)
+
+
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         return False
@@ -507,13 +528,20 @@ def _prepare_cluster_devices_on_restart(snode):
             return False
     else:
 
-        ret = rpc_client.bdev_alceml_create(jm_device.alceml_bdev, jm_device.nvme_bdev, jm_device.get_id(), pba_init_mode=2)
+        if snode.alceml_cpu_cores:
+            alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+            ret = rpc_client.bdev_alceml_create(jm_device.alceml_bdev, jm_device.nvme_bdev, jm_device.get_id(),
+                                            pba_init_mode=2, alceml_cpu_mask=alceml_cpu_mask)
+            snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+        else:
+            ret = rpc_client.bdev_alceml_create(jm_device.alceml_bdev, jm_device.nvme_bdev, jm_device.get_id(),
+                                            pba_init_mode=2)
         if not ret:
             logger.error(f"Failed to create alceml bdev: {jm_device.alceml_bdev}")
             return False
 
         jm_bdev = f"jm_{snode.get_id()}"
-        ret = rpc_client.bdev_jm_create(jm_bdev, jm_device.alceml_bdev)
+        ret = rpc_client.bdev_jm_create(jm_bdev, jm_device.alceml_bdev, jm_cpu_mask=snode.jm_cpu_mask)
         if not ret:
             logger.error(f"Failed to create {jm_bdev}")
             return False
@@ -612,22 +640,26 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     cpu_count = node_info["cpu_count"]
     pollers_mask = ""
     app_thread_mask = ""
-    dev_cpu_mask = ""
-    nvme_pollers_cores = []
+    jm_cpu_mask = ""
+    alceml_cpu_cores = []
+    alceml_cpu_index = 0
+    distrib_cpu_mask = ""
+
+    poller_cpu_cores = []
     if cpu_count < 8:
         mask = (1 << (cpu_count - 1)) - 1
         mask <<= 1
         spdk_cpu_mask = f'0x{mask:X}'
-        os_cores = [0]
     else:
-        os_cores, nvme_pollers_cores, app_thread_core, dev_cpu_cores = \
+        app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, distrib_cpu_cores = \
             utils.calculate_core_allocation(cpu_count)
-        spdk_cores = nvme_pollers_cores + app_thread_core + dev_cpu_cores
+        spdk_cores = app_thread_core + jm_cpu_core + poller_cpu_cores + alceml_cpu_cores + distrib_cpu_cores
 
-        pollers_mask = utils.generate_mask(nvme_pollers_cores)
+        pollers_mask = utils.generate_mask(poller_cpu_cores)
         app_thread_mask = utils.generate_mask(app_thread_core)
         spdk_cpu_mask = utils.generate_mask(spdk_cores)
-        dev_cpu_mask = utils.generate_mask(dev_cpu_cores)
+        jm_cpu_mask = utils.generate_mask(jm_cpu_core)
+        distrib_cpu_mask = utils.generate_mask(distrib_cpu_cores)
 
     # Calculate pool count
     if ec2_metadata and ec2_metadata.get('instanceType'):
@@ -649,7 +681,7 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     number_of_split = num_partitions_per_dev if num_partitions_per_dev else num_partitions_per_dev + 1
     number_of_alceml_devices = number_of_devices * number_of_split
     small_pool_count, large_pool_count = utils.calculate_pool_count(
-        number_of_alceml_devices, max_lvol, max_snap, cpu_count, len(nvme_pollers_cores) or cpu_count)
+        number_of_alceml_devices, max_lvol, max_snap, cpu_count, len(poller_cpu_cores) or cpu_count)
 
     # Calculate minimum huge page memory
     minimum_hp_memory = utils.calculate_minimum_hp_memory(small_pool_count, large_pool_count, max_lvol, max_snap, cpu_count)
@@ -758,9 +790,11 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     snode.write_to_db(kv_store)
     snode.app_thread_mask = app_thread_mask or ""
     snode.pollers_mask = pollers_mask or ""
-    snode.nvme_pollers_cores = nvme_pollers_cores or []
-    snode.dev_cpu_mask = dev_cpu_mask or ""
-    snode.os_cores = os_cores or []
+    snode.jm_cpu_mask = jm_cpu_mask
+    snode.alceml_cpu_index = alceml_cpu_index
+    snode.alceml_cpu_cores = alceml_cpu_cores
+    snode.distrib_cpu_mask = distrib_cpu_mask
+    snode.poller_cpu_cores = poller_cpu_cores or []
 
     snode.iobuf_small_pool_count = small_pool_count or 0
     snode.iobuf_large_pool_count = large_pool_count or 0
@@ -1083,7 +1117,7 @@ def restart_storage_node(
     number_of_split = snode.num_partitions_per_dev if snode.num_partitions_per_dev else snode.num_partitions_per_dev + 1
     number_of_alceml_devices = number_of_devices * number_of_split
     small_pool_count, large_pool_count = utils.calculate_pool_count(
-        number_of_alceml_devices, snode.max_lvol, snode.max_snap, snode.cpu, len(snode.nvme_pollers_cores) or snode.cpu)
+        number_of_alceml_devices, snode.max_lvol, snode.max_snap, snode.cpu, len(snode.poller_cpu_cores) or snode.cpu)
 
     # Calculate minimum huge page memory
     minimum_hp_memory = utils.calculate_minimum_hp_memory(small_pool_count, large_pool_count, snode.max_lvol, snode.max_snap, snode.cpu)

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_core/utils.py

@@ -286,38 +286,32 @@ def calculate_core_allocation(cpu_count):
     '''
     If number of cpu cores >= 8, tune cpu core mask
         1. Never use core 0 for spdk.
-        2. For every 8 cores, leave one core to the operating system
-        3. Do not use more than 15% of remaining available cores for nvme pollers
-        4. Use one dedicated core for app_thread
-        5. distribute distrib bdevs and alceml bdevs to all other cores
+        2. Core 1 is for app_thread
+        3. Core 2 for Journal manager
+        4. Poller cpu cores are 30% of Available cores
+        5. Alceml cpu cores are 30% of Available cores
+        6. Distribs cpu cores are 40% of Available cores
     JIRA ticket link/s
     https://simplyblock.atlassian.net/browse/SFAM-885
     '''
 
     all_cores = list(range(0, cpu_count))
-    # Calculate the number of cores to exclude for the OS
-    if cpu_count == 8:
-        os_cores_count = 1
-    else:
-        os_cores_count = 1 + (cpu_count // 8)
-
-    # Calculate os cores
-    os_cores = all_cores[0:os_cores_count]
+    app_thread_core = all_cores[1:2]
+    jm_cpu_core = all_cores[2:3]
 
     # Calculate available cores
-    available_cores_count = cpu_count - os_cores_count
+    available_cores_count = cpu_count - 3
 
-    # Calculate NVMe pollers
-    nvme_pollers_count = int(available_cores_count * 0.15)
-    nvme_pollers_cores = all_cores[os_cores_count:os_cores_count + nvme_pollers_count]
+    # Calculate cpus counts
+    poller_cpus_count = int(available_cores_count * 0.3)
+    alceml_cpus_cout = int(available_cores_count * 0.3)
 
-    # Allocate core for app_thread
-    app_thread_core = all_cores[os_cores_count + nvme_pollers_count:os_cores_count + nvme_pollers_count + 1]
+    # Calculate cpus cores
+    poller_cpu_cores = all_cores[3:poller_cpus_count+3]
+    alceml_cpu_cores = all_cores[3+poller_cpus_count:poller_cpus_count+alceml_cpus_cout+3]
+    distrib_cpu_cores = all_cores[3+poller_cpus_count+alceml_cpus_cout:]
 
-    # Calculate bdb_lcpu cores
-    bdb_lcpu_cores = all_cores[os_cores_count + nvme_pollers_count + 1:]
-
-    return os_cores, nvme_pollers_cores, app_thread_core, bdb_lcpu_cores
+    return app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, distrib_cpu_cores
 
 
 def generate_mask(cores):
@@ -405,3 +399,13 @@ def validate_add_lvol_or_snap_on_node(memory_free, huge_free, max_lvol_or_snap,
     if node_lvol_or_snap_count >= max_lvol_or_snap:
         return f"You have exceeded the max number of lvol/snap {max_lvol_or_snap}"
     return ""
+
+
+def get_host_arch():
+    out, _, _ = shell_utils.run_command("uname -m")
+    return out
+
+def decimal_to_hex_power_of_2(decimal_number):
+    power_result = 2 ** decimal_number
+    hex_result = hex(power_result)
+    return hex_result

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_web/blueprints/caching_node_ops.py

@@ -174,6 +174,10 @@ def spdk_process_start():
             time.sleep(2)
 
     spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE
+
+    if node_utils.get_host_arch() == "aarch64":
+        spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE_ARM64
+
     if 'spdk_image' in data and data['spdk_image']:
         spdk_image = data['spdk_image']
         node_docker.images.pull(spdk_image)
@@ -201,7 +205,7 @@ def spdk_process_start():
     rpc_password = data['rpc_password']
 
     container2 = node_docker.containers.run(
-        constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE,
+        spdk_image,
         "python /root/scripts/spdk_http_proxy_server.py",
         name="spdk_proxy",
         detach=True,
@@ -301,7 +305,7 @@ def get_info():
         "system_id": system_id,
 
         "cpu_count": cpuinfo.get_cpu_info()['count'],
-        "cpu_hz": cpuinfo.get_cpu_info()['hz_advertised'][0],
+        "cpu_hz": cpuinfo.get_cpu_info()['hz_advertised'][0] if 'hz_advertised' in cpuinfo.get_cpu_info() else 1,
 
         "memory": get_memory(),
         "hugepages": get_huge_memory(),

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_web/blueprints/caching_node_ops_k8s.py

@@ -112,6 +112,9 @@ def spdk_process_start():
         spdk_mem = 64096
 
     spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE
+    if node_utils.get_host_arch() == "aarch64":
+        spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE_ARM64
+
     if 'spdk_image' in data and data['spdk_image']:
         spdk_image = data['spdk_image']
 

{sbcli_pre-1.2.13 → sbcli_pre-1.3.0}/simplyblock_web/node_utils.py

@@ -163,3 +163,7 @@ def get_memory_details():
         pass
     return data
 
+
+def get_host_arch():
+    out, err, rc = run_command("uname -m")
+    return out

sbcli_pre-1.2.13/simplyblock_core/scripts/db_config_single.sh

@@ -1 +0,0 @@
-fdbcli --exec "configure new single ssd" --timeout 100