Is there a more efficient way to write values to nodes?

[xydan83]

Hello everyone!
If there is a more efficient and faster way to write multiple values to nodes, in addition to this option, as shown below?

for node_data_change in list_of_nodes_data_changes:
  some_node = self._opc_ua_server.get_node(node_data_change.node_id)
  await some_node.write_value(node_data_change.new_variant_val)

For example, this method of recording 20,000 values in a cycle can reach 1-2 seconds (also depends on the speed of the hardware), which is very long.
Maybe there are some better methods on the server side? (I haven't found yet)

[swamper123]

Had you take a look here?

opcua-asyncio/asyncua/client/client.py

Line 719 in a17138c

async def write_values(self, nodes, values):

Depending on how you stored stuff, you may be insipirated. ^^

[swamper123]

await asyncio.gather(*map(server.write_value, nodeid_iteration, dataval_iteration)) could be a way. Not sure if it would be faster than normal looping, but there might be a faster execution....you are right, that everything would be still on one thread (you might have to take a look on subprocessing or similar if you want to use more cores), but concurrency is ... concurrent.

In the loop solution, you would wait every time, until the future is done. Then you make the next request.
Not sure how gather works under the hood, but I could imagine, that it would create multiple tasks at once.

EDIT: Still you have to choose between checking or not checking.

[xydan83]

uh, I'm afraid subprocesses, in addition to problems with locks, will also introduce additional costs of interprocess exchange, although of course this is an option, but I think it will be necessary to somehow lock nodes when writing / reading.

[xydan83]

Passed the test, it looks good.

write_value (node_new_data_variant)

The process of updating 20,000 nodes to the address space took: 0: 00: 00.417552
The process of updating 20,000 nodes to the address space took: 0: 00: 00.415239
The process of updating 20,000 nodes to the address space took: 0: 00: 00.426948
The process of updating 20,000 nodes to the address space took: 0: 00: 00.426581
The process of updating 20,000 nodes to the address space took: 0: 00: 00.427012
The process of updating 20,000 nodes to the address space took: 0: 00: 00.422074
The process of updating 20,000 nodes to the address space took: 0: 00: 00.426228
The process of updating 20,000 nodes to the address space took: 0: 00: 00.417854
The process of updating 20,000 nodes to the address space took: 0: 00: 00.424484

write_attribute_value (node_id, value_to_datavalue (node_new_data_variant, None), attr = ua.AttributeIds.Value)`

The process of updating 20,000 nodes to the address space took: 0: 00: 00.170988
The process of updating 20,000 nodes to the address space took: 0: 00: 00.169890
The process of updating 20,000 nodes to the address space took: 0: 00: 00.170055
The process of updating 20,000 nodes to the address space took: 0: 00: 00.168897
The process of updating 20,000 nodes to the address space took: 0: 00: 00.173403
The process of updating 20,000 nodes to the address space took: 0: 00: 00.166813
The process of updating 20,000 nodes to the address space took: 0: 00: 00.167956

How much critical checks do I miss?

[oroulet]

As long as you writ a DataValue with correct types, everything is fine

[oroulet]

Subprocess will not help anything. Writting on sever side is just about writting to a dict and a few checks.

[oroulet]

I do not think you can do more efficient than using write_attribute_value().
using map is maybe a good idea for many nodes... not sure...
if you have many nodes to write, the python loop is slow, but anyway we are using some python code underneath, so using map will be as slow anyway