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();
}
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;
}
);
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());
}
extern long timeGetTime() {
auto start = std::chrono::system_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(start.time_since_epoch()).count();
}
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);
}
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();
}
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;
}
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;
}
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();
}
long Time::getTime()
{
auto t = std::chrono::high_resolution_clock::now();
return std::chrono::duration_cast<std::chrono::nanoseconds>(t.time_since_epoch()).count();
}
