精华内容
下载资源
问答
  • 纳秒微秒的计算

    千次阅读 2020-09-23 10:52:18
    秒的换算:ms(毫秒),μs(微秒),ns(纳秒),ps(皮秒) 皮秒 皮秒,符号ps(英语:picosecond ). 1皮秒等于一万亿分之一秒(10-12秒) 1,000 皮秒 = 1纳秒 1,000,000 皮秒 = 1微秒 1,000,000,000 皮秒 = 1毫秒 1,000,...

     

    秒的换算:ms(毫秒),μs(微秒),ns(纳秒),ps(皮秒)

     

    皮秒

    皮秒,符号ps(英语:picosecond ).
    1皮秒等于一万亿分之一秒(10-12秒)

    1,000 皮秒 = 1纳秒 

    1,000,000 皮秒 = 1微秒 

    1,000,000,000 皮秒 = 1毫秒 

    1,000,000,000,000 皮秒 = 1秒



    纳秒

    纳秒,符号ns(英语:nanosecond ).
    1纳秒等于十亿分之一秒(10-9秒)

    1 纳秒 = 1000皮秒 

    1,000 纳秒 = 1微秒 

    1,000,000 纳秒 = 1毫秒 

    1,000,000,000 纳秒 = 1秒 


    微秒

    微秒,符号μs(英语:microsecond ).
    1微秒等于一百万分之一秒(10-6秒)

    0.000 001 微秒 = 1皮秒 

    0.001 微秒 = 1纳秒 

    1,000 微秒 = 1毫秒 

    1,000,000 微秒 = 1秒 


    毫秒

    毫秒,符号ms(英语:millisecond ).
    1毫秒等于一千分之一秒(10-3秒)

    0.000 000 001 毫秒 = 1皮秒 

    0.000 001 毫秒 = 1纳秒 

    0.001 毫秒 = 1微秒 

    1000 毫秒 = 1秒

     

    展开全文
  • 纳秒微秒级时间

    千次阅读 2012-09-25 15:04:23
    纳秒微秒级时间 转自:AlbertZ316的专栏  http://blog.csdn.net/albertz316/article/details/7193579 1秒 = 1000毫秒 = 1000 000微秒 = 1000 000 000 纳秒 大家都知道windows下的时间计数器提供的是毫秒...

    纳秒与微秒级时间

    转自:AlbertZ316的专栏  http://blog.csdn.net/albertz316/article/details/7193579

    1秒 = 1000毫秒 = 1000 000微秒 = 1000 000 000 纳秒

    大家都知道windows下的时间计数器提供的是毫秒级的时间计数。那么怎么提供一个精度更高的计数器呢。在Intel   Pentium以上级别的CPU中,有一个称为“时间戳(Time   Stamp)”的部件,它以64位无符号整型数的格式,记录了自CPU上电以来所经过的时钟周期数。对于一个主频为1GHz的CPU,则其一个时钟周期就是一纳秒。由于目前的CPU主频都非常高,因此这个部件可以达到 纳秒级的计时精度。在Pentium以上的CPU中,提供了一条机器指令RDTSC(Read   Time   Stamp   Counter)来读取这个时间戳的数字,并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数 返回值的寄存器,所以我们可以把这条指令看成是一个普通的函数调用。像这样:     
        
      inline   unsigned   __int64   GetCPUCycleCount()     
      {     
      __asm   RDTSC     
      }  

    如果RDTSC不被C++的内嵌汇编器直接支持,我们还可以要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31,如下:     
        
      inline   unsigned   __int64   GetCPUCycleCount()     
      {     
      __asm   _emit   0x0F     
      __asm   _emit   0x31     
      }     
        
      以后在需要计数器的场合,可以像使用普通的Win32   API一样,调用两次GetCPUCycleCount函数,比较两个返回值的差,然后利用CPU的时钟周期的差数就可以计算出一个纳秒级的计时。公式如下  

    时间   =   CPU时钟周期数差数   /   CPU主频速率(Hz)

    vc中的实现代码如下:

    // 纳秒 微秒 时间精度的实现

    #include <stdio.h>
    #include <windows.h>
    #include <mmsystem.h>                   // 使用timeGetTime() 需要包含此头文件
    #pragma comment(lib,"winmm.lib")        // 使用timeGetTime() 需要包含此lib

    // 微秒级
    class MicrosecondTimer
    {
    public:
        inline MicrosecondTimer()
        {
            QueryPerformanceFrequency(&freq);
        }
        inline void Start()
        {
            QueryPerformanceCounter(&startCount);
        }
        // 返回微秒 
        inline UINT64 Stop()          
        {
            QueryPerformanceCounter(&endCount);
            UINT64 decrease = endCount.QuadPart - startCount.QuadPart;
            double elapsed  decrease / (double)freq.QuadPart;
            return UINT64(elapsed*1000000);
        }
    private:
        LARGE_INTEGER freq;
        LARGE_INTEGER startCount;
        LARGE_INTEGER endCount;
    };


    // 纳秒级
    // 连续调用start和stop所需的时间大概是62ns
    class NanosecondTimer
    {

    public:
        inline NanosecondTimer()
        {  
            startT = 0;
            frequency = CalCPUFrequency();
        }
        //得到计算机启动到现在的时钟周期
        static inline  UINT64 GetCPUCycleCount(void)
        {
            //      __asm   _emit   0x0F
            //      __asm   _emit   0x31
            __asm RDTSC
        }

        // 得到CPU的频率
        static inline double CalCPUFrequency()
        {
            LARGE_INTEGER liFreq,liStart,liEnd;
            QueryPerformanceFrequency(&liFreq);      
            QueryPerformanceCounter(&liStart);
            UINT64 startCounts = GetCPUCycleCount();
            Sleep(1000);
            QueryPerformanceCounter(&liEnd);
            UINT64 endCounts = GetCPUCycleCount() - startCounts;
            double elapsed =  (liEnd.QuadPart - liStart.QuadPart) / (double)(liFreq.QuadPart);     // 微秒级精度
            double freq = endCounts / (elapsed*1000000);
            return freq;
        }
        inline void Start()
        {
            startT = GetCPUCycleCount();
        }
        inline UINT64 Stop()
        {
            UINT64 endT = GetCPUCycleCount() - startT;
            return UINT64( endT * 1000 / frequency );
        }
        inline double Frequency()
        {
            return frequency;
        }

    private:
        UINT64 startT;
        double frequency;   // MHz/s
    };


    int main(int argc, CHAR* argv[])
    {

        NanosecondTimer NT;
        MicrosecondTimer MT;
        DWORD t1 = 0, t2 = 0;
        UINT64 ns = 0 ;
        UINT64 ms =  0;

        for (int i = 0; i < 10 ; i++ )
        {
            NT.Start();
            MT.Start();
            Sleep(1);
            ms = MT.Stop();
            ns = NT.Stop();
            printf("CPU:%f; %f \n %I64d; %I64d; \r\n",NT.CalCPUFrequency(),cpuc.GetCpuFrequency() , ns, ms);
        }
        getchar();
        return 0;
    }

    事实上在windows中每次调用代码指令的时间都不稳定,所以这是很难真正的精确到纳秒级的。windows下最多只能提供微秒级的精确度。

    展开全文
  • 皮秒,符号ps(英语:picosecond ...1,000,000 皮秒 = 1微秒 μs 1,000,000,000 皮秒 = 1毫秒 μs 1,000,000,000,000 皮秒 = 1秒 s 纳秒纳秒,符号ns(英语:nanosecond ).1纳秒等于十亿分之一秒(10-9秒) ...

    皮秒,符号ps(英语:picosecond ).
    1皮秒等于一万亿分之一秒(10-12秒)

    1,000 皮秒 = 1纳秒 ns
    1,000,000 皮秒 = 1微秒 μs
    1,000,000,000 皮秒 = 1毫秒 μs
    1,000,000,000,000 皮秒 = 1秒 s 

    纳秒

    纳秒,符号ns(英语:nanosecond ).
    1纳秒等于十亿分之一秒(10-9秒)

    1 纳秒 = 1000皮秒 
    1,000 纳秒 = 1微秒 μs
    1,000,000 纳秒 = 1毫秒 ms
    1,000,000,000 纳秒 = 1秒 s
    

     

    微秒

    微秒,符号μs(英语:microsecond ).
    1微秒等于一百万分之一秒(10-6秒)

    0.000 001 微秒 = 1皮秒 ps
    0.001 微秒 = 1纳秒 μs
    1,000 微秒 = 1毫秒 ms
    1,000,000 微秒 = 1秒 s


    毫秒

    毫秒,符号ms(英语:millisecond ).
    1毫秒等于一千分之一秒(10-3秒)

    0.000 000 001 毫秒 = 1皮秒 ps
    0.000 001 毫秒 = 1纳秒 ns
    0.001 毫秒 = 1微秒 ms
    1000 毫秒 = 1秒s

     

    在典型PC机上各种操作的近似时间:

    执行典型指令                 1/1,000,000,000 秒 =1 纳秒 
    从一级缓存中读取数据            0.5 纳秒 
    分支预测错误                 5 纳秒 
    从二级缓存中读取数据            7 纳秒 
    互斥锁定 / 解锁              25 纳秒 
    从主存储器中读取数据             100 纳秒  
    在 1Gbps 的网络中发送 2KB 数据      20,000 纳秒 
    从内存中读取 1MB 数据            250,000 纳秒 
    从新的磁盘位置读取数据 ( 寻轨 )      8,000,000 纳秒 
    从磁盘中读取 1MB 数据            20,000,000 纳秒 
    在美国向欧洲发包并返回            150 毫秒 =150,000,000 纳秒 

    转载于:https://www.cnblogs.com/yangxunwu1992/p/5769533.html

    展开全文
  • /** * Linux高精度struct timespec(精确到纳秒)struct timeval(精确到微秒) * */ class TimesUtil { public: /** * 获取当前系统时间(精确到纳秒)tv_nsec精确到纳秒(编译时加上-lrt) * */ static inline int64...

    1、找一个比较全的时间工具类太难了,没人总结啊(适用于linux)。

    #include <ctime>
    #include <stdint.h>
    #include <iostream>
    #include <string>
    #include <sys/time.h>
    
    using std::string;
    
    /**
     * Linux高精度struct timespec(精确到纳秒)和struct timeval(精确到微秒)
     * */
    
    class TimesUtil
    {
    public:
    	/**
    	 * 获取当前系统时间(精确到纳秒)tv_nsec精确到纳秒(编译时加上-lrt)
    	 * */
    	static inline int64_t getTimeNs()
    	{
    		struct timespec ts;
    		clock_gettime(CLOCK_REALTIME, &ts);
    		return ts.tv_sec*1000000000 + ts.tv_nsec;
    	}
    	/**
    	 * 获取当前系统时间(精度微秒)tv_usec精确到微秒
    	 * */
    	static inline int64_t getTimeUs()
    	{
    		struct timeval tv;
    		gettimeofday(&tv, NULL);
    		return tv.tv_sec*1000000 + tv.tv_usec;
    	}
    	/**
    	 * 获取当前系统时间(精度毫秒)tv_usec精确到微秒
    	 * */
    	static inline int64_t getTimeMs()
    	{
    		struct timeval tv;
    		gettimeofday(&tv, NULL);
    		return tv.tv_sec*1000 + tv.tv_usec/1000;
    	}
    	/**
    	 * 获取当前系统时间(精度秒),YY年 mm月 dd日 HH时 MM分 SS秒
    	 * */
    	static inline string getDateTime()
    	{
    		time_t now = time(0);
    		tm  *ltm = localtime(&now);
    
    		char myDate[40],myTime[40], ims[10];
    		strftime(myDate, 40, "%Y-%m-%d", ltm);
    		strftime(myTime, 40, " %H:%M:%S", ltm);
    		
    		return string(myDate) + string(myTime);
    	}
    	/**
    	 * 根据纳秒时间返回 交易所时间格式:HHMMSSsss,其中LocalTime精确到纳秒
    	 **/
        static int getLocalTime_t(int64_t LocalTime)
    	{
            	time_t  local_time = LocalTime /1000000000;
            	struct tm*  tm;
            	tm = localtime(&local_time);
                int time_=0;
            	if(LocalTime /1000000000 > 0)
    		    {
    			     time_ = (tm->tm_hour*10000+tm->tm_min*100+tm->tm_sec)*1000+LocalTime%1000000000/1000000;
    		    }else
    		    {
    			    time_ = LocalTime%1000000000/1000000;
    		    }
    		return time_;	//精度毫秒 
    	}
    };

    展开全文
  • auto start_ = std::chrono::high_resolution_clock::now(); /* some code */ auto end_ = std::chrono::high_resolution_clock::now(); fprintf(stdin, %s last<%" PRIu64 ">\n", "some code ", ...
  • 秒 毫秒 微秒 纳秒 皮秒

    千次阅读 2013-10-22 10:16:20
    0.001 微秒 = 1纳秒 微秒 1,000 微秒 = 1毫秒 1,000,000 微秒 = 1秒 1s = 1000ms 1ms = 1000μs 1μs = 1000ns 1ns = 1000ps 1秒(s) = 1000 毫秒(ms) = 1,000,000 微秒(μs) = 1,000,000,000 纳秒(ns) = 1,...
  • 纳秒微秒毫秒 秒 ns、us、ms、s 时间单位之间的换算 1000000000纳秒=1秒 (9个0) 1000000微秒=1秒 (6个0) 1000毫秒=1秒 (3个0)
  • 毫秒,微秒纳秒

    千次阅读 2016-03-01 16:23:20
    毫秒,微秒纳秒
  • C++微秒(纳秒)计时器

    2012-10-24 21:39:04
    一个用C++实现的微秒计时器,文中代码出乘以10^6次方是微秒计时器,乘10^9次方则是纳秒计时器,可用于检测打印或复制语句执行时间
  • According to the SimpleDateFormat class documentation, Java does not support time granularity above milliseconds in its date patterns.So, a date string like2015-05-09 00:10:23.999750900 // The last 9 ...
  • tdengine 2.20版发布直接支持纳秒时间戳了,毫秒、微秒纳秒,建库时需要用 precision "ms"、precision "us"、precision "ns" 来进行标注,如果传入的时间戳不满足位数位数要求则报错。做了一个简单的格式转换函数...
  • 时间单位:   秒(second),时间单位 : s,   毫秒(millisecond),时间单位:ms ...   1μs【微秒】 = 1000ns【纳秒】   1ns 【纳秒】= 1000ps【皮秒】 1秒(s) = 1000 毫秒(ms) = 1,000,000 微秒(μs) = 1,0
  • 秒 毫秒 微秒 纳秒 Hz KHz MHz GHz

    千次阅读 2018-12-29 16:29:56
    1S = 1000000 微秒 u 1S = 1000000000 纳秒 n 1S = 1000000000000 皮秒 p 。。。 1Hz 电磁脉冲 每秒钟周期震动 1 次 1KHz = 1000次 / 1秒 1MHz = 1000 000次 / 1秒 1MHz = 1000 000 000次 / 1秒 ...
  • 秒 毫秒 微秒 纳秒 皮秒 飞秒

    万次阅读 2007-06-21 17:04:00
    millisecond 1ms (毫秒) 1毫秒=0.001秒=10-3秒 microsecond 1μs (微秒) 1微秒=0.000001=10-6秒 nanosecond 1ns (纳秒) 1纳秒=0.0000000001秒=10-9秒 picosecond 
  • ** 秒、毫秒、微秒纳秒以及赫兹对应换算表 ** Hz KHz MHz s ms us ns 1 103 106 109
  • 1s(秒)=10^3ms(毫秒)=10^6μs(微秒)=10^9ns(纳秒)=10^12ps(皮秒)=10^15fs(飞秒)=10^18as(阿秒)=10^21zm(仄秒)=10^24ym(幺秒)  秒 seconds  毫秒 millisecond 微秒 microseconds 纳秒 nanosecond...
  • 1毫微秒纳秒级全光纤掺-光纤激光器(2.05微米)。
  • 1s=1000ms=1000000微秒=1000000000纳秒=1000000000000皮秒=10^15飞秒=10^18啊秒=10^21仄秒=10^24幺秒 1s=10^3ms(毫秒)=10^6μs(微秒)=10^9ns(纳秒)=10^12ps(皮秒)=10^15fs(飞秒)=10^18as(阿秒)=10^21zm(仄秒)=...
  • 秒也是一个的时间单位,0.000 000 001 毫秒 = 1皮秒,0.000 001 毫秒 = 1纳秒,0.001 毫秒 = 1微秒,1毫秒等于0。001秒,60秒等于1分钟,60分钟等于1小时,24小时等于1天,7天等于1星期,30,31,28或29天等于1月,...
  • * 毫秒,微秒,纳秒 **/ public class TestTIme { /** * System.nanoTime * * @param args */ public static void main(String[] args) { Timestamp timestamp; for (int i = 0; i ; i++) { timestamp=...
  • 秒 毫秒 微秒 纳秒 皮秒

    千次阅读 2014-06-02 20:17:28
    1s=1000ms=1000000微秒=1000000000纳秒=1000000000000皮秒=10^15飞秒=10^18啊秒=10^21仄秒=10^24幺秒 1s=10^3ms(毫秒)=10^6μs(微秒)=10^9ns(纳秒)=10^12ps(皮秒)=10^15fs(飞秒)=10^18as(阿秒)=10^21zm(仄秒)=10^...
  • 毫秒 millisecond 1ms 1毫秒=0.001秒=10-3秒 微秒 microsecond 1μs 1微秒=0.000001=10-6秒 纳秒 nanosecond 1ns ...
  • --- 获取纳秒级别的 --- t1.c源码: #include #include #include int main(void) { struct timespec time_start={0, 0},time_end={0, 0}; clock_gettime(CLOCK_REALTIME, &time_start); printf("start time...
  • 微秒, 纳秒,毫秒, 时间单位换算[转]

    万次阅读 2017-11-08 20:52:52
    秒,时间单位,符号s(英语:second):0.000 000 001 毫秒 = 1皮秒0.000 001 毫秒 = 1纳秒0.001 毫秒 = 1微秒1毫秒=0.001秒60秒=1分钟60分钟=1小时24小时=1天7天=1星期30,31,28或29天=1月12月=1年100年=1世纪。微秒...
  • 总结了常用的四种方法。包括: 方法一 利用 SYSTEMTIME 方法二 利用 GetTickCount()函数 方法三 使用clock()函数 方法四 获取高精度时间差 个人感觉还是很清晰明了的。希望对大家有用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,542
精华内容 3,416
关键字:

纳秒和微秒