mktime will convert a struct tm into a Unix timestamp in seconds. Multiply by 1000 and add the extra milliseconds to the result.

Function time_t time(time_t* timer) returns the number of seconds elapsed since 00:00 hours, Jan 1, 1970 UTC. In addition, if the input argument timer != NULL, then the function also sets this argument to the same value (so you probably have no reason to call it with anything else but NULL).

Function struct tm* localtime(const time_t* timer) takes the number of seconds elapsed since 00:00 hours, Jan 1, 1970 UTC, and returns a structure that represents the equivalent time & date. If you're working on a multi-threaded application, then please note that this function is not thread safe.

As to your question - is there any way for converting milliseconds to time & date - yes, but:

• Take into consideration that the milliseconds will be considered as of 00:00 hours, Jan 1, 1970 UTC.
• Since the time_t type is 32-bit long, you will not be able to convert 4G*1000 milliseconds or more.

Here is a function for converting milliseconds to time & date:

struct tm* GetTimeAndDate(unsigned long long milliseconds)
{
    time_t seconds = (time_t)(milliseconds/1000);
    if ((unsigned long long)seconds*1000 == milliseconds)
        return localtime(&seconds);
    return NULL; // milliseconds >= 4G*1000
}

You just need to use regular subtraction, then multiply by 86400000.

Date

(Date__c - DATE(1970, 1, 1)) * 86400000

DateTime

(Date_Time__c - DATETIMEVALUE("1970-01-01 00:00:00")) * 86400000

You're probably trying to convert to a UNIX-like timestamp, which are in UTC:

yourDateTime.ToUniversalTime().Subtract(
    new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
    ).TotalMilliseconds

This also avoids summertime issues, since UTC doesn't have those.

Yes, this program has likely used less than a millsecond. Try using microsecond resolution with timeval.

e.g:

Copy#include <stdio.h>
#include <sys/time.h>

int main(void) {
  struct timeval stop, start;
  gettimeofday(&start, NULL);
  //do stuff
  gettimeofday(&stop, NULL);
  printf("took %lu us\n", (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec);
  return 0;
}

You can then query the difference (in microseconds) between stop.tv_usec - start.tv_usec. Note that this will only work for subsecond times (as tv_usec will loop). For the general case use a combination of tv_sec and tv_usec.

Edit 2016-08-19

A more appropriate approach on system with clock_gettime support would be:

Copystruct timespec start, end;
clock_gettime(CLOCK_MONOTONIC_RAW, &start);
//do stuff
clock_gettime(CLOCK_MONOTONIC_RAW, &end);

uint64_t delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000;

In Python 3 this can be done in 2 steps:

1. Convert timestring to datetime object
2. Multiply the timestamp of the datetime object by 1000 to convert it to milliseconds.

For example like this:

from datetime import datetime

dt_obj = datetime.strptime('20.12.2016 09:38:42,76',
                           '%d.%m.%Y %H:%M:%S,%f')
millisec = dt_obj.timestamp() * 1000

print(millisec)

Output:

1482223122760.0

strptime accepts your timestring and a format string as input. The timestring (first argument) specifies what you actually want to convert to a datetime object. The format string (second argument) specifies the actual format of the string that you have passed.

Here is the explanation of the format specifiers from the official documentation:

• %d - Day of the month as a zero-padded decimal number.
• %m - Month as a zero-padded decimal number.
• %Y - Year with century as a decimal number
• %H - Hour (24-hour clock) as a zero-padded decimal number.
• %M - Minute as a zero-padded decimal number.
• %S - Second as a zero-padded decimal number.
• %f - Microsecond as a decimal number, zero-padded to 6 digits.

To convert unix timestamp to datetime, you can use datetime.fromtimestamp(). The only problem, that your timestamp is in miliseconds, but function expect timestamp in seconds. To cut miliseconds you can divide timestamp to 1000.

Code:

from datetime import datetime

a = 1557975599999
date = datetime.fromtimestamp(a // 1000)
print(date)

Output:

2019-05-16 05:59:59

Upd.

@Daniel in comments noticed that fromtimestamp() accept floats, so we can save miliseconds from original timestamp. All we need is just to remove one symbol :D

date = datetime.fromtimestamp(a / 1000)

It appears to me that the simplest way to do this is

import datetime

epoch = datetime.datetime.utcfromtimestamp(0)

def unix_time_millis(dt):
    return (dt - epoch).total_seconds() * 1000.0