TaskProgressManager.cpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program 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 2 of the License, or (at
 * your option) any later version.
 * 
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include<ImLib3D/TaskProgressManager.hpp>
#include<ImLib3D/ImLib3D.hpp>
#include<ImLib3D/ImageProgress.hpp>
#include<unistd.h>
void ttprintf(const char *fmt, ...);

TaskProgressManager *defaultTaskProgressManager=NULL;

void 
TaskProgressManager::Report(int taskNum)
{
    // check if we use standard report , or user defined report
    if(alternateReportManager){alternateReportManager->Report(tasks);return;}

    double time=DTime(refTime);
    string report;
    for(int i=0;i<=taskNum;i++)
    {report+=tasks[i]->name+":"+tasks[i]->ProgressLabel()+(i<taskNum ? "," : "");}
    report+=" ";
    if(taskNum<(int)tasks.size()-1)
    {
        report+="(";
        for(uint i=taskNum+1;i<tasks.size();i++){report+=tasks[i]->name+(i<tasks.size()-1 ? "," : "");}
        report+=")";
    }
    ttprintf("%s\r",report.c_str());
    dirtyLine=report.size();
    fflush(stdout);
    for(int i=0;i<taskNum;i++)
    {
        tasks[i]->lastReport=time;
    }
}
void 
TaskProgressManager::CleanLine()
{
    static string blanks="                                                           ";
    if(dirtyLine)
    {
        printf("%s\r",blanks.substr(0,min((int)blanks.size(),dirtyLine)).c_str());
        dirtyLine=0;
    }
}
void 
TaskProgressManager::Lock()
{
#ifdef   HAVE_LIBPTHREAD
    pthread_mutex_lock   (&mutex);
#endif// HAVE_LIBPTHREAD
}
void 
TaskProgressManager::UnLock()
{
#ifdef   HAVE_LIBPTHREAD
    pthread_mutex_unlock (&mutex);
#endif// HAVE_LIBPTHREAD
}

void 
TaskProgressManager::CheckTasks()
{
    Lock();
    double time=DTime(refTime);
    for(int i=(int)tasks.size()-1;i>=0;i--)
    {
        if((time-tasks[i]->lastReport)>reportDelay)
        {
            Report(i);
        }
    }
    UnLock();
}
void  
TaskProgressManager::NewTask(Task *task)
{
    Lock();
//  printf("NewTask:%x\n",(uint)task);
    tasks.push_back(task);
    task->refTime=refTime;
    task->startTime=DTime(refTime);
    task->lastReport=task->startTime;
    UnLock();
}
void 
TaskProgressManager::EndTask(const Task *task)
{
    Lock();
    if(find(tasks.begin(),tasks.end(),task)==tasks.end())
    {ttprintf("TaskProgressManager::EndTask: Bad task id:%x!!\n",(uint)task);}
    else
    {
        if(reportTotalTime)
        {
            //FIXME (cleanup, this is just for use with xdu...)
            mprintf("\n%d task-over:",(int)rint(1000*(DTime(refTime)-task->startTime)));
            for(uint i=0;i<tasks.size();i++)
            {
                string nospaces=tasks[i]->name;
                Replace(nospaces," ","_");
                mprintf("%s-%d",nospaces,tasks[i]->id);
                if(i!=tasks.size()-1){mprintf("/");}
            }
            if(task!=tasks[tasks.size()-1]){mprintf("NOTLAST??");}
            printf("\n");
        }
        tasks.erase(find(tasks.begin(),tasks.end(),task),tasks.end());
    }
//  ttprintf("EndTask: tasks remaining:%d\n",tasks.size());
    UnLock();
}

void 
TaskProgressManager::Run()// never should exit
{
    while(running)
    {
        CheckTasks();
//          struct timespec delay;
//          delay.tv_sec = (int)sampleDelay;
//          delay.tv_nsec = (sampleDelay-(int)sampleDelay)*1000000000L;
//          pthread_delay_np( &delay );

        usleep((int)(1000000*sampleDelay));
    }
#ifdef HAVE_LIBPTHREAD
    pthread_exit(0);
#endif// HAVE_LIBPTHREAD
}
void *
TaskProgressManager::EntryPoint(void *arg)
{
//  mprintf("TaskProgressManager(pid:%d): monitoring thread started\n",getpid());
    TaskProgressManager *tpm=(TaskProgressManager *)arg;
    tpm->Run();
    return NULL;
}
void 
TaskProgressManager::Stop()
{
    running=false;
}

void TaskProgressManager::Start()
{
#ifdef HAVE_LIBPTHREAD
    running=true;
    pthread_create (&thread, NULL,&TaskProgressManager::EntryPoint,(void *)this);
#endif// HAVE_LIBPTHREAD
}
TaskProgressManager::TaskProgressManager(double sampleDelay,double reportDelay):
    sampleDelay(sampleDelay),
    reportDelay(reportDelay),
    running(false),
    dirtyLine(0),
    alternateReportManager(NULL),
    reportTotalTime(false)
{
#ifdef HAVE_LIBPTHREAD
    pthread_mutex_t init=PTHREAD_MUTEX_INITIALIZER;
    mutex=init;
#endif// HAVE_LIBPTHREAD
    refTime=DTime();
}
TaskProgressManager::~TaskProgressManager()
{
    ;
}

int TaskInProgress::idcount=0;

TaskInProgress::TaskInProgress(const string &_name,TaskProgressManager *_manager):
    id(idcount++),
    name(_name)
{
    manager=_manager;
    manager->NewTask(this);
}
void 
TaskInProgress::AutoKill()
{
//  ttprintf("autokill %x\n",(uint)this);
    manager->EndTask(this);
}


//  int
//  main(int argc,char **argv)
//  {
//      TaskProgressManager progress(1,3);
//      g_progress=&progress;
//      ttprintf("start:\n");
//      progress.Start();
//      {
//          int i=0;
//          TaskTracker<int> task("toto",0,4,&i,progress);
//          ttprintf("entering main loop:\n");      
//          for(i=0;i<4;i++)
//          {
//              usleep(6000000);
//              ttprintf("making2...:\n");      
//              TaskInProgress task2("task2",progress);
//              usleep(6000000);
//          }
//      }
//  }
void 
ttprintf(const char *fmt, ...)
{
    va_list args;
    va_start(args,fmt);
    if(imLib3D.taskProgressManager){imLib3D.taskProgressManager->CleanLine();}
    vprintf(fmt,args);
}

---