<details> <summary title=".bashrc"><kbd> .bashrc </kbd></summary>

<pre><code class="lang-bash">export PYTHONHASHSEED=0</code></pre>

</details>

<details> <summary title="Your bash script"><kbd> Your bash script </kbd></summary>

<pre><code class="lang-bash">export PYTHONHASHSEED=0 python YOURSCRIPT.py</code></pre>

</details>

<details> <summary title="Terminal"><kbd> Terminal </kbd></summary>

<pre><code class="lang-shell">$ PYTHONHASHSEED=0 python YOURSCRIPT.py</code></pre>

</details>

Examples

• An async examples (with asyncio):

Receiver.py performance measurements

• CPU: i5-3570@3.40GHz (Ivy Bridge)
• RAM: 32 GBytes, DDR3, dual channel, 655 MHz
• OS: Ubuntu 20.04.6 LTS under WSL2. Windows 10

# We create local variables once in order to access them many times in the future, ensuring high performance. # Applying a principle that is widely recommended for improving Python code. companymetrics: List = sso.companyinfo.companymetrics # 12479 iterations/seconds someemployee: Employee = sso.companyinfo.someemployee # 10568 iterations/seconds datadict: Dict = sso.datadict # 16_362 iterations/seconds numpyndarray: np.ndarray = datadict[&#39;key3&#39;] # 26_223 iterations/seconds

Optimal work with shared data (through local variables):

# Object properties k = sso.intvalue # 850098 iterations/seconds k = sso.strvalue # 228966 iterations/seconds sso.intvalue = 200 # 207480 iterations/seconds sso.intvalue += 1 # 152263 iterations/seconds sso.strvalue = &#39;Hello. &#39; # 52390 iterations/seconds (memory allocation performance is planned to be improved) sso.strvalue += &#39;!&#39; # 35823 iterations/seconds (memory allocation performance is planned to be improved)

# Numpy.ndarray numpyndarray += 10 # 403646 iterations/seconds numpyndarray -= 15 # 402107 iterations/seconds

# Dict k = datadict[&#39;key1&#39;] # 87558 iterations/seconds k = datadict[(&#39;key&#39;, 2)] # 49338 iterations/seconds datadict[&#39;key1&#39;] = 200 # 86744 iterations/seconds datadict[&#39;key1&#39;] += 3 # 41409 iterations/seconds datadict[&#39;key1&#39;] *= 1 # 40927 iterations/seconds datadict[(&#39;key&#39;, 2)] = &#39;value2&#39; # 31460 iterations/seconds (memory allocation performance is planned to be improved) datadict[(&#39;key&#39;, 2)] = datadict[(&#39;key&#39;, 2)] + &#39;d&#39; # 18_972 iterations/seconds (memory allocation performance is planned to be improved) datadict[(&#39;key&#39;, 2)] = &#39;value2&#39; # 10941 iterations/seconds (memory allocation performance is planned to be improved) datadict[(&#39;key&#39;, 2)] += &#39;d&#39; # 16568 iterations/seconds (memory allocation performance is planned to be improved)

An example of non-optimal work with shared data (without using a local variables):

# An example of non-optimal work with object properties (without using local variables) k = sso.companyinfo.income # 20445 iterations/seconds sso.companyinfo.income = 3000000.0 # 13899 iterations/seconds sso.companyinfo.income *= 1.1 # 17272 iterations/seconds sso.companyinfo.income += 500000.0 # 18_376 iterations/seconds # Example of non-optimal usage of numpy.ndarray without a proper local variable datadict[&#39;key3&#39;] += 10 # 6319 iterations/seconds

Notify the sender about the completion of work on the shared object

Reference (and explaining examples line by line)

