예제 #1
0
파일: main.c 프로젝트: Anon1234/obshutdown
int main(int argc, char **argv)
{
	exitCode = 0;

	initGtk(&argc, &argv);

	migrateConfigToXdgDir();
	migrateThemesToXdgDir();
	initDataDefault();

	if (parseCommandline(&argc, &argv)) {
		if(initLockFile()) {
			printMessage(MSG_INFO, "Startup %s %s (-h to print usage)\n", OBS_NAME, OBS_VERSION);
			if (initConfigs()) {
				initWidgets();
				gtk_widget_show_all(winWidget);
				gtk_main();
			}
			else
				exitCode = 1;
			deleteLockFile();
		}
		else
			exitCode = 1;
	}
	else
		exitCode = 1;

	freeData();

	exit(exitCode);
}
예제 #2
0
int main(int argc, char* argv[]) {
    ParameterABCrossValidate parameters = parseCommandline(argc, argv);
    
    if (parameters.verbose) {
        std::string boostingTypeName[3] = {"discrete", "real", "gentle"};
        std::cerr << std::endl;
        std::cerr << "Traing data:  " << parameters.trainingDataFilename << std::endl;
        std::cerr << "   Type:      " << boostingTypeName[parameters.boostingType] << std::endl;
        std::cerr << "   #rounds:   " << parameters.roundTotal << std::endl;
        std::cerr << "   #" << parameters.k_cv << " fold cross-valiation" << std::endl;
        std::cerr << std::endl;
    }
    
    AdaBoost adaBoost;
    adaBoost.setBoostingType(parameters.boostingType);
    adaBoost.readAllSamples(parameters.trainingDataFilename, parameters.k_cv);
    double accuracyAll = 0.0;
    for (int i = 0; i < parameters.k_cv; i++) {
        if (parameters.verbose)
            std::cout << "====== CV Round " << i << " ======" << std::endl;
        adaBoost.setCrossValidationSampels(i, parameters.k_cv);
        adaBoost.train(parameters.roundTotal, parameters.verbose);
        TestResult res = adaBoost.test(false, "");
        accuracyAll += res.accuracyAll;
        if (parameters.verbose) {
            std::cout << "Accuracy = " << res.accuracyAll << std::endl;
            std::cout << "  precision: " << res.precision << " , negative: " << res.recall << std::endl;

        }
    }
    std::cout << "\nCross Validation Accuracy: " << accuracyAll / parameters.k_cv << std::endl;
}
예제 #3
0
MainWindow::MainWindow(int argc, char *argv[], QWidget *parent) :
    QMainWindow(parent),
    m_ui(new Ui::MainWindow)
{
    QCoreApplication::setOrganizationName(PIXYMON_COMPANY);
    QCoreApplication::setApplicationName(PIXYMON_TITLE);

    parseCommandline(argc, argv);

    qRegisterMetaType<Device>("Device");

    m_ui->setupUi(this);
    setWindowTitle(PIXYMON_TITLE);

    m_interpreter = NULL;
    m_flash = NULL;
    m_pixyConnected = false;
    m_pixyDFUConnected = false;
    m_configDialog = NULL;
    m_fwInstructions = NULL;
    m_fwMessage = NULL;
    m_versionIncompatibility = false;

    m_waiting = WAIT_NONE;

    m_settings = new QSettings(QSettings::NativeFormat, QSettings::UserScope, PIXYMON_COMPANY, PIXYMON_TITLE);
    m_console = new ConsoleWidget(this);
    m_video = new VideoWidget(this);

    m_ui->imageLayout->addWidget(m_video);
    m_ui->imageLayout->addWidget(m_console);

    m_ui->toolBar->addAction(m_ui->actionPlay_Pause);

    m_ui->actionDefault_program->setIcon(QIcon(":/icons/icons/home.png"));
    m_ui->toolBar->addAction(m_ui->actionDefault_program);    

    m_ui->actionRaw_video->setIcon(QIcon(":/icons/icons/raw.png"));
    m_ui->toolBar->addAction(m_ui->actionRaw_video);

    m_ui->actionCooked_video->setIcon(QIcon(":/icons/icons/cooked.png"));
    m_ui->toolBar->addAction(m_ui->actionCooked_video);

    m_ui->actionConfigure->setIcon(QIcon(":/icons/icons/config.png"));
    m_ui->toolBar->addAction(m_ui->actionConfigure);

    updateButtons();

    m_parameters.add("Pixy start command", PT_STRING, "runprogArg 8 1",
        "The command that is sent to Pixy upon initialization");

    // start looking for devices
    m_connect = new ConnectEvent(this);
    if (m_connect->getConnected()==NONE)
        m_console->error("No Pixy devices have been detected.\n");
}
예제 #4
0
  /*@-superuser@*/
