/*! \file QueueRuntime.hpp
\brief management of threads for Dissection Matrix
\author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
\date Jun. 20th 2014
\date Jul. 12th 2015
\date Nov. 30th 2016
*/
// This file is part of Dissection
//
// Dissection is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Linking Dissection statically or dynamically with other modules is making
// a combined work based on Disssection. Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Dissection give you
// permission to combine Dissection program with free software programs or
// libraries that are released under the GNU LGPL and with independent modules
// that communicate with Dissection solely through the Dissection-fortran
// interface. You may copy and distribute such a system following the terms of
// the GNU GPL for Dissection and the licenses of the other code concerned,
// provided that you include the source code of that other code when and as
// the GNU GPL requires distribution of source code and provided that you do
// not modify the Dissection-fortran interface.
//
// Note that people who make modified versions of Dissection are not obligated
// to grant this special exception for their modified versions; it is their
// choice whether to do so. The GNU General Public License gives permission to
// release a modified version without this exception; this exception also makes
// it possible to release a modified version which carries forward this
// exception. If you modify the Dissection-fortran interface, this exception
// does not apply to your modified version of Dissection, and you must remove
// this exception when you distribute your modified version.
//
// This exception is an additional permission under section 7 of the GNU
// General Public License, version 3 ("GPLv3")
//
// Dissection is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Dissection. If not, see .
//
#ifndef _QUEUE_RUNTIME_
# define _QUEUE_RUNTIME_
#include "Compiler/OptionLibrary.hpp"
#include "Driver/C_threads_tasks.hpp"
#include "Compiler/elapsed_time.hpp"
#include
#include
#include
#ifdef POSIX_THREADS
#include
#else
#include
#include
#include
#endif
#ifdef POSIX_THREADS
typedef pthread_t QueueRuntime_thread;
typedef pthread_mutex_t QueueRuntime_mutex;
typedef pthread_cond_t QueueRuntime_cond;
#define MUTEX_LOCK(a, b) pthread_mutex_lock(&(a))
#define COND_BROADCAST(b) pthread_cond_broadcast(&(b))
#define MUTEX_UNLOCK(b) pthread_mutex_unlock(&(b))
#define COND_WAIT(a, b, c) pthread_cond_wait(&(b), &(a))
#else
typedef std::thread QueueRuntime_thread;
typedef std::mutex QueueRuntime_mutex;
typedef std::condition_variable QueueRuntime_cond;
#define MUTEX_LOCK(a, b) std::unique_lock(b)((a))
#define COND_BROADCAST(b) (b).notify_all()
#define MUTEX_UNLOCK(b)
#define COND_WAIT(a, b, c) (b).wait((c))
#endif
class QueueRuntime
{
public:
QueueRuntime(int nb_doms, int num_threads, const bool isSym,
const bool verbose, FILE *fp);
~QueueRuntime();
void generate_queue(C_task_seq* &_queue_symb,
list* &_queue_static,
vector* &_queue_dynamic,
list &queue_null,
// list &queue_dummy,
Dissection::Tree* btree,
vector* children,
vector* tasks_SparseSymb,
vector* tasks_SparseNum,
vector* tasks_SparseLocalSchur,
vector* tasks_DFillSym,
vector* tasks_DFullLDLt,
vector* tasks_DTRSMScale,
vector* tasks_DSymmGEMM,
vector** tasks_Dsub,
vector* tasks_deallocLower,
vector* tasks_deallocLocalSchur,
long **nops_queue,
vector > all_fathersIndex,
vector nrow_DFullLDLt,
vector isMergedDTRSM,
vector isDividedDTRSM,
const int level_last);
void write_dependency(FILE *fp);
void exec_symb_fact();
void exec_num_fact(const int called);
void exec_num_fact_debug();
void execute_task_debug(C_task_seq *seq, int pos,
int *permute_block,
int pid);
void exec_fwbw();
void exec_fwbw_seq();
void thread_queue_symb_factorize(const int pid, const int num_threads);
void thread_queue_num_factorize(const int pid, const int num_threads);
void thread_queue_fwbw(const int pid, const int num_threads);
void thread_queue_C_DFULL(const int pid, const int num_thraeds,
C_task_seq *it,
int *permute_block,
const int cnt_cdfull,
const int zone_first_entered,
const int zone_idxn);
void thread_queue_parallel_dynamic(const int pid, const int num_threads,
C_task_seq *it,
int *permute_block,
const int zone_idxn);
void thread_queue_parallel_static(const int pid, const int num_threads,
C_task_seq *it,
int *permute_block,
const int zone_idxp,
const int zone_idxn,
const int zone_first_entered,
const int zone_last_entered);
void thread_queue_single(const int pid, const int num_threads,
C_task_seq *it,
int *permute_block,
const int zone_idxn);
int execute_task_dynamic_buffer(int *permute_block,
int pid,
QueueRuntime_mutex &mutex_depenency);
void execute_task(C_task_seq *seq, int pos,
int *permute_block,
int pid,
QueueRuntime_mutex &mutex_depenency);
void execute_task(C_task_seq *seq, int pos,
int *permute_block,
int pid);
int check_parents_done(C_task *it,
QueueRuntime_mutex &mutex_depenency);
int check_parents_done(C_task *it);
void set_queue_fwbw(C_task_seq* &queue_fwbw)
{
_queue_fwbw = queue_fwbw;
}
QueueRuntime(const QueueRuntime &s) { } // copy constrcutor : dummy
private:
int _nb_doms;
int _num_threads;
C_task_seq* _queue_symb;
C_task_seq* _queue_fwbw;
list *_queue_static;
vector *_queue_dynamic;
// list* _queue_dummy;
QueueRuntime_mutex _mutex_root;
QueueRuntime_mutex _mutex_dependency;
QueueRuntime_mutex *_mutex_group;
QueueRuntime_mutex _mutex_debug;
QueueRuntime_mutex _mutex_file;
QueueRuntime_cond _cond_root;
int *_zone_entered;
int *_zone_finished;
int ***_group_entered;
int ***_group_finished;
int ***_group_task_ends;
int ***_group_static_assigned;
int *_group_task_id;
int *_zone_static_assigned;
int **_begins;
int **_ends;
int ***_begins_group;
int ***_ends_group;
long **_group_nops;
unsigned char _waiting_root; // num. of threads should be less than 255
int _phase_dynamic;
int _queue_dynamic_pos_start;
int _queue_dynamic_pos;
int _queue_dynamic_notcopied;
//
// ofstream _fout;
// forward-backward substitutions
bool _verbose;
FILE *_fp;
bool _isSym;
}; // End class DissictionQueue
struct THREAD_QUEUE_EXEC {
int id;
int num_threads;
QueueRuntime* dissectionRuntime;
THREAD_QUEUE_EXEC(int id_,
int num_threads_,
QueueRuntime* dissectionRuntime_) :
id(id_),
num_threads(num_threads_),
dissectionRuntime(dissectionRuntime_) {}
};
void copytask_list2seq(list &queue_static,
list queue_lists,
list &queue_null,
string task_name,
int task_id,
int mutex_id,
int parallel_single,
int num_threads,
int level,
int phase);
void task_assign_diag1(list * &queue_static,
vector* &tasks_queue,
list &queue_null,
// list &queue_dummy,
vector &nrow_DFullLDLt,
vector &isMergedDTRSM,
string queue_symbol,
int queue_id,
int level_id,
int num_threads,
int level_last,
int level,
int begdom,
int enddom,
long *nops_sum,
vector starts,
list* &queue_lists,
bool queue_lists_clear,
Dissection::Tree* btree,
vector* children);
void task_assign_diag2(list *&queue_static,
vector* &tasks_queue,
vector &queue_null,
// vector &queue_dummy,
vector &isMergedDTRSM,
string queue_symbol,
int queue_id,
int level_id,
int num_threads,
int level_last,
int level,
int begdom,
int enddom,
long *nops_sum,
vector starts,
vector starts_sub,
list* &queue_lists,
bool queue_lists_clear,
Dissection::Tree* btree,
vector* children);
void allocate_int2d(int **&array, const int num_threads);
void allocate_unsigned2d(long **&array, const int num_threads);
void allocate_int3d(int ***&array, const int num_threads);
void deallocate_int2d(int **&array);
void deallocate_unsigned2d(long **&array);
void deallocate_int3d(int ***&array);
void *thread_queue_num_factorize_(void *arg);
void *thread_queue_symb_factorize_(void *arg);
void *thread_queue_fwbw_(void *arg);
#endif