size_t Scheduler::add_timer(uint64 timeout,
Timer_Proc proc,
void* arg)
{
Auto_Mutex auto_lock(_lock);
// Create new timer:
Timer* timer = new Timer;
timer->id = _id_pool.get();
timer->deadline = Time::now() + timeout;
timer->proc = proc;
timer->arg = arg;
// Insert timer into list:
_insert_timer(_list, timer);
if (_auto_dispatch && !_dispatcher_thread_running)
start_dispatcher();
return timer->id;
}
PROXY_API __bool PMC_API init_proxy(HWND hWnd, __uint flags)
{
char * szWarning = "没有找到软件狗，进入演示状态，数据库最大规模32点";
if(!_g_InitLock){
_g_InitLock = new CLock;
}
g_InitLock.Lock();
if(g_iInitCount){
g_iInitCount++;
g_InitLock.UnLock();
return __true;
}
g_iInitCount++;
g_iInitFlag = flags;
_load_settings(__false);
g_DBDispatchTable.OnAddNode = _on_add_node;
g_DBDispatchTable.OnDropNode = _on_del_node;
hook_rtdb_events(&g_DBDispatchTable);
if(!(g_iInitFlag & PROXY_INIT_AS_SERVER)){
unsigned char run, dev;
int runLevel, devLevel;
init_key();
get_key(&run, &runLevel, &dev, &devLevel);
if(!dev){
/* no dog is attached*/
/* create_group(0x12345678,xxx) is a loophole */
create_group((RTK_CURSOR)0x12345678, (PRTK_GROUP)32);
if(!(flags & PROXY_SILENT)){
MessageBox(
hWnd,
szWarning,
"PMC Error",
MB_OK
);
}
}else{
/* yes, dog is attached, set database limit */
create_group((RTK_CURSOR)0x12345678, (PRTK_GROUP)devLevel);
}
}
init_powermgr();
init_network(0);
init_rtdb();
connect_vbus(BUSID_RTDB, 0, _on_rtdb, default_client_filter);
connect_vbus(BUSID_CONFIG, 0, _on_config, default_client_filter);
connect_vbus(BUSID_ALARM, 0, _on_alarm, default_client_filter);
connect_vbus(BUSID_SYSTEM, 0, _on_system, default_client_filter);
connect_vbus(BUSID_OPERATION, 0, 0, default_client_filter);
if(flags & PROXY_ENABLE_DISPATCHER){
start_dispatcher();
}
g_Worker = new CProxyWorker(flags);
if(!g_Worker){
g_InitLock.UnLock();
return __false;
}
g_Worker->start();
#if defined(_WIN32) && 1
SetThreadPriority(g_Worker->handle(), THREAD_PRIORITY_BELOW_NORMAL);
#endif
g_InitLock.UnLock();
return __true;
}
int start_simulation(void)
{
cl_device_id *dev;
cl_uint devc;
cl_context context;
cl_command_queue *cmd_queue;
cl_mem src, dst, wdth, hght, *offy;
cl_int err;
cl_kernel kern;
cl_program prog;
cl_platform_id pform;
size_t rows, columns, runs, print_each = 0, offsetx, offsety, *y, swapoffy;
int gui_enabled, platform, device;
unsigned int *buff0;
unsigned int i;
struct dispatcher_context *c;
int random;
char fname[1024];
cl_uint cqc;
#if 1
do
{
printf("Width: ");
scanf(SZTF, &columns);
if (columns % 32)
{
printf("Width must be a multiple of 32\n");
continue;
}
if (columns == 0)
{
printf("Width must be > 0\n");
continue;
}
break;
}
while (true);
do
{
printf("Height: ");
scanf(SZTF, &rows);
if (rows == 0)
{
printf("Width must be > 0\n");
continue;
}
break;
}
while (true);
printf("Runs: ");
scanf(SZTF, &runs);
printf("Random? ");
scanf("%d", &random);
if (!random)
{
printf("File name: ");
scanf("%s", fname);
printf("Offset X: ");
scanf(SZTF, &offsetx);
printf("Offset Y: ");
scanf(SZTF, &offsety);
}
printf("GUI? ");
scanf("%d", &gui_enabled);
if (!gui_enabled)
{
printf("Print after run: ");
scanf(SZTF, &print_each);
}
printf("Platform index: ");
scanf("%d", &platform);
printf("Device index (-1 for all): ");
scanf("%d", &device);
do
{
printf("Swap offset: ");
scanf(SZTF, &swapoffy);
if (swapoffy == 0) swapoffy = rows;
if (rows % swapoffy != 0)
{
printf("Swap offset must be a factor of the row count\n");
continue;
}
break;
}
while (true);
#else
columns = 512;
rows = 512;
runs = 1000;
gui_enabled = 1;
print_each = 0;
random = 1;
offsetx = 0;
offsety = 0;
platform = 0;
device = 0;
swapoffy = rows;
#endif
err = get_devices(&dev, &devc, &pform, platform, device);
if (err)
return err;
err = initialize_context_cmd_queue(dev, devc, pform, &context, &cmd_queue, &cqc);
if (err)
return err;
err = load_kernel(context, dev, devc, &prog, &kern);
if (err)
return err;
buff0 = (unsigned int*)malloc(rows * (columns / 8));
if (!buff0)
return -1;
if (random)
{
srand((unsigned int)time(NULL));
for (i = 0; i < (rows * (columns / 8)) / 4; i++)
{
buff0[i] = rand() | (rand() << 16);
}
}
else
{
memset(buff0, 0, rows * (columns / 8));
if (!load_file_to_buffer(buff0, fname, offsetx, offsety, columns, rows))
return -1;
}
err = compute_buffer_sizes(context, cmd_queue, cqc, kern, columns, rows, swapoffy, &y);
if (err)
return err;
err = create_buffers(context, swapoffy * (columns / 8), columns,
swapoffy, &src, &dst, &wdth, &hght, &offy, y, buff0, devc);
if (err)
return err;
if (gui_enabled)
{
if (!initialize_window())
return -1;
}
c = (struct dispatcher_context *)malloc(sizeof(*c));
if (!c)
return -1;
c->cmd_queue = cmd_queue;
c->cqc = cqc;
c->kern = kern;
c->columns = columns;
c->rows = rows;
c->print_each = print_each;
c->runs = runs;
c->gui_enabled = gui_enabled;
c->buff0 = buff0;
c->src = src;
c->dst = dst;
c->wdth = wdth;
c->hght = hght;
c->offy = offy;
c->y = y;
c->swapoffy = swapoffy;
c->context = context;
c->win_height = rows;
return start_dispatcher(c);
}
/*Questo è il main del processo principale, WATOR.
* 1- Controllo di esistenza file
* 2- Predispone i thread per la gestione corretta dei segnali
* 3- Avvia i thread
* 4- Aspetta che terminano il lavoro
* */
int main (int argc, char *argv[]) {
int n_tentativo;
wat_proc_conf* x;
/*Inizializzazione*/
root_thread = pthread_self();
/*Inizializza variabili globali di gestione dei segnali*/
close_all = 0;
sig_sigusr1 = 0;
puoi_stampare = 0;
count_worker = 0;
puoi_procedere = 1;
n_tentativo = 0;
pthread_mutex_init(&set_critica, NULL);
pthread_mutex_init(&set_skip, NULL);
pthread_mutex_init(&lista_mux, NULL);
pthread_mutex_init(&stampa_mux, NULL);
pthread_cond_init(&lista_vuota, NULL);
pthread_cond_init(&stanno_lavorando, NULL);
pthread_cond_init(&stampa_pronta, NULL);
pthread_cond_init(&stampa_effettuata, NULL);
if ( mkdir("./tmp", S_IRWXU) ) {
if(errno != EEXIST)
perror("Errore Creazione Directory");
}
/*Rimuovo la socket se esiste, cioè se una precedente esecuzione è stata terminata male*/
system("rm -f ./tmp/*");
if( file_exist(SOCKNAME) ) {
printf("Il file socket vecchio esiste ancora\n");
if( remove(SOCKNAME) ) {
perror("Non è stato possibile cancellare la vecchia socket");
return 1;
}
}
/*Gestione dei segnali
* Vengono mascherati i segnali tipici di questo programma, cioè
* SIGINT, SIGTERM e SIGUSR1
* L'idea è quella di mascherare i segnali a tutti i thread tranne che
* al gestore dei segnali, che si preoccuperà di gestire tutto.
*/
sa.sa_handler=SIG_IGN;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGINT);
sigaddset(&sa.sa_mask, SIGUSR2);
sigaddset(&sa.sa_mask, SIGTERM);
sigaddset(&sa.sa_mask, SIGUSR1);
/*Applico maschera a questo thread. La maschera poi viene ereditata dai figli*/
pthread_sigmask(SIG_BLOCK, &sa.sa_mask, NULL);
/*Fine Gestione dei segnali*/
/*Carico gli argomenti passati al programma*/
x = valutazione_argomenti(argc, argv, NWORK_DEF, CHRON_DEF);
if(x == NULL) {
return 1;
}
/*Carico il nuovo pianeta*/
if(!file_exist(x->file)) {
errno = ENOENT;
perror("File planet");
return 1;
}
simulazione = new_wator(x->file);
if(simulazione == NULL) {
perror("Errore creazione nuova simulazione");
return 1;
}
/*Se non sono stati passati argomenti, assegno quelli di default*/
if( ( simulazione -> nwork = x->nwork ) == 0)
simulazione -> nwork = NWORK_DEF;
if( ( simulazione -> chronon = x->chron ) == 0)
simulazione -> chronon = CHRON_DEF;
if( x->dumpfile == NULL ) {
strcpy(dumpfile,"stdout");
}
else {
strcpy(dumpfile,x->dumpfile);
}
intervallo_di_stampa = (x->chron) ? x->chron : CHRON_DEF;
free(x->file);
free(x->dumpfile);
free(x);
/*Creo divisione della matrici per far lavorare i thread, funzione delegata dal dispatcher*/
lista = split_matrice(simulazione->plan);
/*Avvio Gestore Segnali*/
n_tentativo=0;
while( start_gestore_segnali() ) {
if(n_tentativo < MAX_TRY) {
sleep(my_exp2(n_tentativo));
n_tentativo++;
}
else {
perror("Errore creazione Thread Gestore Segnali");
return 1;
}
}
/*Avvio n worker*/
n_tentativo=0;
while ( (worker_thr_ids = start_nworker(simulazione->nwork)) == NULL ) {
if(n_tentativo < MAX_TRY) {
sleep(my_exp2(n_tentativo));
n_tentativo++;
}
else {
perror("Errore creazione Threads NWorker");
return 1;
}
}
/*Avvio visualizer*/
n_tentativo=0;
while ( (visualizer = start_visualizer(dumpfile)) == -1 ) {
if(n_tentativo < MAX_TRY) {
sleep(my_exp2(n_tentativo));
n_tentativo++;
}
else {
perror("Errore Start_Visualizer");
return 1;
}
}
/*Avvio thread collector*/
n_tentativo=0;
while( start_collector() ) {
if(n_tentativo < MAX_TRY) {
sleep(my_exp2(n_tentativo));
n_tentativo++;
}
else {
perror("Errore creazione Thread Collector");
return 1;
}
}
/*Avvio Thread Dispacer */
n_tentativo=0;
while( start_dispatcher() ) {
if(n_tentativo < MAX_TRY) {
sleep(my_exp2(n_tentativo));
n_tentativo++;
}
else {
perror("Errore Creazione Thread Dispatcher");
return 1;
}
}
/*Aspetto che i thread lanciati terminano
*/
pthread_join(gestore_segnali_id, NULL);
pthread_join(dispatcher_id, NULL);
/*Procedura di recupero di collector se dormiva mentre tutti si chiudevano*/
pthread_mutex_lock(&stampa_mux);
puoi_stampare = TRUE;
pthread_cond_broadcast(&stampa_pronta);
pthread_mutex_unlock(&stampa_mux);
pthread_join(collector_id, NULL);
free_wator(simulazione);
free(worker_thr_ids);
if( remove(SOCKNAME) ) {
perror("Non è stato possibile rimuovere il file SOCKNAME");
return 1;
};
pthread_mutex_destroy(&set_critica);
pthread_mutex_destroy(&set_skip);
pthread_mutex_destroy(&lista_mux);
pthread_mutex_destroy(&stampa_mux);
pthread_cond_destroy(&lista_vuota);
pthread_cond_destroy(&stanno_lavorando);
pthread_cond_destroy(&stampa_pronta);
pthread_cond_destroy(&stampa_effettuata);
return 0;
}