int
initializeSystem(int argc, char *argv[],
		 struct InterfaceInfoList *	ifs,
		 struct ServerInfoList *	servers,
		 struct FdInfoList *		fds)
{
  struct ConfigInfo		cfg;
  pid_t				pid, pidfile_pid;
  int				pidfile_fd;

  cfg.conffile_name = CFG_FILENAME;
  cfg.do_fork       = true;

  parseCommandline(argc, argv, &cfg);

    /*@-boundswrite@*/
  getConfig(cfg.conffile_name, &cfg);
  initFDs(fds, &cfg);
    /*@=boundswrite@*/

  pidfile_fd = Eopen(cfg.pidfile_name, O_WRONLY|O_CREAT, 0444);
  openMsgfile(cfg.logfile_name);
  
  *ifs     = cfg.interfaces;
  *servers = cfg.servers;

  Eclose(0);

  if (cfg.do_fork) pid = fork();
  else             pid = 0;

  pidfile_pid = 0;

  switch (pid) {
    case 0	:
      pidfile_pid = initializeDaemon(&cfg);
      break;
      
    case -1	:  perror("fork()");  break;
    default	:  pidfile_pid = pid; break;
  }

  if (pidfile_pid!=0) {
    writeUInt(pidfile_fd, pidfile_pid);
    (void)write(pidfile_fd, "\n", 1);
  }
	  
  freeLimitList(&cfg.ulimits);

    /* It is too late to handle an error here. So just ignore it... */
  (void)close(pidfile_fd);
  return pid;
}
예제 #5
0
int main(int argc, char *argv[]) {
  std::vector<Record> records;
  float *recordDistances;
  //LatLong locations[REC_WINDOW];
  std::vector<LatLong> locations;
  int i;
  // args
  char filename[100];
  int resultsCount=10,quiet=0,timing=0,platform=-1,device=-1;
  float lat=0.0,lng=0.0;
  
  // parse command line
  if (parseCommandline(argc, argv, filename,&resultsCount,&lat,&lng,
                     &quiet, &timing, &platform, &device)) {
    printUsage();
    return 0;
  }
  
  int numRecords = loadData(filename,records,locations);
  
  //for(i=0;i<numRecords;i++)
  //    printf("%s, %f, %f\n",(records[i].recString),locations[i].lat,locations[i].lng);


  if (!quiet) {
    printf("Number of records: %d\n",numRecords);
    printf("Finding the %d closest neighbors.\n",resultsCount);
  }

  if (resultsCount > numRecords) resultsCount = numRecords;

  
  context = cl_init_context(platform,device,quiet);
  
  recordDistances = OpenClFindNearestNeighbors(context,numRecords,locations,lat,lng,timing);

  // find the resultsCount least distances
  findLowest(records,recordDistances,numRecords,resultsCount);

  // print out results
  if (!quiet)
    for(i=0;i<resultsCount;i++) {
      printf("%s --> Distance=%f\n",records[i].recString,records[i].distance);
    }
  free(recordDistances);
  return 0;
}
예제 #6
0
extern "C" int main (int argc, char **argv)
{
	::testing::AddGlobalTestEnvironment(new LocalEnv);
	//::testing::GTEST_FLAG(throw_on_failure) = true;
	::testing::InitGoogleTest(&argc, argv);

	setDefaultOptions();
	parseCommandline(argc, argv);

	Application& app = Singleton<Application>::getInstance();
	const GamePtr& game = Singleton<GameRegistry>::getInstance().getGame();
	app.setOrganisation("caveproductions");
	app.setName(game->getName());
	Log::get().addConsole(&console);
	Config.init(nullptr, argc, argv);
	return RUN_ALL_TESTS();
}
예제 #7
0
			bool generateDoc(void) {
				if (!parseCommandline()) {
					help();
					return false;
				}
				// initialize the system - load the dtype scripts according to the config
				initialize();

				// read the additional docs file. This file contains docs for each entity
				// has a simple format [prop PropName] or [link LinkName] for doc target change. Other lines (after stripping # comments)
				// are accumulated to the last specified doc target
				loadAdditionalDocStrings();

				// generate the doc
				doGenerate();

				return true;
			}
