C++ map::put方法代码示例

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void*), void *arg)
{
    init();
    printf("Thread Creation no %d \n",THREAD_COUNT);
    THREAD_COUNT++;

    struct Thread_Arg th_arg;

    th_arg.start_routine=start_routine;
    th_arg.arg=arg;

    int ret = original_pthread_create(thread, attr, closure_wrapper, (void*)&th_arg);

    struct thread_data* new_thread = MALLOC(struct thread_data);
    new_thread->thread_id=*thread;
    new_thread->local_thread_id=THREAD_COUNT;
    new_thread->state=PTHREAD_ACTIVE_THREAD;

    all_thread.put(*thread,new_thread);

    //Set next thread to newly created thread
    //Execute newly created thread instantenously

    next_thread=*thread;

    sched();

    // TODO
    return ret;
}

int pthread_mutex_lock(pthread_mutex_t *mutex) {
    //    init();
    //This is a non deterministic point . Capture non-determinism here
    findnextthreadtoschedule(NULL);

    // Call scheduler and wait for your turn
    sched();

    //I am not worthy of this lock
    while(!mutex_lock_validity(mutex)) {
        findnextthreadtoschedule(pthread_self());
        sched();
    }

    logChoice(all_thread.indexnum(pthread_self()),getActiveThreadNum());
    incrementLevel();

    PRINT("ACQUIRING LOCK %lx \n",mutex);
    lock_map.put(mutex,(pthread_self()));
    return original_pthread_mutex_lock(mutex);
    // TODO
}

void
init(void) {
    if(!initialized) {
        initTracer();
        original_pthread_create=( int(*)(pthread_t*, const pthread_attr_t*, void* (*)(void*), void*) )dlsym(RTLD_NEXT,"pthread_create");
        original_pthread_mutex_lock =(int (*)(pthread_mutex_t*))dlsym(RTLD_NEXT, "pthread_mutex_lock");
        original_pthread_mutex_unlock =(int (*)(pthread_mutex_t*))dlsym(RTLD_NEXT, "pthread_mutex_unlock");
        original_pthread_join = (int (*)(pthread_t, void**))dlsym(RTLD_NEXT, "pthread_join");
        initialized=true;

        THREAD_COUNT++;

        //insert main thread in the list
        struct thread_data* main_thread=MALLOC(struct thread_data);
        main_thread->thread_id=pthread_self();
        main_thread->state=PTHREAD_ACTIVE_THREAD;
        main_thread->local_thread_id=THREAD_COUNT;

        all_thread.comparator=pthread_equal;
        all_thread.put(pthread_self(),main_thread);

        original_pthread_mutex_lock(&SCHED_LOCK);
    }

    void run(std::istream& in)
    	    {
    	    vector<string> tokens;
    	    string line;
    	    int chromCol=0;
    	    int posCol=1;
    	    int idCol=2;
    	    int refCol=3;
    	    int altCol=4;
    	    int sampleCol=-1;

    	    while(getline(in,line,'\n'))
    		    {
    		    if(AbstractApplication::stopping()) break;
    		    if(line.empty() || line[0]=='#') continue;
    		    tokenizer.split(line,tokens);

    		    string chrom=tokens[chromCol];
    		    chat *p2;
    		    int pos=(int)strtol(tokens[posCol].c_str(),&p2,10);
    		    string id=tokens[idCol];
    		    string ref=tokens[refCol];
    		    string alt=tokens[altCol];
    		    string sampleName=tokens[sampleCol];
    		    Row* therow=NULL;
    		    if(!rows.empty() &&
    			rows.back()->pos->chrom.compare(chrom)==0 &&
    			rows.back()->pos->pos==pos &&
    			rows.back()->ref.compare(ref)==0 &&
    			rows.back()->alt.compare(alt)==0
    			)
    			{
    			therow=rows.back();
    			}
    		    else
    			{
    			therow=new Row;
    			therow->pos=new ChromPosition(chrom,pos);
    			therow->id.assign(id);
    			therow->ref.assign(ref);
    			therow->alt.assign(alt);
    			rows.push_back(therow);
    			}
    		    int index_sample=0;
    		    if(sampleCol==-1)
    			{
    			if(sample2col.empty())
    			    {
    			    Sample* sample=new Sample;
    			    sample->name.assign("Sample");
    			    sample->column_index=0;
    			    samples.push_back(sample);
    			    }
    			index_sample=0;
    			}
    		    else
    			{
			map<string,Sample*>::iterator r= sample2col.find(sampleName);
			if(r==sample2col.end())
			    {
			    Sample* sample=new Sample;
			    sample->name.assign(sampleName);
			    sample->column_index=sample2col.size();
			    index_sample=sample->column_index;
			    samples.push_back(sample);
			    sample2col.put(sample->name,sample);
			    }
			else
			    {
			    index_sample=r->second->column_index;
			    }
    			}

    		    if(index_sample>=therow->data.size())
    			{
    			therow->data.resize(index_sample+1);
    			}
    		    Data* data=new Data;
    		    therow->data.assign(index_sample,data);
    		    }
    	    }