////////////////////////////////////////////////////////////////////////////////
// Set the trace facility to be used
////////////////////////////////////////////////////////////////////////////////
Uint32 Tracer::setTraceFacility(const String& traceFacility)
{
    Uint32 retCode = 0;
    Tracer* instance = _getInstance();

    if (traceFacility.size() != 0)
    {
        Uint32 index = 0;
        while (TRACE_FACILITY_LIST[index] != 0 )
        {
            if (String::equalNoCase( traceFacility,TRACE_FACILITY_LIST[index]))
            {
                if (index != instance->_traceFacility)
                {
                    instance->_setTraceHandler(index);
                }
                retCode = 1;
                break;
            }
            index++;
        }
    }

    return retCode;
}

void 
Controller::render(){
	Tracer* trace = new Tracer(root);
	trace->setDimensions(500,500);
	trace->InitRender();
	trace->Render();
}

	Ref<Object> Tracer::dump(Frame * frame)
	{
		Tracer * tracer = NULL;
		
		frame->extract()(tracer, "self");
		
		StringStreamT buffer;
		tracer->dump(frame, buffer);
		
		return new(frame) String(buffer.str());
	}

void closer (t_Tracer_OpenTr *open)
{
    Debugger                *c;
    PROCESS_INFORMATION     ProcInfo;
    char                    bla[30];
    
    if (open->Definition->Name == "CreateProcessA")
    {
        printf("MAIN: Process created (CreateProcessA)\n");

        if (!ReadProcessMemory(dbg.getProcessHandle(),
                               (LPCVOID)(open->OutArgs[9].data.address),
                               &ProcInfo,
                               sizeof(ProcInfo),
                               NULL))
        {
            printf("Failed to read process memory at %08X\n", open->OutArgs[9].data.address);
        }
        else
        {
            c = new (Debugger);

            sprintf(bla,"Child %u",ProcInfo.dwProcessId);
            c->attach(ProcInfo.dwProcessId);
            c->log.Name= bla;

            Children.push_back(c);
        }
    }
    else if (open->Definition->Name == "CreateProcessAsUserA")
    {
        printf("MAIN: Process created (CreateProcessAsUserA)\n");

        if (!ReadProcessMemory(dbg.getProcessHandle(),
                               (LPCVOID)(open->OutArgs[10].data.address),
                               &ProcInfo,
                               sizeof(ProcInfo),
                               NULL))
        {
            printf("Failed to read process memory at %08X\n", open->OutArgs[10].data.address);
        }
        else
        {
            c = new (Debugger);

            sprintf(bla,"Child %u",ProcInfo.dwProcessId);
            c->attach(ProcInfo.dwProcessId);
            c->log.Name= bla;

            Children.push_back(c);
        }
    } 
}

void Tracer::setTraceLevel(TraceLevel tracelevel, bool recursive)
{
    m_tracelevel = tracelevel;

    if (recursive) {
        // set the tracelevl of all children recursively
        Tracer* child;
        for (child = m_children->first(); child; child = m_children->next()) {
            child->setTraceLevel(tracelevel, true);
        }
    }
}

TEST(HooksTest, UnknownChildHook)
{
    pid_t child_pid = fork();
    if (child_pid == 0) {
        _exit(0);
    }

    ASSERT_GE(child_pid, 0);

    std::optional<pid_t> exited_pid;
    std::optional<pid_t> unknown_pid;

    Tracer tracer;

    // Tracee must remain alive long enough for child_pid to exit
    auto tracee = tracer.fork([] { while (true) pause(); });
    ASSERT_TRUE(tracee);

    auto tracee_tid = tracee.value()->tid;

    Hooks hooks;

    hooks.syscall_entry = [&](auto t, auto &info) {
        if (unknown_pid) {
            SysCall sc("exit_group", info.syscall.abi());
            assert(sc);
            (void) t->modify_syscall_args(sc.num(), {});
        }
        return action::Default{};
    };

    hooks.tracee_exit = [&](auto pid, auto) {
        exited_pid = pid;
        return action::Default{};
    };

    hooks.unknown_child = [&](auto pid, auto) {
        unknown_pid = pid;

        // tracee must be a valid pointer because this hook would not have been
        // called if the only tracee exited or died
        (void) tracee.value()->interrupt();
    };

    ASSERT_TRUE(tracer.execute(hooks));

    ASSERT_EQ(exited_pid, tracee_tid);
    ASSERT_EQ(unknown_pid, child_pid);
}

