HOWTO thread in PLMK

HOWTO configure and use a thread in the Programming-Language-Micro-Kernel (PLMK).

Date

27 dez 2024 - link with C# and Java dokument.

17 dez 2024 - setup of the initial document

INDEX

• Thread basics
• Thread requirements
• Thread startup
• Thread storage
• Thread pool
• Weak or Strong reference

Thread basics

‍INDEX

See also

https://en.wikipedia.org/wiki/Thread_(computing)

Thread (computing) from wikipedia

Thread requirements

‍INDEX

A thread in Programming-Language-Micro-Kernel (PLMK) is very simple:

1. In PLMK a server-instance always runs in an isolated environment, which means it doesn't matter whether a new process or a separate thread is used.

    !on remote host!                                  !on local host!
   
        server1---------x                     x----------server2
           |            |                     |             |
           |     child-context-1       child-context-2      |
           |            |                     |             |                      server
   parent-context-1-----x                     x-----parent-context-2
           |                                                |
   (MqConfigS::server)                 (example: MqConfigS::server --fork --uds … --file …)
           |                                                |
   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
           |                                                |
        (--tcp)                                  (--pipe, --uds, --tcp)
           |                                                |
   parent-context-1-----x                     x-----parent-context-2
           |            |                     |             |                      client
           |     child-context-1       child-context-2      |
           |            |                     |             |
           x------------x--------client-------x-------------x
   
                             !on local host!
   

   See also

   libmqmsgque - link - api

   libmqmsgque - service - fac

   libmqmsgque - service - api

2. From (1) it follows that a thread never accesses a resource that is outside its environment, which means, for example, that a server-instance never accesses an object from another server-instance.
   • Since server-instance and environment are clearly linked, from now on I will always talk about server-instance.
3. There is a 1:1 relationship between a server-instance and a thread.
   • It is impossible to run two server-instance's on one thread because the data is stored as thread-local-storage and must be clearly identifiable.
4. All data types of a server-instance are in a structure, e.g. MkRuntimeC, which is always defined as thread-local-storage.
5. Every object is firmly linked to its server-instance via MkObjectS::objRt.
6. Transferring an object-pointer from one server-instance to another server-instance is a design flaw.

Thread startup

‍INDEX

A thread in Programming-Language-Micro-Kernel (PLMK) is created via pIoStartServer, whereby all types of instances (pipe, spawn, fork, thread, etc.) can be created in the function.

• The thread itself is finally created by the internal function MqSysServerThread using the value of MqLalS::MqSysServerThreadCB.
• By default, the value of MqLalS::MqSysServerThreadCB is preset to the function sSysServerThread :

  static enum MkErrorE sSysServerThread (
    MK_RT_ARGS
    MQ_CTX const context,
    struct MqSysServerThreadMainS * const argP,
    MK_STRN  name,                
    int thread_status,            
    struct MkIdS * idP    
  ) {
  #if META_HAS_THREAD
    mqthread_t threadId;
   
    // after a "thread" no "fork" is possible
    MqContextCT_X(context)->ignoreFork = true;
   
    # if defined(HAVE_PTHREAD)
   
    #   define check0(cmd,...) if (cmd(__VA_ARGS__)!=0) {MkErrorSetC_1XS("Error in '" #cmd "'");goto error;}
   
      int ret;
   
      // thread attributes
      pthread_attr_t attr;
      check0(pthread_attr_init, &attr);
  /*
        printXV(context,"thread_status<%s>",
          thread_status==PTHREAD_CREATE_DETACHED?"PTHREAD_CREATE_DETACHED":"PTHREAD_CREATE_JOINABLE");
  */
      check0(pthread_attr_setdetachstate, &attr, thread_status);
      check0(pthread_attr_setscope, &attr, PTHREAD_SCOPE_SYSTEM);
   
      // thread setup !before! a thread was created
      if (MqContextCT_X(context)->fThreadInit) (*MqContextCT_X(context)->fThreadInit)(context);
   
      // start thread
      do {
        ret = pthread_create(&threadId,&attr,sSysServerThreadInit,argP);
      } while (ret == EAGAIN);
   
      // cleanup attribute
      check0(pthread_attr_destroy, &attr);
   
      if (unlikely(ret != 0)) {
        MkErrorDbV_1_XS (MK_ERROR_CAN_NOT_START_SERVER, name);
        goto error;
      }
   
    # else    // NOT defined(HAVE_PTHREAD)
   
      if (unlikely ( (threadId = _beginthreadex(NULL, 0, sSysServerThreadInit, argP, 0, NULL)) == 0)) {
        MkErrorDbV_1_XS (MK_ERROR_CAN_NOT_START_SERVER, name);
        MkErrorSysAppend (_beginthreadex, errno);
        goto error;
      }
   
    # endif   // defined(HAVE_PTHREAD)
   
    // save tid
    (*idP).val = (MK_IDNT)threadId;
    (*idP).type = MK_ID_THREAD;
   
    return MK_OK;
   
  error:
    pBufferStreamFree(MK_RT_CALL MkBUS(&argP->argvR));
    #if MqRuntimeC_SysServerThread_size
      argP->isUsed = false;
    #else
      MkSysFreeNonNull(argP);
    #endif
    return MK_ERROR;
  #else     // NOT META_HAS_THREAD
    return MkErrorDbV_1_XS (MK_ERROR_NOT_SUPPORTED, "sSysServerThread");
  #endif    // META_HAS_THREAD
  }

  • The creation of the thread is left to the operating system, which in LINUX is for example a pthread.
