Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.clipper.visual-objects > #13405

Re: CreateThread vs. CreateVOThread

From Jamal <nospam@example.com>
Newsgroups comp.lang.clipper.visual-objects
Subject Re: CreateThread vs. CreateVOThread
Date 2021-08-03 12:05 -0400
Organization Aioe.org NNTP Server
Message-ID <sebpfl$vn7$1@gioia.aioe.org> (permalink)
References <29915aac-da35-4455-b403-c1fec00692e3n@googlegroups.com>

Show all headers | View raw


According to the docs the CreateThread() and CreateVOThread() are the same:
However, "CreateVOThread() also performs some additional initializations 
in the kernel runtime."

But it does not say what those initializations! But I guess it has to do 
with the GC suspension during its processing.

Additionally, the docs say (Just in case you did not see it and for others):

CreateVOThread() and ExitVOThread()

"First of all, threads in a Visual Objects application should not be 
created by calling the Windows API function CreateThread() directly, but 
by calling the Visual Objects runtime function CreateVOThread(). This 
function is called exactly like CreateThread() and actually it calls 
CreateThread() internally. CreateVOThread() also performs some 
additional initializations in the kernel runtime.

Similar to CreateVOThread() there is an ExitVOThread() function that 
should be called instead of ExitThread(). However, try to avoid exiting 
a thread in a Visual Objects application by calling ExitThread() at all. 
Instead, exit your threads by returning from the thread entry point 
function."

And the docs go on further:

"When multiple threads are running, each dynamic memory pointer becomes 
a shared resource. One thread might load a pointer to a string into a 
register. (The GC can only update memory locations, not registers.) 
Before actually performing an operation with that pointer, execution is 
transferred to another thread that triggers the GC. Now the string 
referred to by the register in the first thread is moved, and when 
execution returns to the first thread, the pointer in the register is 
not valid anymore."



"The problem described above will be resolved in a future release of 
Visual Objects, but right now the programmer has to be aware of it."

(I don't think this was ever resolved, and I guess will never be)


"There are two ways of avoiding problems with threads and dynamic data. 
The first solution is to disable garbage collection when more than one 
thread is active and enabling it only again after all threads but one 
finish. This can be done through the Visual Objects runtime functions 
DynLock() and DynUnlock(). The disadvantage of this approach is that no 
more memory will be freed or reused while the DynLock() is active. 
Depending on the application logic, memory consumption might increase 
rapidly. Even when the collector runs again, the dynamic memory pool 
will stay at the maximum size for future reuse. You might reduce the 
size of the dynamic memory pool manually by calling DynShrink().

Disabling the collector globally while a thread is running, is a good 
solution when threads only run for a short while and do not generate a 
lot of dynamic data garbage. Indexing a database produces a lot of 
dynamic data garbage, so that indexing in a thread is not recommended 
for bigger databases.

To avoid the collector problem, the solution is not to use dynamic data 
at all inside a thread. Another solution is to minimize the use of 
dynamic data to very few places, so that DynLock() and DynUnlock() can 
be used locally. The Web server that will be presented later is a good 
example for this technique."


On 8/3/2021 6:56 AM, Robert Pope wrote:
> Hi All.
> 
> I'm wondering if anyone knows what the differences between Win32 API CreateThread() vs. VO's CreateVOThread() are? Mostly with relation to the garbage collector. I.e. if I use Win32 API's CreateThread() would I completely avoid the garbage collector running on my thread. Is there a reason why I would still be better off using CreateVOThread()?
> 
> I understand that threads and dynamic memory  / the garbage collector don't play well together. I have in my ThreadFunc avoided declaring any LOCAL's and avoided calling any VO functions (because they might also have LOCAL's). There are also no anonymous variables like a string concatenation. Where I can't avoid a variable I use a structure (ThreadData) in static memory. The thread is the only reader/writer to this structure.
> 
> Assuming I haven't missed anything, my thread is only working in static memory and only calling Windows API functions.
> 
> The thread itself is pretty simple. It calls Win32 API IsHungAppWindow() once per second and logs an event in the windows event log if that function returns true.
> 
> I'm not sure how much I trust VO's threading (or my code not to have missed some dynamic memory allocation somewhere) so I've also included runtime options to completely disable this feature if it plays up.
> 
> Cheers!
> Rob.
> 

Back to comp.lang.clipper.visual-objects | Previous | Next — Previous in thread | Next in thread | Find similar | Unroll thread


Thread

CreateThread vs. CreateVOThread Robert Pope <cooeee@gmail.com> - 2021-08-03 03:56 -0700
  Re: CreateThread vs. CreateVOThread Jamal <nospam@example.com> - 2021-08-03 12:05 -0400
    Re: CreateThread vs. CreateVOThread Robert Pope <cooeee@gmail.com> - 2021-08-03 10:07 -0700
      Re: CreateThread vs. CreateVOThread Jamal <nospam@example.com> - 2021-08-03 18:02 -0400
      Re: CreateThread vs. CreateVOThread dlzc <dlzc1@cox.net> - 2021-08-04 07:32 -0700
      Re: CreateThread vs. CreateVOThread "Wolfgang Riedmann" <wriedmann@gmail.com> - 2021-08-04 17:07 +0200
        Re: CreateThread vs. CreateVOThread Robert Pope <cooeee@gmail.com> - 2021-08-04 10:18 -0700
          Re: CreateThread vs. CreateVOThread "Wolfgang Riedmann" <wriedmann@gmail.com> - 2021-08-05 11:47 +0200

csiph-web