void operator delete[](void* p)  
{  
        if (Tracer::Ready)  
                gNewTracer.Remove(p);  
        cout << "delete[](void* p)"<<endl;  
        free(p);  
}  

void* operator new[] (size_t size)  
{  
        void* p = malloc(size);  
        if (Tracer::Ready)  
                gNewTracer.Add(p, "?", 0);  
        return p;  
}  

void Tracer::dump(QString indention) const
{
    // print some useful infos about this tracer
    kdbgstream(indention, 0, 999, true)
            << "- "
            << *m_tracerpartname
            << " [" << TRACE_LEVEL_NAME[m_tracelevel] << "] "
            << "(classname: " << *m_classname << "), "
            << "fulltracername: " << *m_tracername
            << endl;

    // call dump on each child
    indention.append("  ");
    Tracer* child;
    for (child = m_children->first(); child; child = m_children->next()) {
        child->dump(indention);
    }
}

int main(int argn, char* argv[])
{
	po::variables_map vm = parse_program_options(argn, argv);

	if(vm.empty() || vm.count("help"))
	{
		return 0;
	}

	pid_t child_pid = fork();

	if(child_pid == 0)
	{
		// Make args string vector into null-terminated char* array
		std::vector<std::string> args_vec = vm["commands"].as<std::vector<std::string>>();
		std::vector<char*> args;

		for(auto& arg : args_vec)
		{
			args.push_back(const_cast<char*>(arg.c_str()));
		}

		args.push_back(nullptr);

		// Run given process
		if(!run_child(args_vec.front(), args.data()))
		{
			std::cerr << "Error : Failed to execute and trace the given commands." << std::endl;
		}
	}
	else if(child_pid == -1)
	{
		std::cerr << "Error : Failed to execute the given commands." << std::endl;
	}
	else
	{
		Tracer tracer;
		tracer.do_trace(child_pid, vm);
	}

	return 0;
}

int main()
{
  Signal<Vector,int> sig1( "sig1" );
  Vector v1(2); v1.fill(1.1); sig1 = v1;

  Signal<Vector,int> sig2( "sig2" );
  Vector v2(4); v2.fill(2.); sig2 = v2;

  Signal<Vector,int> sig3( "sig3" );
  Vector v3(6); v3.fill(3.); sig3 = v3;

  SignalTimeDependent<double,int> sigM( f,sotNOSIGNAL,"sigM" );
  sigM.access(0);
  
  Tracer* tracer = new Tracer( "trace" );
  tracer->addSignalToTrace( sig1 );
  tracer->openFiles( "/tmp/sot-core","tr_",".dat" );
  
  tracer->addSignalToTrace( sig2 );

  return 0;
}