• Alternatively the externe function of type MqSysServerThreadF can be assigned to MqLalS::MqSysServerThreadCB (Thread pool) which creates the thread and then has to call MqSysServerThreadMain with the argument argP.

Thread storage

‍INDEX - MkKernel_Storage_C_API - MkRuntimeC_C_API

The primary memory for a multi-threaded application is the thread-local-storage.

• read more at Thread pool.

Thread pool

‍INDEX

The initial implementation of the Programming-Language-Micro-Kernel (PLMK) thread was without thread-pool.

• Starting with C# and Java the thread-pool support was added.

The biggest difference between a single pthread-thread and an already used thread-pool-thread is:

• The pthread-thread has to create and initialize the runtime-local-storage data.
• The thread-pool-thread has only to initialize the runtime-local-storage data.

The biggest difference between a single-threaded application (process) and a multi-threaded application is:

• The memory of a single-threaded application is cleaned up by the operating system at the end of the process.
• The memory of a multi-threaded application must be cleaned up by the programmer at the end of the thread.

The biggest difference between a multi-thread-once and a multi-thread-pool application is:

• When a thread is used once, the thread-local-storage memory is released by the operating system but not the pointer to the heap contained therein.
  • The memory must therefore be cleaned up.
• When a thread is used multiple times, the thread-local-storage memory is not released and is reused.
  • However, the memory must be initialized again.

See also

C# Thread-Pool

JAVA Thread-Pool

Weak or Strong reference

‍INDEX

A weak reference is a reference that is controlled by Target-Programming-Language (TPL), and a strong reference is a reference that is controlled by Programming-Language-Micro-Kernel (PLMK).

The difference lies in the lifetime of the object:

• The weak reference gives Target-Programming-Language (TPL) more leeway for memory management but requires Programming-Language-Micro-Kernel (PLMK) to be able to react to an invalid reference, i.e. possibly recreate the Target-Programming-Language (TPL) object if necessary.
• The strong reference is easier to program because the connection between Programming-Language-Micro-Kernel (PLMK) and Target-Programming-Language (TPL) can never become invalid but forces Target-Programming-Language (TPL) to take over memory management from Programming-Language-Micro-Kernel (PLMK), which ultimately wastes resources.

With the switch to thread pool in C# and Java, the reference-technology was also switched from strong to weak because there is always a memory problem in a multi-threaded application and a language like C# and Java is better equipped with the sophisticated garbage-collection than Programming-Language-Micro-Kernel (PLMK).

See also

C# references

JAVA references