ಪೈಥಾನ್‌ನಲ್ಲಿನ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ದೊಡ್ಡ ನಂಬಿ ಅರೇಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹಂಚಿಕೊಳ್ಳುವುದು

ಪೈಥಾನ್‌ನಲ್ಲಿ ದೊಡ್ಡ ಡೇಟಾ ವರ್ಗಾವಣೆಗಾಗಿ ಹಂಚಿದ ಸ್ಮರಣೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಪೈಥಾನ್‌ನಲ್ಲಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಆಗಾಗ್ಗೆ ಸವಾಲುಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಮಲ್ಟಿಪ್ರೊಸೆಸಿಂಗ್ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬಂದಾಗ. ಬೃಹತ್ ಪ್ರಮಾಣದಲ್ಲಿ ಹಂಚಿಕೆ numpy ಸರಣಿಗಳು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಮತ್ತು ಅನಗತ್ಯ ನಕಲು ಮಾಡದೆ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಅಂತಹ ಒಂದು ಅಡಚಣೆಯಾಗಿದೆ.

ನೀವು ವೈಜ್ಞಾನಿಕ ಡೇಟಾ, ಹಣಕಾಸು ಮಾದರಿಗಳು ಅಥವಾ ಯಂತ್ರ ಕಲಿಕೆಯ ಒಳಹರಿವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ, ಮತ್ತು ಪ್ರತಿ ಡೇಟಾಸೆಟ್ ಗಮನಾರ್ಹ ಮೆಮೊರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. 🧠 ಪೈಥಾನ್‌ನ ಮಲ್ಟಿಪ್ರೊಸೆಸಿಂಗ್ ಮಾಡ್ಯೂಲ್ ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹುಟ್ಟುಹಾಕಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ, ನಂಬಿ ಅರೇಗಳಂತಹ ಡೇಟಾವನ್ನು ಸಮರ್ಥವಾಗಿ ಹಂಚಿಕೊಳ್ಳುವುದು ಟ್ರಿಕಿ ಆಗಿರಬಹುದು.

ಈ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು HDF5 ಫೈಲ್‌ಗೆ ಬರೆಯುವುದನ್ನು ನೀವು ಪರಿಗಣಿಸಿದಾಗ ಈ ವಿಷಯವು ಇನ್ನಷ್ಟು ನಿರ್ಣಾಯಕವಾಗುತ್ತದೆ, ಇದು ಬೃಹತ್ ಪ್ರಮಾಣದ ರಚನಾತ್ಮಕ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಅದರ ದೃಢತೆಗೆ ಹೆಸರುವಾಸಿಯಾಗಿದೆ. ಸರಿಯಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯಿಲ್ಲದೆ, ನೀವು ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು ಅಥವಾ "ಮೆಮೊರಿ ಕಂಡುಬಂದಿಲ್ಲ" ದೋಷಗಳಿಗೆ ಒಳಗಾಗುವ ಅಪಾಯವಿದೆ, ಇದು ನಿಮ್ಮ ಕೆಲಸದ ಹರಿವನ್ನು ಅಡ್ಡಿಪಡಿಸುತ್ತದೆ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಯನ್ನು ನಮ್ಮ ಆಂಕರ್‌ನಂತೆ ಬಳಸಿಕೊಂಡು, ನಂಬಿ ಅರೇಗಳಿಗಾಗಿ ಹಂಚಿದ ಮೆಮೊರಿಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಸಲಹೆಗಳೊಂದಿಗೆ, ಸಾಮಾನ್ಯ ಮೋಸಗಳನ್ನು ತಪ್ಪಿಸುವಾಗ ದೊಡ್ಡ ಡೇಟಾವನ್ನು ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನೀವು ಕಲಿಯುವಿರಿ. ಧುಮುಕೋಣ! 🚀

ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ನಂಬಿ ಅರೇ ಹಂಚಿಕೆಯನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು

ಮೇಲೆ ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ದೊಡ್ಡದನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಸವಾಲನ್ನು ಪರಿಹರಿಸುವತ್ತ ಗಮನಹರಿಸುತ್ತವೆ numpy ಸರಣಿಗಳು ಡೇಟಾವನ್ನು ನಕಲು ಮಾಡದೆಯೇ ಪೈಥಾನ್‌ನಲ್ಲಿನ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ. ಹಂಚಿದ ಸ್ಮರಣೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳುವುದು, ಸಮರ್ಥ ಸಂವಹನ ಮತ್ತು ಕನಿಷ್ಠ ಸಂಪನ್ಮೂಲ ಬಳಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಪ್ರಾಥಮಿಕ ಗುರಿಯಾಗಿದೆ. ಪೈಥಾನ್ ಅನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ ಬಹುಸಂಸ್ಕರಣೆ ಮತ್ತು ಹಂಚಿಕೆಯ ಮೆಮೊರಿ ಮಾಡ್ಯೂಲ್‌ಗಳು, ಪರಿಹಾರವು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು numpy ಸರಣಿಗಳನ್ನು ಪೋಷಕರ ಪ್ರಕ್ರಿಯೆಗೆ ಮನಬಂದಂತೆ ಹಂಚಿಕೊಳ್ಳಲು ಅನುಮತಿಸುತ್ತದೆ.

ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಬಳಸುತ್ತದೆ ಹಂಚಿದ ಸ್ಮರಣೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ವರ್ಗ. ಈ ವಿಧಾನವು ನಕಲು ಮಾಡುವ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ, ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅವಶ್ಯಕವಾಗಿದೆ. ಹಂಚಿದ ಮೆಮೊರಿ ಜಾಗದಲ್ಲಿ ನಂಬಿ ಅರೇ ಅನ್ನು ಪುನರ್ನಿರ್ಮಿಸಲಾಗಿದ್ದು, ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ನೇರವಾಗಿ ಅರೇಯನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಸರತಿ ಸಾಲುಗಳ ಬಳಕೆಯು ಪೋಷಕ ಮತ್ತು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಸರಿಯಾದ ಸಂವಹನವನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಸೋರಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ಮೆಮೊರಿಯನ್ನು ಅನ್‌ಲಿಂಕ್ ಮಾಡಿದಾಗ ತಿಳಿಸುವುದು.

ಪರ್ಯಾಯ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ Pool.map ಕಾರ್ಯ, ಇದು ಪ್ರಕ್ರಿಯೆಗಳ ರಚನೆ ಮತ್ತು ಸೇರುವಿಕೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ. ಪ್ರತಿ ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಅದರ ಸಂಬಂಧಿತ ಫೈಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ರಚನೆಯ ವಿವರಗಳನ್ನು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗೆ ಹಿಂತಿರುಗಿಸಲು ಹಂಚಿದ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸ್ವಚ್ಛ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲದು, ವಿಶೇಷವಾಗಿ ಬಹು ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ. ವೈಜ್ಞಾನಿಕ ಡೇಟಾ ಸಂಸ್ಕರಣೆ ಅಥವಾ ಇಮೇಜ್ ವಿಶ್ಲೇಷಣೆಯಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಇದು ಪ್ರಾಯೋಗಿಕ ಪರಿಹಾರವಾಗಿದೆ, ಅಲ್ಲಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹಂಚಿಕೊಳ್ಳಬೇಕು.

ದೊಡ್ಡ ಪಠ್ಯ ಫೈಲ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಜೀನೋಮಿಕ್ ಡೇಟಾವನ್ನು ಸಂಶೋಧನಾ ತಂಡವು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಪ್ರತಿ ಫೈಲ್ ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮೆಮೊರಿ ನಿರ್ಬಂಧಗಳ ಕಾರಣದಿಂದಾಗಿ ನಕಲು ಮಾಡುವುದು ಅಪ್ರಾಯೋಗಿಕವಾಗಿದೆ. ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಪ್ರತಿ ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಫೈಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಪೋಷಕರು ಡೇಟಾವನ್ನು ಒಂದೇ HDF5 ಫೈಲ್‌ಗೆ ಬರೆಯುತ್ತಾರೆ. ಹಂಚಿದ ಮೆಮೊರಿಯೊಂದಿಗೆ, ತಂಡವು ಅನಗತ್ಯ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ, ಸುಗಮ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. 🚀 ಈ ವಿಧಾನವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು ಮಾತ್ರವಲ್ಲದೆ "ಮೆಮೊರಿ ಕಂಡುಬಂದಿಲ್ಲ" ಅಥವಾ ಮೆಮೊರಿ ಸೋರಿಕೆಯಂತಹ ದೋಷಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಇದು ಅಂತಹ ಕಾರ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಸಾಮಾನ್ಯ ಮೋಸಗಳು. 🧠

from multiprocessing import Process, Queue
from multiprocessing.shared_memory import SharedMemory
import numpy as np
from pathlib import Path
def loadtxt_worker(out_queue, in_queue, filepath):
    dtype = [('chr', 'S10'), ('pos', '<i4'), ('pct', '<f4'), ('c', '<i4'), ('t', '<i4')]
    data = np.loadtxt(filepath, dtype=dtype)
    shm = SharedMemory(create=True, size=data.nbytes)
    shared_array = np.ndarray(data.shape, dtype=dtype, buffer=shm.buf)
    shared_array[:] = data
    out_queue.put({"name": shm.name, "shape": data.shape, "dtype": dtype})
    while True:
        msg = in_queue.get()
        if msg == "done":
            shm.close()
            shm.unlink()
            break
def main():
    filenames = ["data1.txt", "data2.txt"]
    out_queue = Queue()
    in_queue = Queue()
    processes = []
    for file in filenames:
        p = Process(target=loadtxt_worker, args=(out_queue, in_queue, file))
        p.start()
        processes.append(p)
    for _ in filenames:
        msg = out_queue.get()
        shm = SharedMemory(name=msg["name"])
        array = np.ndarray(msg["shape"], dtype=msg["dtype"], buffer=shm.buf)
        print("Array from child:", array)
        in_queue.put("done")
    for p in processes:
        p.join()
