qore_thread.h

Go to the documentation of this file.

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    qore_thread.h
 
    POSIX thread library for Qore
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2020 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
 
    Note that the Qore library is released under a choice of three open-source
    licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
    information.
*/
 
#ifndef _QORE_QORE_THREAD_H
#define _QORE_QORE_THREAD_H
 
#include <cstdio>
#include <pthread.h>
 
#include <functional>
 
class QoreProgram;
class AbstractQoreZoneInfo;
class ThreadCleanupNode;
class AbstractThreadResource;
 
typedef void (*qtdest_t)(void *);
 
typedef void (*qtrdest_t)(void *, ExceptionSink *);
 
typedef void (*q_thread_t)(ExceptionSink* xsink, void* arg);
 
 
DLLEXPORT bool is_valid_qore_thread();
 
DLLEXPORT int gettid() noexcept;
 
 
DLLEXPORT int q_gettid() noexcept;
 
DLLEXPORT QoreProgram* getProgram();
 
DLLEXPORT const AbstractQoreZoneInfo* currentTZ();
 
 
DLLEXPORT void set_thread_resource(AbstractThreadResource* atr);
 
 
DLLEXPORT int remove_thread_resource(AbstractThreadResource* atr);
 
 
DLLEXPORT bool check_thread_resource(AbstractThreadResource* atr);
 
 
DLLEXPORT void set_thread_resource(const ResolvedCallReferenceNode* rcr, const QoreValue arg);
 
 
DLLEXPORT int remove_thread_resource(const ResolvedCallReferenceNode* rcr, ExceptionSink* xsink);
 
#if 0
 
DLLEXPORT void set_thread_resource_id(q_trid_t trid, AbstractThreadResource *atr);
 
 
DLLEXPORT int remove_thread_resource_id(q_trid_t trid);
 
 
DLLEXPORT bool check_thread_resource_id(q_trid_t trid);
#endif
 
DLLEXPORT q_trid_t qore_get_trid();
 
 
class ThreadCleanupList {
private:
   static ThreadCleanupNode *head;
 
public:
   DLLLOCAL ThreadCleanupList();
   DLLLOCAL ~ThreadCleanupList();
   DLLLOCAL void exec();
 
 
   DLLEXPORT void push(qtdest_t func, void *arg);
 
 
   DLLEXPORT void pop(bool exec = true);
};
 
DLLEXPORT extern ThreadCleanupList tclist;
 
#define QFT_OK          0  
#define QFT_ERROR      -1  
#define QFT_REGISTERED -2  
 
 
 
DLLEXPORT int q_register_foreign_thread();
 
 
DLLEXPORT int q_deregister_foreign_thread();
 
 
DLLEXPORT int q_reserve_foreign_thread_id();
 
 
DLLEXPORT int q_release_reserved_foreign_thread_id(int tid);
 
 
DLLEXPORT int q_register_reserved_foreign_thread(int tid);
 
 
DLLEXPORT int q_deregister_reserved_foreign_thread();
 
 
int q_start_thread(ExceptionSink* xsink, q_thread_t f, void* arg = nullptr);
 
 
class QoreForeignThreadHelper {
private:
   DLLLOCAL QoreForeignThreadHelper& operator=(const QoreForeignThreadHelper&);
   DLLLOCAL QoreForeignThreadHelper(const QoreForeignThreadHelper&);
   DLLLOCAL void* operator new(size_t);
 
protected:
   class qore_foreign_thread_priv* priv;
 
public:
   DLLEXPORT QoreForeignThreadHelper();
 
   DLLEXPORT explicit QoreForeignThreadHelper(int tid);
 
   DLLEXPORT ~QoreForeignThreadHelper();
};
 
typedef std::function<void(void*)> q_thread_local_destructor;
 
 
hashdecl q_user_tld {
    void* data;
    q_thread_local_destructor destructor;
 
    DLLLOCAL q_user_tld(void* data, q_thread_local_destructor destructor);
    DLLLOCAL q_user_tld(q_user_tld&& old) = default;
    DLLLOCAL q_user_tld(const q_user_tld& old) = default;
    DLLLOCAL q_user_tld& operator=(const q_user_tld& other) = default;
};
 
 
DLLEXPORT int q_get_unique_thread_local_data_key();
 
 
DLLEXPORT void q_save_thread_local_data(int key, void* data, q_thread_local_destructor destructor = nullptr);
 
 
DLLEXPORT void* q_swap_thread_local_data(int key, void* new_data, q_thread_local_destructor destructor = nullptr, bool run_destructor = true);
 
 
DLLEXPORT void* q_get_thread_local_data(int key);
 
 
DLLEXPORT q_user_tld* q_get_thread_local_data_all(int key);
 
 
DLLEXPORT int q_remove_thread_local_data(int key, q_user_tld& data, bool run_destructor = true);
 
#endif  // ifndef _QORE_THREAD_H