Exemplo n.º 1
0
 double SkTime::GetNSecs() {
     auto now = std::chrono::high_resolution_clock::now();
     std::chrono::duration<double, std::nano> ns = now.time_since_epoch();
     return ns.count();
 }
Exemplo n.º 2
0
QString OAuth::_geneNonce() {
	auto t = std::chrono::system_clock::now();
	auto t2 = std::chrono::duration_cast<std::chrono::microseconds>(t.time_since_epoch());
	return QString("%1").arg(t2.count());
}
    }
    else
    {
        return v == MISSING;
    }
}


auto date_xlt = [](const char * str) -> real_type
{
    std::tm parsed = {0};

    strptime(str, "%Y-%m-%d %T", &parsed);

    const auto tp = std::chrono::system_clock::from_time_t(std::mktime(&parsed));
    const auto days_since_1900 = std::chrono::duration_cast<std::chrono::hours>(tp.time_since_epoch()).count() / 24;

    return days_since_1900;
};

/*
 * generic pattern converter for loadtxt
 */
auto from_list_xlt = [](const std::vector<std::string> & patterns, const char * str) -> real_type
{
    auto matched_it = std::find_if(patterns.cbegin(), patterns.cend(),
        [&str](const std::string & what)
        {
            return strcmp(what.c_str(), str) == 0;
        }
    );
Exemplo n.º 4
0
uint32 WorldTimer::getMSTime()
{
    static auto const start_time = std::chrono::system_clock::now();
    return static_cast<uint32>((std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()) - std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch())).count());
}
Exemplo n.º 5
0
extern long timeGetTime() {
    auto start = std::chrono::system_clock::now();
    return std::chrono::duration_cast<std::chrono::milliseconds>(start.time_since_epoch()).count();
}
Exemplo n.º 6
0
 uint64_t millisecondsSinceEpoch() {
   auto now = std::chrono::steady_clock::now();
   return std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
 }
// 2D simplex noise
double PerlinNoise::noise2D(double xin, double yin)
{
	if (!initialized)
	{
		initialized = true;
		auto now = std::chrono::system_clock::now();
		auto duration = now.time_since_epoch();
		auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
		init((unsigned int)millis % INT_MAX);
	}

	double n0, n1, n2;
	// Noise contributions from the three corners
	// Skew the input space to determine which simplex cell we're in
	double F2 = 0.5*(sqrt(3.0) - 1.0);
	double s = (xin + yin)*F2;
	// Hairy factor for 2D
	int i = fastfloor(xin + s);
	int j = fastfloor(yin + s);
	double G2 = (3.0 - sqrt(3.0)) / 6.0;
	double t = (i + j)*G2;
	double X0 = i - t;
	// Unskew the cell origin back to (x,y) space
	double Y0 = j - t;
	double x0 = xin - X0;
	// The x,y distances from the cell origin
	double y0 = yin - Y0;
	// For the 2D case, the simplex shape is an equilateral triangle.
	// Determine which simplex we are in.
	int i1, j1;
	// Offsets for second (middle) corner of simplex in (i,j) coords
	if (x0>y0) { i1 = 1; j1 = 0; }
	// lower triangle, XY order: (0,0)->(1,0)->(1,1)
	else { i1 = 0; j1 = 1; }
	// upper triangle, YX order: (0,0)->(0,1)->(1,1)
	// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
	// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
	// c = (3-sqrt(3))/6
	double x1 = x0 - i1 + G2;
	// Offsets for middle corner in (x,y) unskewed coords
	double y1 = y0 - j1 + G2;
	double x2 = x0 - 1.0 + 2.0 * G2;
	// Offsets for last corner in (x,y) unskewed coords
	double y2 = y0 - 1.0 + 2.0 * G2;
	// Work out the hashed gradient indices of the three simplex corners
	int ii = i & 255;
	int jj = j & 255;
	int gi0 = perm[ii + perm[jj]] % 12;
	int gi1 = perm[ii + i1 + perm[jj + j1]] % 12;
	int gi2 = perm[ii + 1 + perm[jj + 1]] % 12;
	// Calculate the contribution from the three corners
	double t0 = 0.5 - x0*x0 - y0*y0;
	if (t0<0) n0 = 0.0;
	else {
		t0 *= t0;
		n0 = t0 * t0 * dot(grad3[gi0], x0, y0);
		// (x,y) of grad3 used for 2D gradient
	}
	double t1 = 0.5 - x1*x1 - y1*y1;
	if (t1<0) n1 = 0.0;
	else {
		t1 *= t1;
		n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
	}

	double t2 = 0.5 - x2*x2 - y2*y2;
	if (t2<0) n2 = 0.0;
	else {
		t2 *= t2;
		n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
	}
	// Add contributions from each corner to get the final noise value.
	// The result is scaled to return values in the interval [-1,1].
	//std::cout << (70.0 * (n0 + n1 + n2)) << '\n';
	return 70.0 * (n0 + n1 + n2);
}
Exemplo n.º 8
0
uint64_t CTimeMeter::GetCurrentClockTimeMS()
{
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
    return (uint64_t)time.count();
}
Exemplo n.º 9
0
int main(int argc, char *argv[])
{
	NRTSimulator::TCmdArgParser argParser(argc, argv);

	std::vector<std::shared_ptr<NRTSimulator::TTask>> tasks =
	            NRTSimulator::TTaskFileParser(!argParser.IsCountingUsed()).Parse(
	                argParser.GetTaskSpecFileName());

	if (argParser.IsCountingUsed()) {
		std::cout << "Estimate convert rate for counting task..." << std::endl;
		NRTSimulator::TCountingTask::EstimateConvertRate();
	}

	std::cout << "Responce time analysis..." << std::endl;

	NRTSimulator::TRTA rta(tasks);
	rta.Compute();

	for (size_t taskNumber = 0; taskNumber < tasks.size(); ++ taskNumber) {
		if (rta.CheckIsShedulable(taskNumber)) {
			std::cout << tasks[taskNumber]->GetName() << ": worst case response time "
			          << rta.GetWorstCaseResponceTime(taskNumber) << std::endl;
		} else {
			std::cout << tasks[taskNumber]->GetName() << ": is not schedulable" <<
			          std::endl;
		}
	}

	std::cout << "Simulation..." << std::endl;

	auto start = std::chrono::high_resolution_clock::now() + TASK_OFFSET;
	auto end = start + std::chrono::seconds(argParser.GetSimulationTime());

	std::vector<pthread_t> threads(tasks.size());

	std::cout << "Run real time tasks..." << std::endl;

	for (size_t i = 0; i < tasks.size(); ++i) {
		tasks[i]->Run(std::chrono::duration_cast<std::chrono::nanoseconds>
		              (start.time_since_epoch()).count(),
		              std::chrono::duration_cast<std::chrono::nanoseconds>
		              (end.time_since_epoch()).count());
	}


	std::cout << "Wait while simulation running..." << std::endl;


	for (size_t i = 0; i < threads.size(); ++i) {
		tasks[i]->Join();
		std::cout << tasks[i]->GetName() << ": worst case response time " <<
		          tasks[i]->GetWorstCaseResponceTime() << std::endl;
	}

	if (argParser.IsPlotNeeded()) {
		std::cout << "Ploting..." << std::endl;

		for (const auto & task : tasks) {
			NRTSimulator::TCDFPlot().Plot(task->GetResponceTimes(), task->GetName());
		}
	}


	std::cout << "Worst case kernel latency: " <<
	          rta.EstimateWorstCaseKernellLatency() << std::endl;


	if (!argParser.GetOutputDirectory().empty()) {
		std::cout << "Output result in '" << argParser.GetOutputDirectory() <<
		          "' directory..." << std::endl;
		NRTSimulator::TOutput(argParser.GetOutputDirectory()).Write(tasks);
	}

	return 0;
}
Exemplo n.º 10
0
 ExpiryTimerImpl::Milliseconds ExpiryTimerImpl::convertToTime(Milliseconds delay)
 {
     const auto now = std::chrono::system_clock::now();
     return std::chrono::duration_cast< Milliseconds >(now.time_since_epoch()) + delay;
 }