int main(int argc, char* argv[])
{
    if (argc < 3) {
        std::cerr << "Usage: "<<argv[0]<<" <host> <port>"<< endl;
        return 1;
    }
    serverIp = argv[1];
    serverPort = argv[2];

    try {
        io_service io_service;

        PutTraceReq putReq;
        Tracer* tracerPtr = putReq.mutable_tracer();
        tracerPtr->set_uid("190836141");
        tracerPtr->set_id("1778");
        tracerPtr->set_type("device_log");
        tracerPtr->set_time(time(0));
        tracerPtr->set_src("internal");
        tracerPtr->set_key("online_status");
        tracerPtr->set_value("this is the value");
        tracerPtr->set_status("0");

        eachPut(io_service, putReq);

        GetTraceReq getReq;
        getReq.set_uid("190836141");
        eachGet(io_service, getReq);

        io_service.run();
    }
    catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

bool Client::IsVisible (const Vector &pos) const
{
   Tracer trace (GetHeadOrigin (), pos, NO_BOTH, m_ent);

   return ! (trace.Fire () != 1.0);
}

//
// public static methods
//
Tracer* Tracer::getInstance(const char* tracername, const char* classname)
{
    QString strTracername(tracername);
    QString strClassname(classname);

    // if neither tracername nor classname is specified we return the root-tracer
    if (strTracername.isEmpty() && strClassname.isEmpty()) {
        return getRootTracer();
    }

    Tracer* currentTracer = getRootTracer();
    QString currentTracerName = QString("");
    
    // split the tracername into its parts
    QStringList parts = QStringList::split(TRACER_NAME_SEPARATOR, strTracername, false);

    // if specified the classname is handled as last part of the tracername
    if (!strClassname.isEmpty()) {
        parts.append(strClassname);
    }

    int partsCount = parts.count();

    // loop over the tracename parts and
    // try to get the tracer matching the tracername and classname
    // as soon as we don't find a matching subtracer we begin to create new tracers...
    for (int i = 0; i < partsCount; i++) {
        QString part = parts[i];
        
        // create the tracername of the tracer we would like at this point
        if (i > 0) {
            currentTracerName = currentTracerName.append(TRACER_NAME_SEPARATOR);
        }
        currentTracerName = currentTracerName.append(part);

        // try to get a matching tracer for the currentTracerName
        Tracer* matchingChild = currentTracer->getChild(part);
        if (matchingChild) {
            currentTracer = matchingChild;
        } else {
            //no matching subtracer found --> create one!

            Tracer* child;
            if (i + 1 == partsCount) {
                // this is the last tracer to instantiate --> create WITH classname
                child = new Tracer(currentTracerName, part, strClassname);
            } else {
                // this is a missing supertracer of the tracer to create --> create without classname
                child = new Tracer(currentTracerName, part, "");
            }

            // link the new tracer into the tracer tree
            currentTracer->m_children->append(child);
            child->m_parent = currentTracer;

            // tracers inherit the tracelevel of the parent
            child->m_tracelevel = currentTracer->m_tracelevel;
            
            currentTracer = child;
        }
    }

    // if a classname is specified but the resulting tracer has no one set
    // the tracer was already instantiated without a classname set
    // this most likely occurs when the tracer was configured by a traceconfigfile
    // --> force the classname
    if (!strClassname.isEmpty() && currentTracer->m_classname->isEmpty()) {
        currentTracer->m_classname = new QString(strClassname);
    }
    

    return currentTracer;
}

//.........这里部分代码省略.........
	}
	fb_copy_time = framebuffer.get_copy_exec_time();
	double total_msec = rt_time.msec_since_snap();

	if (min_time < 0)
		min_time = total_msec;
	else
		min_time = std::min(min_time,total_msec);

	if (max_time < 0)
		max_time = total_msec;
	else
		max_time = std::max(max_time,total_msec);

        if (device.release_graphic_resource(tex_id) ||
            cubemap.release_graphic_resources()) {
                std::cerr << "Error releasing texture resource." << std::endl;
                exit(1);
        }

        for (size_t i = 0; i < scenes.size(); ++i) {
                if (scenes[i].release_graphic_resources()) {
                        std::cerr << "Error releasing texture resource." << std::endl;
                        exit(1);
                }
        }

        ////////////////// Immediate mode textured quad
	glBindTexture(GL_TEXTURE_2D, gl_tex);

	glBegin(GL_TRIANGLE_STRIP);

	glTexCoord2f(1.0,1.0);
	glVertex2f(1.0,1.0);

	glTexCoord2f(1.0,0.0);
	glVertex2f(1.0,-1.0);

	glTexCoord2f(0.0,1.0);
	glVertex2f(-1.0,1.0);

	glTexCoord2f(0.0,0.0);
	glVertex2f(-1.0,-1.0);

	glEnd();
	////////////////////////////////////////////

	i += dir;
	if (!(i % (STEPS-1))){
		dir *= -1;
	}		
	std::cout << "Time elapsed: " 
		  << total_msec << " milliseconds " 
		  << "\t" 
		  << (1000.f / total_msec)
		  << " FPS"
		  << "\t"
		  << total_ray_count
		  << " rays casted "
		  << "\t(" << pixel_count << " primary, " 
		  << total_ray_count-pixel_count << " secondary)"
		  << "               \r" ;
	std::flush(std::cout);
	rt_time.snap_time();
	total_ray_count = 0;

	std::cout << "\nPrim Gen time: \t" << prim_gen_time  << std::endl;
	std::cout << "Sec Gen time: \t" << sec_gen_time << std::endl;
	std::cout << "Tracer time: \t" << prim_trace_time + sec_trace_time  
		  << " (" <<  prim_trace_time << " - " << sec_trace_time 
		  << ")" << std::endl;
	std::cout << "Shadow time: \t" << prim_shadow_trace_time + sec_shadow_trace_time 
		  << " (" <<  prim_shadow_trace_time 
		  << " - " << sec_shadow_trace_time << ")" << std::endl;
	std::cout << "Shader time: \t " << shader_time << std::endl;
	std::cout << "Fb clear time: \t" << fb_clear_time << std::endl;
	std::cout << "Fb copy time: \t" << fb_copy_time << std::endl;
	std::cout << std::endl;

	glutSwapBuffers();
	current_frame = (current_frame+motion_rate)%frames;
	if (current_frame == 0) {
		double t = seq_time.msec_since_snap();
		     
		std::cout << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" << std::endl;
		std::cout << "Sequence stats:" << std::endl << std::endl;
		std::cout << "Frames: " << frames << std::endl;
		std::cout << "Sequence render time: " << t << "msec\t(" 
			  << frames*1000.f/t << " FPS)" <<   std::endl;
		std::cout << "Mean / Min / Max render time: " 
			  <<  t/frames << " / " 
			  <<  min_time << " / " 
			  <<  max_time << " msec" << std::endl;
		std::cout << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" << std::endl;
		max_time = -1;
		min_time = -1;
		seq_time.snap_time();
	}

}