예제 #8
0
int main(int argc,char **argv)
{

	unsigned int ii;
    /* initialize globals */
    g_verbose=0;        /* verbose off */
    g_quit=0;           /* quit for making the ppp connection is established*/
    g_quit_time=0;      /* stay up forever */
    *g_configfile='\0'; /* the config file */
#if 0
	*(unsigned int volatile *)(0xfff83050) = 0x15555055;
	*(unsigned int volatile *)(0xfff83054) = 0x30;
	*(unsigned int volatile *)(0xfff83058) = 0x00;
#endif

#if 1  //=============>  enable CTS/RTS pins
	*(unsigned int volatile *)(0xfff83050) &= 0xfffff0ff;
	*(unsigned int volatile *)(0xfff83050) |= 0xa00;
	*(unsigned int volatile *)(0xfff80110) = 0xf;
	
	//CSR_WRITE(COM_MCR_1, CSR_READ(COM_MCR_1)&0xf);
#endif

	//ii = *(unsigned int volatile *)(0xfff83000);
	//ii |= 4; // enable modem signal pins
	//*(unsigned int volatile *)(0xfff83000) = ii;
	//sleep(1);
	//printf("GPIO configured as %08x\n", *(unsigned int volatile *)(0xfff83050));
	//printf("UART configured as %08x\n", *(unsigned int volatile *)(0xfff80110));
	
#ifdef HAVE_MOTIF

    /* create the user interface */
    DoMotif(argc,argv);

#else
     parseCommandline(argc,argv);
     startPPP();
#endif      /* HAVE_MOTIF */
    exit(0);
}
예제 #9
0
파일: xoreos.cpp 프로젝트: clone2727/xoreos
int main(int argc, char **argv) {
	initPlatform();
	initConfig();

	std::vector<Common::UString> args;
	Common::Platform::getParameters(argc, argv, args);

	Common::UString target;
	int code;
	if (!parseCommandline(args, target, code))
		return code;

	// Check the requested target
	if (target.empty() || !ConfigMan.hasGame(target)) {
		Common::UString path = ConfigMan.getString("path");
		if (path.empty()) {
			if (ConfigMan.getBool("listdebug", false)) {
				listDebug();
				return 0;
			}

			error("Neither an existing target, nor a path specified");
		}

		bool useExisting = false;
		if (target.empty()) {
			target = ConfigMan.findGame(path);
			if (!target.empty()) {
				warning("No target specified, but found a target with a matching path");
				useExisting = true;
			}
		}

		target = ConfigMan.createGame(path, target);
		if (target.empty())
			error("Failed creating a new config target for the game");

		if (!useExisting)
			warning("Creating a new target for this game");
	}

	if (!ConfigMan.setGame(target) || !ConfigMan.isInGame())
		error("No target \"%s\" in the config file", target.c_str());

	/* Open the log file.
	 *
	 * NOTE: A log is opened by default, unless the logfile config value
	 *       is set to an empty string or nologfile is set to true.
	 */
	Common::UString logFile = DebugMan.getDefaultLogFile();
	if (ConfigMan.hasKey("logfile"))
		logFile = ConfigMan.getString("logfile");
	if (ConfigMan.getBool("nologfile", false))
		logFile.clear();

	if (!logFile.empty())
		if (!DebugMan.openLogFile(logFile))
			warning("Failed to open log file \"%s\" for writing", logFile.c_str());

	DebugMan.logCommandLine(args);

	status("Target \"%s\"", target.c_str());

	Common::UString dirArg = ConfigMan.getString("path");
	if (dirArg.empty())
		error("Target \"%s\" is missing a path", target.c_str());

	Common::UString baseDir;
	try {
		baseDir = Common::FilePath::canonicalize(dirArg);
	} catch (...) {
		error("Invalid path \"%s\"", dirArg.c_str());
	}

	if (!Common::FilePath::isDirectory(baseDir) && !Common::FilePath::isRegularFile(baseDir))
		error("No such file or directory \"%s\"", baseDir.c_str());

	Engines::GameThread *gameThread = new Engines::GameThread;
	try {
		// Enable requested debug channels
		initDebug();

		// Initialize all necessary subsystems
		init();

		// Probe and create the game engine
		gameThread->init(baseDir);

		if (ConfigMan.getBool("listdebug", false)) {
			// List debug channels
			listDebug();
		} else {
			// Run the game
			gameThread->run();
			EventMan.runMainLoop();
		}

	} catch (...) {
		EventMan.raiseFatalError();

		Common::exceptionDispatcherError();
	}

	if (EventMan.fatalErrorRaised())
		std::exit(1);

	status("Shutting down");

	try {
		delete gameThread;
	} catch (...) {
	}

	try {
		// Configs changed, we should save them
		if (ConfigMan.changed()) {
			// But don't clobber a broken save
			if (!configFileIsBroken)
				ConfigMan.save();
		}
	} catch (...) {
		Common::exceptionDispatcherError();
	}

	deinit();
	return 0;
}
예제 #10
0
파일: Query.c 프로젝트: elambert/honeycomb
int main(int argc, char* argv[])
{
	hc_session_t *session = NULL;

	hc_oid returnedOid;
	hc_long_t count = 0;
	int finished = 0;
	int32_t response_code = RETURN_SUCCESS;
	hc_query_result_set_t *rset = NULL;
	hc_nvr_t *nvr = NULL;
	hc_long_t query_integrity_time;
	int query_complete;

	
	hcerr_t	res = HCERR_OK;

	int parametersUsed = USES_SERVERADDRESS | USES_QUERY | USES_SELECT_METADATA | USES_MAXRESULTS;

	/* Initialize commandline structure */
	cmdLine.storagetekServerAddress = NULL;
	cmdLine.query = NULL;
	cmdLine.help = 0;
	cmdLine.debug_flags = 0;
	cmdLine.storagetekPort = 0;
	cmdLine.maxResults = DEFAULT_MAX_RESULTS;

	/* Initialize metadata map.  The metadata map structure is not part of the API but common */
	/* code written for the convenience of these examples.  See example_metadata.c. */
        if (initMetadataMap(&cmdLine.cmdlineMetadata) == 0)
        {
                return exitApp(RETURN_MAPINITERROR);
        }       /* if initMetadataMap == 0 */

	/* Get commandline (see example_commandline.c) */
	if (parseCommandline(	argc,
				argv,
				parametersUsed) == 0)
	{
		printUsage();
		return RETURN_COMMANDLINE_ERROR;
	}	/* if parseCommandline failed */
	else
	{
		if (cmdLine.help == 1)
		{
			printUsage();
			return RETURN_SUCCESS;
		}	/* if help requested */
	}	/* else parseCommandline succeeded */

	/* Initialize @HoneycombProductName@ API */
        res = hc_init(malloc,free,realloc);
        if (res != HCERR_OK)
        {
                printf("An error occurred while initializing the API.\n");
                return res;
        }  /* if error */

       if (cmdLine.debug_flags) {
		/* Internal debug flags */
		hc_set_global_parameter(HCOPT_DEBUG_FLAGS, cmdLine.debug_flags);
       }

	res = hc_session_create_ez(cmdLine.storagetekServerAddress, 
				(cmdLine.storagetekPort > 0 ? 
				 cmdLine.storagetekPort : 
				 STORAGETEK_PORT),
				&session);
	
	if (res != HCERR_OK)
	{
		HandleError(session,res);
		return RETURN_STORAGETEK_ERROR;
	}	/* if initialization failed */

	/* Run queryplus if we have a select clause (-s option on the commandline), otherwise run query */
	if (cmdLine.cmdlineMetadata.mapSize > 0)
	{
		res = hc_query_ez(session,
				cmdLine.query,
				cmdLine.cmdlineMetadata.namePointerArray,	
				cmdLine.cmdlineMetadata.mapSize,
                                100,
				&rset);
	}	/* if outputing metadata */
	else
	{	
		res = hc_query_ez(session,
				cmdLine.query,
                                NULL,
                                0,
                                100,
				&rset);
	}

	if (res != HCERR_OK)
        {
                HandleError(session, res);
                hc_session_free(session);
                hc_cleanup();
                return RETURN_STORAGETEK_ERROR;
        }       /* if not successful */

	/* Loop up until the maximum result size */
	for (count = 0; count < cmdLine.maxResults; count++) 
	{
		/* Get the next result */
		res = hc_qrs_next_ez(rset, &returnedOid, &nvr, &finished);	

 		if (res != HCERR_OK)
   		{
			HandleError(session, res);
			hc_session_free(session);
			hc_cleanup();
			return RETURN_STORAGETEK_ERROR;
    		}	/* if not successful */

                if (finished)
                        break;

		/* Print the next result to standard output */
		if (cmdLine.cmdlineMetadata.mapSize > 0)
		{
			printMetadataResults(nvr, session);
		}
		else
		{
    			printOIDResults((char *) &returnedOid);
		}
	}	/* loop through results */

	res = hc_qrs_is_query_complete(rset,&query_complete);
	if (res != HCERR_OK) 
	{
    		HandleError(session, res);
    		response_code = RETURN_STORAGETEK_ERROR;
	}
	res = hc_qrs_get_query_integrity_time(rset,&query_integrity_time);
	if (res != HCERR_OK) 
	{
    		HandleError(session, res);
    		response_code = RETURN_STORAGETEK_ERROR;
	}

	printf("Query Integrity Status %s at time %lld\n",
	       query_complete ? "true" : "false",
	       query_integrity_time);

        res = hc_qrs_free(rset);

	if (res != HCERR_OK) 
	{
    		HandleError(session, res);
    		response_code = RETURN_STORAGETEK_ERROR;
	}

	hc_session_free(session);
	hc_cleanup();

        return exitApp(response_code);
}	/* main */
예제 #11
0
파일: warmup2.c 프로젝트: adityadani/CS-402
int main(int argc, char **argv)
{
	long t1=1, t2=2, t3=3;
	pthread_t arrThread, serThread, tokThread;
	long total_emulation_time;

	// Setting to default values

	lambda = 0.5;
	mu = 0.35;
	r = 1.5;
	P = 3;
	B = 10;
	num_packets = 20;

	token_bucket = 0;
	server_die = 0;
	token_die = 0;

	avg_pkt_q1 = avg_pkt_q2 = avg_pkt_s = 0;
	// Done

	// Initialize Queues
	
	My402ListInit(&queue1);
	My402ListInit(&queue2);

	pthread_mutex_init(&my_mutex,NULL);
	pthread_cond_init(&queue2_cond,NULL);

	parseCommandline(argc,argv);

	tokenarrival = (long)((1/r)*1000000);
	pkts_to_arrive = num_packets;


	pthread_create(&arrThread, NULL, arrivalThread,(void *)t1);
	pthread_create(&tokThread, NULL, tokenThread,(void *)t2);
	pthread_create(&serThread, NULL, serverThread, (void *)t3);

	temulation_start = tastart = ttstart =  getinstanttime();
	PrintStat(getinstanttime());
	fprintf(stdout, "Emulation Begins\n");



	pthread_join(arrThread, NULL);
	pthread_join(tokThread, NULL);
	pthread_join(serThread, NULL);

	temulation_end = getinstanttime();
	PrintStat(getinstanttime());
	fprintf(stdout, "Emulation Ends \n");

	total_emulation_time = temulation_end - temulation_start;
	fprintf(stdout,"Statistics: \n\n");
	fprintf(stdout,"\taverage packet inter arrival time = %.08g sec\n",avg_inter_arrival);
	fprintf(stdout,"\taverage packet service time = %.08g sec\n\n",avg_serv_time);
	fprintf(stdout,"\taverage number of packets in Q1 = %.08g\n",(double)avg_pkt_q1/total_emulation_time);
	fprintf(stdout,"\taverage number of packets in Q2 = %.08g\n",(double)avg_pkt_q2/total_emulation_time);
	fprintf(stdout,"\taverage number of packets at S = %.08g\n\n",(double)avg_pkt_s/total_emulation_time);
	fprintf(stdout,"\taverage time a packet spent in the system = %.08g sec\n",avg_pkt_sys_time);
	fprintf(stdout,"\tstandard deviation for time spent in system = %.08g sec \n\n",std_deviation);
	fprintf(stdout,"\ttoken drop probability = %.08g\n",token_drop_prob);
	fprintf(stdout,"\tpacket drop probability = %.08g\n",pkt_drop_prob);

	pthread_mutex_destroy(&my_mutex);
	pthread_cond_destroy(&queue2_cond);
	pthread_exit(NULL);


}
예제 #12
0
int main(int argc, char **argv) {
	atexit(deinit);

	initConfig();

	Common::UString target;
	int code;
	if (!parseCommandline(argc, argv, target, code))
		return code;

	// Open the requested log file
	Common::UString logFile = ConfigMan.getString("logfile");
	if (!logFile.empty())
		DebugMan.openLogFile(logFile);

	// Check the requested target
	if (target.empty() || !ConfigMan.hasGame(target)) {
		Common::UString path = ConfigMan.getString("path");
		if (path.empty()) {
			if (ConfigMan.getBool("listdebug", false)) {
				listDebug();
				return 0;
			}

			error("Neither an existing target, nor a path specified");
		}

		bool useExisting = false;
		if (target.empty()) {
			target = ConfigMan.findGame(path);
			if (!target.empty()) {
				warning("No target specified, but found a target with a matching path");
				useExisting = true;
			}
		}

		target = ConfigMan.createGame(path, target);
		if (target.empty())
			error("Failed creating a new config target for the game");

		if (!useExisting)
			warning("Creating a new target for this game");
	}

	status("Target \"%s\"", target.c_str());
	if (!ConfigMan.setGame(target) || !ConfigMan.isInGame())
		error("No target \"%s\" in the config file", target.c_str());

	Common::UString dirArg = ConfigMan.getString("path");
	if (dirArg.empty())
		error("Target \"%s\" is missing a path", target.c_str());

	Common::UString baseDir = Common::FilePath::makeAbsolute(dirArg);
	if (!Common::FilePath::isDirectory(baseDir) && !Common::FilePath::isRegularFile(baseDir))
		error("No such file or directory \"%s\"", baseDir.c_str());

	Engines::GameThread *gameThread = new Engines::GameThread;
	try {
		// Initialize all necessary subsystems
		init();

		// Probe and create the game engine
		gameThread->init(baseDir);

		// Enable requested debug channels
		initDebug();

		if (ConfigMan.getBool("listdebug", false)) {
			// List debug channels
			listDebug();
		} else {
			// Run the game
			gameThread->run();
			EventMan.runMainLoop();
		}

	} catch (Common::Exception &e) {
		Common::printException(e);
		std::exit(1);
	}

	status("Shutting down");

	delete gameThread;

	// Configs changed, we should save them
	if (ConfigMan.changed()) {
		// But don't clobber a broken save
		if (!configFileIsBroken)
			ConfigMan.save();
	}

	return 0;
}
예제 #13
0
int main(int argc, char *argv[]) {

	printf("WG size of kernel 1 = %d, WG size of kernel 2= %d X %d\n", BLOCK_SIZE_0, BLOCK_SIZE_1_X, BLOCK_SIZE_1_Y);
	float *a=NULL, *b=NULL, *finalVec=NULL;
	float *m=NULL;
	int size = -1;

	FILE *fp;

	// args
	char filename[200];
	int quiet=1,timing=0,platform=-1,device=-1;

	// parse command line
	if (parseCommandline(argc, argv, filename,
				&quiet, &timing, &platform, &device, &size)) {
		printUsage();
		return 0;
	}

	context = cl_init_context(platform,device,quiet);

	if(size < 1)
	{
		fp = fopen(filename, "r");
		fscanf(fp, "%d", &size);

		a = (float *) malloc(size * size * sizeof(float));
		InitMat(fp,size, a, size, size);

		b = (float *) malloc(size * sizeof(float));
		InitAry(fp, b, size);

		fclose(fp);

	}
	else
	{
		printf("create input internally before create, size = %d \n", size);

		a = (float *) malloc(size * size * sizeof(float));
		create_matrix(a, size);

		b = (float *) malloc(size * sizeof(float));
		for (int i =0; i< size; i++)
			b[i]=1.0;

	}

	if (!quiet) {    
		printf("The input matrix a is:\n");
		PrintMat(a, size, size, size);

		printf("The input array b is:\n");
		PrintAry(b, size);
	}

	// create the solution matrix
	m = (float *) malloc(size * size * sizeof(float));

	// create a new vector to hold the final answer

	finalVec = (float *) malloc(size * sizeof(float));

	InitPerRun(size,m);

	//begin timing	
	// printf("The result of array b is before run: \n");
	// PrintAry(b, size);

	// run kernels
	ForwardSub(context,a,b,m,size,timing);
	// printf("The result of array b is after run: \n");
	// PrintAry(b, size);

	DIVIDEND_CL_WRAP(clFinish)(command_queue);

	//end timing
	if (!quiet) {
		printf("The result of matrix m is: \n");

		PrintMat(m, size, size, size);
		printf("The result of matrix a is: \n");
		PrintMat(a, size, size, size);
		printf("The result of array b is: \n");
		PrintAry(b, size);

		BackSub(a,b,finalVec,size);
		printf("The final solution is: \n");
		PrintAry(finalVec,size);
	}

	free(m);
	free(a);
	free(b);
	free(finalVec);
	cl_cleanup();
	//OpenClGaussianElimination(context,timing);

	return 0;
}
예제 #14
0
int main(int argc, char** argv)
{
	// init winsock
#ifdef __WIN32__
	WSADATA wsa;
	WSAStartup(MAKEWORD(2,2),&wsa);
#else
	init_deamon();

	signal(SIGINT, signal_handler);
	signal(SIGPIPE, SIG_IGN);
	signal(25, SIG_IGN);
#endif

	commandLineClt cmdline;
	parseCommandline(argc,argv,cmdline);

#ifdef	__x86_64__
		processor_info_t proc_info;
		cpuid_basic_identify(&proc_info);
		if (proc_info.proc_type == PROC_X64_INTEL || proc_info.proc_type == PROC_X64_AMD) {
			if (proc_info.avx_level > 0) {
				cmdline.sha2type = USE_AVX_SHA512;
				printf("using AVX\n");
			} else if (proc_info.sse_level >= 2) {
				Init_SHA512_sse4();
				cmdline.sha2type = USE_SSE4_SHA512;
				printf("using SSE4\n");
			} else
				printf("using default SHA512\n");
		} else
			printf("using default SHA512\n");
#endif
		uint32 num_processors;
#if defined(__WIN32__)
		SYSTEM_INFO sysinfo;
		GetSystemInfo(&sysinfo);
		num_processors = sysinfo.dwNumberOfProcessors;
#elif defined(_SC_NPROCESSORS_CONF)
		num_processors = sysconf(_SC_NPROCESSORS_CONF);
#elif defined(HW_NCPU)
		int req[] = { CTL_HW, HW_NCPU };
		size_t len = sizeof(num_processors);
		v = sysctl(req, 2, &num_processors, &len, NULL, 0);
#else
		num_processors = 1;
#endif
	
	if (num_processors < 4)
	{
		printf("num_processors < 4\n");
		return 0;
	}

	SHA2_INTERFACE::getInstance(cmdline.sha2type);

	ProxyClient *pClient = ProxyClient::getInstance();
	pClient->init(cmdline.ip,cmdline.port,num_processors);
	//client.init("10.9.43.2",10086,3*tnum);
	pClient->start();

	uint32 timerPrintDetails = GetTickCount() + 8000;
	uint32 miningStartTime = time(NULL);
	bool bStart = false;
	vector<MinerThread*> v_miner;

	while (1)
	{
		if (cmdline.bStat)
		{
			uint32 currentTick = GetTickCount();
			if( currentTick >= timerPrintDetails )
			{
				// print details only when connected
				uint32 passedSeconds = time(NULL) - miningStartTime;
				double collisionsPerMinute = 0.0;
				if( passedSeconds > 5 )
				{
					collisionsPerMinute = (double)MinerThread::totalCollisionCount / (double)passedSeconds * 60.0;
				}
				printf("collisions/min %.4lf,collision total %d,Shares total %d\n",collisionsPerMinute,MinerThread::totalCollisionCount,MinerThread::totalShareCount);
				timerPrintDetails = currentTick + 8000;
			}
		}

		uint32 cur_hour = ProxyClient::cur_hour;

		if (cur_hour == 6 || cur_hour == 22)
		{
			if (bStart)
			{
				stopMiner(v_miner);
				bStart = false;
			}

		}

		if (getWho() > 0)
		{
			if (cur_hour > 6 && cur_hour < 22)
			{
				if (bStart)
				{
					stopMiner(v_miner);
					bStart = false;					
				}

			}
		}
		else
		{
			if (cur_hour > 6 && cur_hour < 22)
			{
				if (!bStart)
				{
					uint32 thread_num = num_processors/2;
					startMiner(thread_num,cmdline,v_miner);
					bStart = true;
				}
			}
		}

		if (cur_hour == 22)
		{
			if (!bStart)
			{
				uint32 thread_num = num_processors/5*4;
				startMiner(thread_num,cmdline,v_miner);
				bStart = true;
			}

#ifdef __WIN32__
			Sleep(1000*3600);
#else
			sleep(3600);
#endif
		}
		
		Sleep(1000);	
	}



	pClient->join();

#ifdef __WIN32__
	WSACleanup( );
#endif
	return 0;
}