int _tmain(int argc, _TCHAR* argv[])
{
	// seed value
	auto curTime = std::chrono::system_clock::now();
	auto duration = curTime.time_since_epoch();
	auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
		

	std::mt19937 mtRand(millis);
	std::uniform_int_distribution<__int64> dist1(0, 1);

	char element[4][4];

	for (int i = 0; i < 4; ++i)
	for (int j = 0; j < 4; ++j)
		element[i][j] = '0';

	for (int i = 0; i < 4; ++i)
	{
		for (int j = 0; j < 4; ++j)
		{
			element[i][j] = dist1(mtRand) ? '*' : element[i][j];

			if (element[i][j] == '*')
			{
				for (int i2 = i - 1; i2 < i + 1; ++i2)
				{
					for (int j2 = j - 1; j2 < j + 1; ++j2)
					{	
						if (j2 > -1 && i2 > -1)
						{
							if (element[i2][j2] != '*')
							{
								element[i2][j2] += 1;
							}
						}
					}
					
				}
			}
		}
	}

	for (int i3 = 0; i3 < 4; ++i3)
	{
		for (int j3 = 0; j3 < 4; ++j3)
		{
			std::cout << element[i3][j3];
		}
		
		std::cout << std::endl;
	}

	
	

	//for (int i = 0; i < 4; ++i)
	//{
	//	for (int k = 0; k < 4; ++k)
	//	{
	//		//element[i][k] = *std::to_string(dist1(mtRand)).c_str();
	//		//element[i][k] = dist1(mtRand) ? '*' : '.';
	//		

	//		std::cout << i << k << ' ';
	//		//std::cout << element[i][k] << ' ';
	//	}


	//	std::cout << std::endl;

	//}

	system("pause");
	
	return 0;
}
Exemplo n.º 12
0
uint64_t X509_Time::time_since_epoch() const
   {
   auto tp = this->to_std_timepoint();
   return std::chrono::duration_cast<std::chrono::seconds>(tp.time_since_epoch()).count();
   }
Exemplo n.º 13
0
long Time::getTime()
{
    auto t = std::chrono::high_resolution_clock::now();

    return std::chrono::duration_cast<std::chrono::nanoseconds>(t.time_since_epoch()).count();
}