void foo(Tracer t){
	Tracer trace("foo");
	t.show();
}

Tracer bar(Tracer const &t){
	Tracer trace("bar");
	t.show();
	return trace;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////
// ps_base_address()
//
// search through all loaded modules for a string match and return it's base address.
//
bool ps_base_address (char *module, DWORD *address, DWORD *size)
{
    map <DWORD,t_Debugger_memory*>::const_iterator  it;
    
    dbg.ReBuildMemoryMap();

    // determine the base address of the executable section for the loaded module.
    for (it = dbg.MemoryMap.begin(); it != dbg.MemoryMap.end(); ++it)
    {
        // match the module name.
        if (stricmp(it->second->Name.c_str(), module) != 0)
            continue;

        // ensure we found the correct section.
        if ((it->second->basics.Protect & PAGE_EXECUTE)           ||
            (it->second->basics.Protect & PAGE_EXECUTE_READ)      ||
            (it->second->basics.Protect & PAGE_EXECUTE_READWRITE) ||
            (it->second->basics.Protect & PAGE_EXECUTE_WRITECOPY))
        {
            // module executable section found.
            *address = it->second->address;
            *size    = it->second->basics.RegionSize;
            return true;
        }
    }

    return false;
}

int main (int argc, char** argv)
{

	/*---------------------- Initialize OpenGL and OpenCL ----------------------*/

	if (init_gl(argc,argv,&glinfo, window_size, "RT") != 0){
		std::cerr << "Failed to initialize GL" << std::endl;
		exit(1);
	} else { 
		std::cout << "Initialized GL succesfully" << std::endl;
	}

	if (init_cl(glinfo,&clinfo) != CL_SUCCESS){
		std::cerr << "Failed to initialize CL" << std::endl;
		exit(1);
	} else { 
		std::cout << "Initialized CL succesfully" << std::endl;
	}
	print_cl_info(clinfo);

        /* Initialize device interface */
        if (device.initialize(clinfo)) {
                std::cerr << "Failed to initialize device interface" << std::endl;
                exit(1);
        }
        /* Initialize generic gpu library */
        DeviceFunctionLibrary::initialize(clinfo);

	/*---------------------- Create shared GL-CL texture ----------------------*/
	gl_tex = create_tex_gl(window_size[0],window_size[1]);
        tex_id = device.new_memory();
        DeviceMemory& tex_mem = device.memory(tex_id);
        if (tex_mem.initialize_from_gl_texture(gl_tex)) {
                std::cerr << "Failed to create memory object from gl texture" << std::endl;
                exit(1);
        }

	/*---------------------- Set up scene ---------------------------*/
	frames = 15;
	const std::string pack = "pack1OBJ";
	// const std::string pack = "pack2OBJ";
	double wave_attenuation = 1.f;

        scenes.resize(frames);
	for (uint32_t i = 0; i < frames ; ++i) {

                scenes[i].initialize();
		std::stringstream grid_path,visual_path;
		grid_path << "models/obj/" << pack << "/gridFluid" << i+1 << ".obj";
		mesh_id grid_mid = scenes[i].load_obj_file_as_aggregate(grid_path.str());
		object_id grid_oid = scenes[i].add_object(grid_mid);
		Object& grid = scenes[i].object(grid_oid);
		grid.mat.diffuse = White;
		grid.mat.reflectiveness = 0.95f;
		grid.mat.refractive_index = 1.5f;
		grid.geom.setScale(makeVector(1.f,wave_attenuation,1.f));

		/* ---- Solids ------ */
		// visual_path << "models/obj/" << pack << "/visual" << visual_frame << ".obj";
		// mesh_id visual_mid = scenes[i].load_obj_file_as_aggregate(visual_path.str());
		// object_id visual_oid = scenes[i].geometry.add_object(visual_mid);
		// Object& visual = scenes[i].geometry.object(visual_oid);
		// visual.mat.diffuse = Red;

		// for (uint32_t j = 0; j < bridge_parts ; ++j) {
		// 	std::stringstream bridge_path;
		// 	bridge_path << "models/obj/" << pack << "/bridge" << j << i+1 << ".obj";
		// 	mesh_id bridge_mid = scenes[i].load_obj_file_as_aggregate(bridge_path.str());
		// 	object_id bridge_oid = scenes[i].geometry.add_object(bridge_mid);
		// 	Object& bridge = scenes[i].geometry.object(bridge_oid);
		// 	bridge.mat.diffuse = Green;
		// }

		// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot2.obj");
		// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot-low_res.obj");
		// object_id teapot_obj_id = scenes[i].geometry.add_object(teapot_mesh_id);
		// Object& teapot_obj = scenes[i].geometry.object(teapot_obj_id);
		// teapot_obj.geom.setPos(makeVector(-1.f,0.f,0.f));
		// teapot_obj.geom.setScale(makeVector(3.f,3.f,3.f));
		// teapot_obj.mat.diffuse = Green;
		// teapot_obj.mat.shininess = 1.f;
		// teapot_obj.mat.reflectiveness = 0.3f;

		/* ------------------*/

                // scenes[i].set_accelerator_type(KDTREE_ACCELERATOR);
                scenes[i].set_accelerator_type(BVH_ACCELERATOR);
		scenes[i].create_aggregate_mesh();
		scenes[i].create_aggregate_accelerator();
		Mesh& scene_mesh = scenes[i].get_aggregate_mesh();
                if (scenes[i].transfer_aggregate_mesh_to_device() 
                    || scenes[i].transfer_aggregate_accelerator_to_device())
                        std::cerr << "Failed to transfer scene info to device"<< std::endl;


		/*---------------------- Print scene data ----------------------*/
		std::cerr << "Scene " << i << " stats: " << std::endl;
		std::cerr << "\tTriangle count: " << scene_mesh.triangleCount() << std::endl;
		std::cerr << "\tVertex count: " << scene_mesh.vertexCount() << std::endl;
		std::cerr << std::endl;
//.........这里部分代码省略.........

 void
 TraceError(const wxString & message)
 {
   if (tracer)
     tracer->TraceError(message);
 }