if __name__ == "__main__":
    main()

from multiprocessing import Pool, shared_memory
import numpy as np
from pathlib import Path
def load_and_share(file_info):
    filepath, dtype = file_info
    data = np.loadtxt(filepath, dtype=dtype)
    shm = shared_memory.SharedMemory(create=True, size=data.nbytes)
    shared_array = np.ndarray(data.shape, dtype=dtype, buffer=shm.buf)
    shared_array[:] = data
    return {"name": shm.name, "shape": data.shape, "dtype": dtype}
def main():
    dtype = [('chr', 'S10'), ('pos', '<i4'), ('pct', '<f4'), ('c', '<i4'), ('t', '<i4')]
    filenames = ["data1.txt", "data2.txt"]
    file_info = [(file, dtype) for file in filenames]
    with Pool(processes=2) as pool:
        results = pool.map(load_and_share, file_info)
        for res in results:
            shm = shared_memory.SharedMemory(name=res["name"])
            array = np.ndarray(res["shape"], dtype=res["dtype"], buffer=shm.buf)
            print("Shared Array:", array)
            shm.close()
            shm.unlink()
if __name__ == "__main__":
    main()

ಮಲ್ಟಿಪ್ರೊಸೆಸಿಂಗ್ ಪರಿಸರದಲ್ಲಿ ಡೇಟಾ ಹಂಚಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದು

ಕೆಲಸ ಮಾಡುವ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶ ದೊಡ್ಡ numpy ಸರಣಿಗಳು ಮಲ್ಟಿಪ್ರೊಸೆಸಿಂಗ್‌ನಲ್ಲಿ ಸಮರ್ಥ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಮತ್ತು ಹಂಚಿಕೆಯ ಸಂಪನ್ಮೂಲಗಳ ನಿರ್ವಹಣೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ. ಹಂಚಿದ ಮೆಮೊರಿಯು ಶಕ್ತಿಯುತವಾದ ಸಾಧನವಾಗಿದ್ದರೂ, ಸಂಘರ್ಷಗಳು ಮತ್ತು ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಯಲು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿದೆ. ಸರಿಯಾದ ವಿನ್ಯಾಸವು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಗಳು ಅನಗತ್ಯ ಡೇಟಾ ನಕಲು ಅಥವಾ ದೋಷಗಳಿಲ್ಲದೆ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯೊಂದಿಗೆ ಸರಣಿಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಡೇಟಾ ಪ್ರಕಾರಗಳು ಮತ್ತು ಆಕಾರಗಳನ್ನು ಸ್ಥಿರವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಬಳಸಿಕೊಂಡು ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಿದಾಗ numpy.loadtxt, ಇದನ್ನು ಪ್ರಕ್ರಿಯೆಗಳಾದ್ಯಂತ ಒಂದೇ ರಚನೆಯಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಬೇಕು. HDF5 ನಂತಹ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಿಗೆ ಬರೆಯುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಪ್ರಸ್ತುತವಾಗಿದೆ, ಏಕೆಂದರೆ ತಪ್ಪಾದ ಡೇಟಾ ರಚನೆಯು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಅಥವಾ ದೋಷಪೂರಿತ ಫೈಲ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಇದನ್ನು ಸಾಧಿಸಲು, ರಚನೆಯ ಬಗ್ಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು-ಅದರ ಆಕಾರ, ಡಿಟೈಪ್ ಮತ್ತು ಹಂಚಿಕೆಯ ಮೆಮೊರಿ ಹೆಸರು-ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ತಡೆರಹಿತ ಪುನರ್ನಿರ್ಮಾಣಕ್ಕೆ ಅತ್ಯಗತ್ಯ.

ದೊಡ್ಡ ಹವಾಮಾನ ಡೇಟಾಸೆಟ್‌ಗಳು ಅಥವಾ ಜೀನೋಮ್ ಸೀಕ್ವೆನ್ಸಿಂಗ್ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಂತಹ ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ಈ ತಂತ್ರಗಳು ಸಂಶೋಧಕರಿಗೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಹಂಚಿದ ಮೆಮೊರಿಯನ್ನು ಸಂವಹನಕ್ಕಾಗಿ ಕ್ಯೂಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಸಿಸ್ಟಮ್ ಮೆಮೊರಿಯನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡದೆಯೇ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ಫೈಲ್ ಕಾಲಾನಂತರದಲ್ಲಿ ಪ್ರದೇಶದ ತಾಪಮಾನವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಉಪಗ್ರಹ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದನ್ನು ಊಹಿಸಿ. 🚀 ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಕಾರ್ಯಗಳಿಗಾಗಿ ಮೃದುವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುವ ಮೂಲಕ ವ್ಯವಸ್ಥೆಯು ಈ ಬೃಹತ್ ಸರಣಿಗಳನ್ನು ಅಡಚಣೆಗಳಿಲ್ಲದೆ ನಿರ್ವಹಿಸಬೇಕು. 🌍