Code for shared memory Creator side: <pre><code class="lang-python">asharedmemorymanager: ASharedMemoryManager = ASharedMemoryManager(SharedMemory(&#39;sharedmemoryidentifier&#39;, create=True, size=200 1024*2))

declare creation and initiation of the shared memory instance with a size of 200 MiB.</code></pre>

Code for shared memory Consumer side: <pre><code class="lang-python">asharedmemorymanager: ASharedMemoryManager = ASharedMemoryManager(SharedMemory(&#39;sharedmemoryidentifier&#39;))

declares connection to shared memory instance</code></pre>

On shared memory Creator side: <pre><code class="lang-python">async with asharedmemorymanager as asmm:

creates, initiates shared memory instance and waits for the Consumer creation. Execute it once per run.

On shared memory concumer side: <pre><code class="lang-python">async with asharedmemorymanager as asmm:

waits for the shared memory creation and initiation by the shared memory Creator. Execute it once per run.

<pre><code class="lang-python">asharedmemorycontext_manager: ASharedMemoryContextManager = asmm()

creates shared memory access context manager. Create it once per coroutine. Use in the same coroutine as much as you need it.</code></pre>

<pre><code class="lang-python">async with asharedmemorycontextmanager as sharedmemory:

acquire access to shared memory as soon as possible</code></pre>

<pre><code class="lang-python">async with asharedmemorycontextmanager.ifhasmessages() as sharedmemory:

acquire access to shared memory if message queue is not empty</code></pre>

<pre><code class="lang-python">SharedMemory.size # an actual size of the shared memory</code></pre>

<pre><code class="lang-python">SharedMemory.name # an identifier of the shared memory</code></pre>

<pre><code class="lang-python">objmapped = sharedmemory.value.put_message(obj)

Puts object to the shared memory and create an appropriate message

Returns mapped version of the object if applicable (returns the same object otherwise).

Next types will return same object: None, bool, int, float, str, bytes, bytearray, tuple.</code></pre>

<pre><code class="lang-python">objmapped, sharedobjoffset = sharedmemory.value.putmessage2(obj)

Puts object to the shared memory and create an appropriate message

Returns:

* Mapped version of the object if applicable (returns the same object otherwise).

Next types will return same object: None, bool, int, float, str, bytes, bytearray, tuple.

* An offset to the shared object data structure which holds an appropriate shared object content</code></pre>

<pre><code class="lang-python">hasmessages: bool = sharedmemory.value.has_messages()

main way for checking an internal message queue for an emptiness</code></pre>

<pre><code class="lang-python">objmapped = sharedmemory.value.take_message()

Takes (and removes) the latest message from an internal message queue.

Creates and returns mapped object from an appropriate shared object data structure.

Does not deletes an appropriate shared object data structure.

Returns mapped version of the object if applicable (returns new copy of an object otherwise).

Next types will return new copy of an object: None, bool, int, float, str, bytes, bytearray, tuple.

Will raise NoMessagesInQueueError exception if an internal message queue is empty</code></pre>

<pre><code class="lang-python">objmapped, sharedobjoffset = sharedmemory.value.takemessage2()

Takes (and removes) the latest message from an internal message queue.

Creates and returns mapped object from an appropriate shared object data structure.

Does not deletes an appropriate shared object data structure.

Returns:

* Mapped version of the object if applicable (returns new copy of an object otherwise).

Next types will return new copy of an object: None, bool, int, float, str, bytes, bytearray, tuple.

* An offset to the shared object data structure which holds an appropriate shared object content

Will raise NoMessagesInQueueError exception if an internal message queue is empty</code></pre>

<pre><code class="lang-python">sharedmemory.value.destroyobj(sharedobjoffset)

Destroys the shared object data structure which holds an appropriate shared object content.

Use it in order to free memory used by your shared object.

sharedmemory.value.destroyobject(sharedobjoffset)

<pre><code class="lang-python">sharedobjbuffer: memoryview = sharedmemory.value.getobjbuffer(sharedobj_offset)

Feel free to use this memory for your own needs while an appropriate shared object is still not destroyed.

Next types provides buffer to their shared data: bytes, bytearray, str, numpy.ndarray (buffer of an appropriate shared bytes object mapped by this ndarray), torch.Tensor (buffer of an appropriate shared bytes object mapped by this Tensor)</code></pre>

Useful exceptions

<pre><code class="lang-python">class SharedMemoryError:

Base exception all other exceptions are inherited from it</code></pre>

<pre><code class="lang-python">class FreeMemoryChunkNotFoundError(SharedMemoryError): &quot;&quot;&quot;Indicates that an unpartitioned chunk of free memory of requested size not being found.

Regarding this error, it’s important to adjust the size parameter in the SharedMemory configuration. Trying to estimate memory consumption down to the byte is not practical because it fails to account for the memory overhead required by each entity stored (such as entity type metadata, pointers to child entities, etc.).

When setting the size parameter for SharedMemory, consider using broader units like tens (for embedded systems), hundreds, or thousands of megabytes, rather than precise byte counts. This approach is similar to how you would not precisely calculate the amount of memory needed for a web server hosted externally; you make an educated guess, like assuming that 256 MB might be insufficient but 768 MB could be adequate, and then adjust based on practical testing.

Also, be aware of memory fragmentation, which affects all memory allocation systems, including the OS itself. For example, if you have a SharedMemory pool sized to store exactly ten 64-bit integers, accounting for additional bytes for system information, your total might be around 200 bytes. Initially, after storing the integers, your memory might appear as [&quot;int&quot;, &quot;int&quot;, ..., &quot;int&quot;]. If you delete every second integer, the largest contiguous free memory chunk could be just 10 bytes, despite having 50 bytes free in total. This fragmentation means you cannot store a larger data structure like a 20-byte string which needs contiguous space.

To resolve this, simply increase the size parameter value of SharedMemory. This is akin to how you would manage memory allocation for server hosting or thread stack sizes in software development. &quot;&quot;&quot;</code></pre>

<pre><code class="lang-python">NoMessagesInQueueError

Next calls can raise it if an internal message queue is empty: takemessage(), takemessage2(), readmessage(), readmessage2()</code></pre>

Performance tips

<details> <summary title="Data structures"><kbd> Data structures </kbd></summary>

Data structures

For example instead operating with dict:

<details> <summary title="Example"><kbd> Example </kbd></summary>

Message sender

<pre><code class="lang-python">company_metrics: Dict[str, Any] = { &#39;websites&#39;: [&#39;http://company.com&#39;, &#39;http://company.org&#39;], &#39;avgsalary&#39;: 3000.0, &#39;employees&#39;: 10, &#39;inagood_state&#39;: True, } companymetricsmapped: List = sharedmemory.value.putmessage(company_metrics)</code></pre>

Message receiver

<pre><code class="lang-python">companymetrics: Dict[str, Any] = sharedmemory.value.take_message() k = companymetrics[&#39;employees&#39;] # 87558 iterations/seconds companymetrics[&#39;employees&#39;] = 200 # 86744 iterations/seconds companymetrics[&#39;employees&#39;] += 3 # 41409 iterations/seconds</code></pre>

</details> <br>

or even instead operating with dataclass (classes by default operate faster then dict):

<details> <summary title="Example"><kbd> Example </kbd></summary>

Message sender

<pre><code class="lang-python">@dataclass class CompanyMetrics: income: float employees: int avg_salary: float annual_income: float inagood_state: bool emails: Tuple websites = List[str]

company_metrics: CompanyMetrics = CompanyMetrics( income=1.4, employees: 12, avg_salary: 35.0, annualincome: 30000.0, inagood_state: False, emails: (&#39;sails@company.com&#39;, &#39;support@company.com&#39;), websites = [&#39;http://company.com&#39;, &#39;http://company.org&#39;], ) companymetricsmapped: CompanyMetrics = sharedmemory.value.putmessage(company_metrics)</code></pre>

Message receiver

<pre><code class="lang-python">companymetrics: CompanyMetrics = sharedmemory.value.take_message() k = companymetrics.employees # 850098 iterations/seconds companymetrics.employees = 200 # 207480 iterations/seconds companymetrics.employees += 1 # 152263 iterations/seconds</code></pre>

</details> <br>

it would be more beneficial to operate with a list and appropriate IntEnum indexes:

<details> <summary title="Example"><kbd> Example </kbd></summary>

Message sender:

<pre><code class="lang-python">class CompanyMetrics(IntEnum): income = 0 employees = 1 avg_salary = 2 annual_income = 3 inagood_state = 4 emails = 5 websites = 6

companymetrics: List = intenumdicttolist({ # lists with IntEnum indexes are blazing-fast alternative to dictionaries CompanyMetrics.websites: [&#39;http://company.com&#39;, &#39;http://company.org&#39;], CompanyMetrics.avgsalary: 3000.0, CompanyMetrics.employees: 10, CompanyMetrics.inagood_state: True, }) # Unmentioned fields will be filled with Null values companymetricsmapped: List = sharedmemory.value.putmessage(company_metrics)</code></pre>

Message receiver:

<pre><code class="lang-python">companymetrics: List = sharedmemory.value.take_message() k = companymetrics[CompanyMetrics.avgsalary] # 1535267 iterations/seconds companymetrics[CompanyMetrics.avgsalary] = 5000.0 # 1300_966 iterations/seconds companymetrics[CompanyMetrics.avgsalary] += 1.1 # 299_415 iterations/seconds</code></pre>

</details> <br>

</details>

<details> <summary title="Sets"><kbd> Sets </kbd></summary>

Sets

<pre><code class="lang-python">my_obj: List = [ True, 2, FastLimitedSet({ &#39;Hello &#39;, &#39;World&#39;, 3, }) ] myobjmapped = sharedmemory.value.putmessage(my_obj)</code></pre>

Drawbacks of this approach: only initial set of items will be shared. Changes made to the mapped objects (an added or deleted items) will not be shared and will not be visible by other process.

</details>

<details> <summary title="Dictionaries"><kbd> Dictionaries </kbd></summary>

Dictionaries

<pre><code class="lang-python">my_obj: List = [ True, 2, FastLimitedDict({ 1: &#39;Hello &#39;, &#39;2&#39;: &#39;World&#39;, 3: np.array([1, 2, 3], dtype=np.int32), }) ] myobjmapped = sharedmemory.value.putmessage(my_obj)</code></pre>

Drawbacks of this approach: only initial set of key-values pairs will be shared. Added, updated or deleted key-value pairs will not be shared and such changes will not be visible by other process.

</details>

<details> <summary title="For example"><kbd> For example </kbd></summary>

For example

<pre><code class="lang-python">@dataclass class SomeSharedObject: someprocessingstage_control: bool int_value: int str_value: str data_dict: Dict[Hashable, Any] company_info: CompanyInfo

my_obj: List = [ True, 2, SomeSharedObject( someprocessingstage_control=False, int_value=18, str_value=&#39;Hello, &#39;, data_dict=None, company_info=None, ), ] myobjmapped: List = sharedmemory.value.putmessage(my_obj)

myobjmapped[2].somenewattribute = &#39;Hi!&#39; # this attribute will Not became shared and as result will not became accessible by other process</code></pre>

</details>

<details> <summary title="For example"><kbd> For example </kbd></summary>

For example

<pre><code class="lang-python">@dataclass class SomeSharedObject: someprocessingstage_control: bool int_value: int str_value: str data_dict: Dict[Hashable, Any] company_info: CompanyInfo

my_obj: List = [ True, 2, ForceGeneralObjectInplace(SomeSharedObject( someprocessingstage_control=False, int_value=18, str_value=&#39;Hello, &#39;, data_dict=None, company_info=None, )), ] myobjmapped: List = sharedmemory.value.putmessage(my_obj)

myobjmapped[2].somenewattribute = &#39;Hi!&#39; # this attribute Will became shared and as result Will be seen by process</code></pre>

</details>

How to choose shared memory size

<details> <summary title="How to choose shared memory size"><kbd> How to choose shared memory size </kbd></summary>

When setting the size parameter for SharedMemory, consider using broader units like tens (for embedded systems), hundreds, or thousands of megabytes, rather than precise byte counts. This approach is similar to how you would not precisely calculate the amount of memory needed for a web server hosted externally; you make an educated guess, like assuming that 256 MB might be insufficient but 768 MB could be adequate, and then adjust based on practical testing.

Also, be aware of memory fragmentation, which affects all memory allocation systems, including the OS itself. For example, if you have a SharedMemory pool sized to store exactly ten 64-bit integers, accounting for additional bytes for system information, your total might be around 200 bytes. Initially, after storing the integers, your memory might appear as ["int", "int", ..., "int"]. If you delete every second integer, the largest contiguous free memory chunk could be just 10 bytes, despite having 50 bytes free in total. This fragmentation means you cannot store a larger data structure like a 20-byte string which needs contiguous space.

To resolve this, simply increase the size parameter value of SharedMemory. This is akin to how you would manage memory allocation for server hosting or thread stack sizes in software development.

</details>

Benchmarks

<details> <summary title="System"><kbd> System </kbd></summary>

• CPU: i5-3570@3.40GHz (Ivy Bridge)
• RAM: 32 GBytes, DDR3, dual channel, 655 MHz
• OS: Ubuntu 20.04.6 LTS under WSL2. Windows 10

Throughput GiB/s

<details> <summary title="Benchmarks results"><kbd> Benchmarks results </kbd></summary>

Refference results (sysbench)

<pre><code class="lang-bash">sysbench memory --memory-oper=write run</code></pre>

<pre><code class="lang-">5499.28 MiB/sec</code></pre>

Results

Benchmarks results table

| Approach | sync/async | Throughput GiB/s | |---------------------------------|------------|------------------| | InterProcessPyObjects (sync) | sync | 3.770 | | InterProcessPyObjects + uvloop | async | 3.222 | | InterProcessPyObjects + asyncio | async | 3.079 | | multiprocessing.shared_memory | sync | 2.685 | | uvloop.UnixDomainSockets | async | 0.966 | | asyncio + cengal.Streams | async | 0.942 | | uvloop.Streams | async | 0.922 | | asyncio.Streams | async | 0.784 | | asyncio.UnixDomainSockets | async | 0.708 | | multiprocessing.Queue | sync | 0.669 | | multiprocessing.Pipe | sync | 0.469 |

Benchmark scripts

• InterProcessPyObjects - Sync:

• InterProcessPyObjects - Async (uvloop):

• InterProcessPyObjects - Async (asyncio):

• multiprocessing.shared_memory.py
• uvloop.UnixDomainSockets.py
• asynciowith_cengal.Streams.py
• uvloop.Streams.py
• asyncio.Streams.py
• asyncio.UnixDomainSockets.py
• multiprocessing.Queue.py
• multiprocessing.Pipe.py

Shared Dict Performance

<details> <summary title="Benchmarks results"><kbd> Benchmarks results </kbd></summary>

Competitors:

1. multiprocessing.Manager - dict

Pros:

• Part of the standard library

• dictpythonmultiprocess_dict.py

2. UltraDict

Pros:

• Relatively fast writes
• Fast repetitive reads of an unchanged values
• Has built in inter-process synchronization mechanism

• Relies on pickle on an each change
• Non-dictionary values are read-only from the multiprocessing perspective

• dictthirdpartyultradict.py

3. sharedmemory_dict

Pros:

• At least faster than 'multiprocessing.Manager - dict' solution

• dictthirdpartysharedmemory_dict.py

4. InterProcessPyObjects - IntEnumListStruct

Pros:

• Can use only IntEnum (int) keys
• Fixed size of a size of a provided IntEnum

• dictsharedobjectsintenum_list.py

<pre><code class="lang-python">class CompanyMetrics(IntEnum): income = 0 employees = 1 avg_salary = 2 annual_income = 3 inagood_state = 4 emails = 5 websites = 6

companymetrics: List = intenumdicttolist({ # lists with IntEnum indexes are blazing-fast alternative to dictionaries CompanyMetrics.websites: [&#39;http://company.com&#39;, &#39;http://company.org&#39;], CompanyMetrics.avgsalary: 3000.0, CompanyMetrics.employees: 10, CompanyMetrics.inagood_state: True, }) # Unmentioned fields will be filled with Null values companymetricsmapped: List = sharedmemory.value.putmessage(company_metrics)</code></pre>

Message receiver example:

<pre><code class="lang-python">companymetrics: List = sharedmemory.value.take_message() k = companymetrics[CompanyMetrics.avgsalary] companymetrics[CompanyMetrics.avgsalary] = 5_000.0 companymetrics[CompanyMetrics.avgsalary] += 1.1</code></pre>

5. InterProcessPyObjects - Dataclass

Pros:

• Set of fields is fixed by the set of fields of an original object

• dictsharedobjectsstatic_obj.py

6. InterProcessPyObjects - Dict

Pros:

• Speed optimization implementation are in progress - not released yet

• dictshared_objectsdict.py

Results

Benchmarks results table

| Approach | increments/s | |-------------------------------------------|--------------| | InterProcessPyObjects - IntEnumListStruct | 1189730 | | InterProcessPyObjects - Dataclass | 143091 | | UltraDict | 76214 | | InterProcessPyObjects - Dict | 44285 | | SharedMemoryDict | 42862 | | multiprocessing.Manager - dict | 2751 |

</details>

Todo