novo mql4 fornecendo milissegundos em timestamps.... - página 3

Novo comentário
 

Todos,

A questão aqui é obter o carimbo de hora do tick, e não a hora em que o tick chega ao terminal usando GetTickCount() (ou seja, sempre que a função start() for chamada), como sugerido.

MarketInfo(Symbol(), MODE_TIME) retorna o carimbo de hora do tick como enviado do servidor do corretor na alimentação de dados.

Atenciosamente

VS

 
AnkaSoftware:

Todos,

A questão aqui é obter o carimbo de hora do tick, e não a hora em que o tick chega ao terminal usando GetTickCount() (ou seja, sempre que a função start() for chamada), como sugerido.

MarketInfo(Symbol(), MODE_TIME) retorna o carimbo de hora do tick como enviado do servidor do corretor na alimentação de dados.

Infelizmente, isso será apenas com uma precisão de 1 segundo.
 
ubzen:

1) GetTickCount(), deve trabalhar ao vivo. Sem sentido em dados históricos.

2) Mesmo mt5_dados não são salvos em milissegundos. No entanto, no_problem Live.

3) Não vejo aonde você quer chegar com isso. Se é o mesmo tempo em milissegundos, então ter milissegundos não ajudaria. Se for diferente em milissegundos do que GetTickCount() pode ajudar. Ajuda no sentido de que seu código processa o tick atual em menos de um milissegundo. O quão importante tudo depende do que você está tentando realizar... eu acho.


Obrigado a todos por suas respostas. Havia um indicador que foi afixado na base de código, Rogue Tick Detector. Mas ele ainda não foi aprovado. Você pode encontrá-lo aqui, por enquanto.

A idéia básica é que há momentos em que o tick atual tick0 virá com um carimbo de tempo posterior ao do tick-1 anterior. Mas o preço não seria mais acionável, mas a EA ou o comerciante humano só saberia disso depois do fato. Estava fazendo com que eventos baseados no preço fossem acionados erroneamente. O detector de carrapatos falsos foi capaz de assinalar estes carrapatos falsos e impedir a EA de agir sobre eles (esperar pelo próximo carrapato 'bom').

O método atual de captura de timestmps dos carrapatos, MarketInfo(Symbol(), MODE_TIME), não retorna timestamps de milissegundos. Por isso, vim aqui para ver se existiam alternativas que não estávamos vendo.

As EAs, que incluem as funções de detecção de carrapatos, todas rodam em VPS em Nova York com unidades SSD, Windows 2008, e normalmente são <2ms do servidor do corretor. Sem HFT ou hiperescalonamento (o tempo médio de retenção dos negócios é de aproximadamente 1 hora).

Traz-me de volta a uma de minhas perguntas originais: Então como a plataforma mt4 (e mt5) [em si] deve distinguir corretamente entre carrapatos que chegam "ao mesmo tempo"?

edita, graças ao ankasoftware por esclarecer.

 
4evermaat:


Traz-me de volta a uma de minhas perguntas originais: Então como a plataforma mt4 (e mt5) [em si] deve distinguir corretamente entre carrapatos que chegam "ao mesmo tempo"?

Você não pode ... . seu Corretor realmente lhe envia vários carrapatos que acontecem ao mesmo tempo ? ou eles apenas aumentam a contagem em 2 e enviam o último carrapato ? como você poderia saber se eles o fizeram ? você está ciente de que existe uma enorme diferença na contagem de carrapatos entre os Corretores ?
 
RaptorUK:
Você não pode . . . seu Corretor realmente lhe envia vários carrapatos que acontecem ao mesmo tempo ? ou eles apenas aumentam a contagem em 2 e enviam o último carrapato ? como você poderia saber se eles o fizeram ? você está ciente de que existe uma enorme diferença na contagem de carrapatos entre os Corretores ?


Sim, estou ciente de que corretores diferentes têm rações diferentes e a contagem de carrapatos pode ser muito diferente. Mas acontece que os carrapatos desonestos estão sendo enviados durante certos momentos, principalmente quando os negócios foram fechados com lucro. Isso estava afetando o acionamento dos fechamentos e ordens, então encontramos uma maneira de detectá-los e ignorá-los o melhor que podemos. Cheguei até a suspeitar de manipulação intencional de alimentação em algum momento por parte de alguns dos corretores.

Mas talvez devêssemos ter uma relação de contagem de carrapatos, onde contamos o total de carrapatos

Pode muito bem não afetar muitas pessoas, mas achei que os danos potenciais eram suficientes para justificar uma investigação mais aprofundada.

 
Não há nenhuma função/processo que faça exatamente o que você está pedindo [ que eu saiba ] neste momento.
4evermaatMas talvez devêssemos ter uma relação de contagem de carrapatos, onde contamos o total de carrapatos

O que você tem em mente? Como isto seria diferente do mt4 Volume? Uma proporção do que dois números [ contagem e ???].

Este assunto fica muito confuso muito rapidamente. Eu mesmo não sei tudo sobre carrapatos, nem como as metaquotas o processam, nem por que será muito crítico para alguém. Permitam-me resumir algumas de minhas observações.

1) metaQuotes diz: você quer milli_seconds time_stamp, [ eles imediatamente começam a pensar tick_data ], quem vai segurar este tick_data o corretor? você quer dizer que dizer que há 200 ticks dentro daquele minuto não é bom o suficiente para você? Você realmente quer que poupemos 200 entradas de dados porque OHLC+V não é bom o suficiente?

2) O número 1 do negociante diz: Não preciso de ninguém para salvar as informações, só quero um carimbo de tempo de milli_segundos para determinar os dados antigos.

3) comerciante número2 diz: Eu não preciso que você salve as informações, apenas me dê a capacidade de importá-las e eu obterei meus próprios dados.

4) O comerciante número3 diz: Não vejo porque é tão importante salvar e fornecer dados de carrapatos. Vamos lá, os computadores têm mais poder e memória hoje em dia, certamente meu corretor pode fornecer os dados em algum lugar.

5) o corretor diz: cara, já tenho dificuldade o suficiente para lhe dar m1 dados por mais de 3_meses o que faz você pensar que sou capaz ou disposto a fornecer tantos dados quando você se conecta ou para testes.

6) comerciante número4: não precisamos dele para testes e apenas uma pequena parte dos dados seria suficiente ao vivo, não me queixo de m1 insuficiente agora, então qual é o problema?

7) meta-cotações: ainda não, isto significa que teremos que facilitar funções que retornam milli_segundos e indicadores e tais que distinguem carrapatos ... você está tentando travar o terminal ou algo assim?

8) comerciante número5: você quer dizer que o volume não é de mercado_profundidade, mas uma contagem do número de ticks dentro de um determinado período_de_tempo :) . Você quer dizer que eu posso perder o tick? Você quer dizer que os ticks podem se perder ou atrasar no ciberespaço? Você quer dizer que o tick_count difere entre os corretores? Você quer dizer que os dados que os corretores armazenam não teriam sido os mesmos que eu teria recebido? O que é todo esse alarido sobre o tick então?

9) xxxxxxxxxxxx diz: o tick é ultra-secreto, o que é fornecido certamente é bom o suficiente, eu ajudei a projetar o gerador de tick e tenho muito pouco interesse em fornecer esse tipo de resolução. não vai acontecer.... período.

10) comerciante número6: há limitações tecnológicas, ao que pode ser fornecido, como o tick funciona, o que pode ser recebido, etc., etc. Este não é um problema de MetaTrader, mas sim uma grande quantidade de plataformas de varejo que experimentam este problema. Olhe em direção ao software institucional e esteja pronto para ganhar muito dinheiro.

Trader#3 para Trader#10: eu discordo.

Ubzen diz: eu simplesmente não sei mais o que dizer.

Ps> quase esqueci o trader#7: tudo bem, vou salvar meu próprio tique que vem ao meu terminal e programar meus próprios indicadores e tal para processar estes dados... Foi assim que interpretei a pergunta e por isso recomendei a GetTickCount().

 
ubzen:

Ps> quase esqueci o trader#7: tudo bem, vou salvar meu próprio tick que vem ao meu terminal e programar meus próprios indicadores e tal para processar estes dados... Foi assim que interpretei a pergunta e por isso recomendei o GetTickCount().

Infelizmente, isso ainda não lida com carrapatos perdidos ... na prática é impossível salvar seus próprios carrapatos, você não pode obtê-los todos e porque você vai perder alguns, a menos que este fato seja registrado, os dados salvos serão incorretos, tão potencialmente piores do que inúteis, que serão enganosos.
 
RaptorUK: Infelizmente isso ainda não lida com carrapatos perdidos ... na prática é impossível salvar seus próprios carrapatos, você não pode obtê-los todos e porque você vai perder alguns, a menos que este fato seja registrado, os dados salvos serão incorretos tão potencialmente piores do que inúteis, que será enganoso.

Espero ficar no tópico aqui :). Dito isto, imagine um corretor que envia carimbos de tempo de milissegundos a cada carrapato. Mas, então, não continue - salve esta informação em seu_ lado. Dada toda a desconfiança em relação aos corretores em geral, este corretor abriria uma investida de perguntas. Mas desta vez as pessoas têm provas em milissegundos, mas o corretor não tem registros para contra-atacar. Portanto, em algum sentido, pedir tick_data | milisegundos ou o que quer que leve aos mesmos argumentos é basicamente pedir ao corretor que salve o tick_data e que a plataforma o facilite.

Em uma segunda nota, considere os back-tests invertidos que a maioria dos ppl faz. Onde você executa uma estratégia_viva por cerca de uma semana e depois procede a um back_test naquela semana em_ordem para verificar se você obterá os mesmos resultados. Esta pessoa tem carimbos de tempo_milissegundo ao vivo e atrasos e pacotes ausentes ao vivo. Claro que, como o cartaz original, você ignora os dados que faltam e/ou descarta os carrapatos atrasados. Entretanto, quando você realiza o back-test, todos os dados do corretor com os carimbos de tempo corretos estão lá. Isto obviamente gerará resultados diferentes do que os que você acabou de receber ao vivo.

Então me diga, você foi enganado ao vivo ou está sendo enganado durante o Back_Test?

Entretanto, concordo com sua afirmação acima. Imo, tudo isso cria um conjunto de paradoxos que me leva a ficar longe de processos inter_minuciosos, tudo_conjuntado. A plataforma tem limitações, eu apenas aceito e me movo_a.

 
ubzen:
...

Entretanto, concordo com sua declaração acima. Imo, tudo isso cria um conjunto de paradoxos que me leva a ficar longe de processos inter_minuciosos, tudo_junto. A plataforma tem limitações, eu apenas aceito e me movo_a.

;-)
 
angevoyageur:

Temporizadores, Resolução de Temporizadores e Desenvolvimento de Código Eficiente

Windows Timer Resolução : Megawatts desperdiçado

Interessantes links de agradecimento, o que me levou ao Microsecond Resolution Time Services for Windows. Realizei alguns testes com base em informações dessas páginas.

Meus testes em um PC Win 7 e um VPS Windows 2012 indicam que GetTickCount() sempre tem uma resolução de 15,6 msecs (64 interrupções por segundo) independentemente da configuração do temporizador do sistema, enquanto que a resolução ao obter o tempo de milissegundos chamando as funções GetSystemTime() [ou GetLocalTime()] ou GetSystemTimeAsFileTime() é afetada pelas configurações do temporizador do sistema, e pode dar até 0,5 msec de resolução em ambas as máquinas que testei.

GetTickCount() Resolução

Aqui está o código para um script para testar a resolução GetTickCount():

// Script to test Millisecond Resolution via GetTickCount()

void OnStart() {
  uint startMsecsU = GetTickCount(), nowMsecsU;
  for (int j=0; j<1000000000; j++) {
    if ((nowMsecsU = GetTickCount()) > startMsecsU) {
      MessageBox(StringFormat("GetTickCount %u -> %u diff %u", startMsecsU, nowMsecsU, nowMsecsU - startMsecsU), "Test Millisecond Resolution via GetTickCount");
      return;
    }
}

Isto sempre dá 15 ou 16 (ou seja, 15,6) em ambas as máquinas testadas independentemente das mudanças de resolução do cronômetro do sistema mencionadas abaixo para os outros testes.

Resolução GetSystemTime()

Agora as coisas começam a ficar interessantes. Aqui está o código para um script para testar a resolução GetSystemTime():

/* Script to test Millisecond Resolution via GetSystemTime()

Windows struct for a GetSystemTime() or GetLocalTime() call:
typedef struct _SYSTEMTIME {
  WORD wYear;
  WORD wMonth;
  WORD wDayOfWeek;
  WORD wHour;
  WORD wMinute;
  WORD wSecond;
  WORD wDay;
  WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME;
*/

// MT4 equivalent struct:
struct _SYSTEMTIME {
  ushort wYear;         // 2014 etc
  ushort wMonth;        // 1 - 12
  ushort wDayOfWeek;    // 0 - 6 with 0 = Sunday
  ushort wDay;          // 1 - 31
  ushort wHour;         // 0 - 23
  ushort wMinute;       // 0 - 59
  ushort wSecond;       // 0 - 59
  ushort wMilliseconds; // 0 - 999
};

#import "kernel32.dll"
void GetSystemTime(_SYSTEMTIME &time);
#import

void OnStart() {
  _SYSTEMTIME st;
  GetSystemTime(st);
  int startMsecs = st.wMilliseconds, nowMsecs;
  for (int j=0; j<1000000000; j++) {
    GetSystemTime(st);
    if (st.wMilliseconds != startMsecs) {
      nowMsecs = st.wMilliseconds;
      if (nowMsecs < startMsecs)
        nowMsecs += 1000; // wMilliseconds wrapped
      MessageBox(StringFormat("GetSystemTime msecs %d -> %d diff %d", startMsecs, nowMsecs, nowMsecs - startMsecs), "Test Millisecond Resolution via GetSystemTime");
      return;
    }
  }
}

Isso dá uma resolução de 15/16 msecs em um PC recém-iniciado sem nenhum outro software rodando, mas 1 msec se o Chrome estiver rodando no PC! Como o segundo link do angevoyageur explica o Chrome configura o temporizador do sistema para 1 msec de resolução, assim como alguns outros softwares.

Encontrei duas pequenas utilidades para definir a resolução do temporizador do sistema, de modo que a resolução de 1 msec (ou mesmo 0,5 msec) possa ser obtida de forma controlada em uma máquina com inicialização limpa:

Ferramenta de temporização do sistema Windows: http://vvvv.org/contribution/windows-system-timer-tool

Resolução do temporizador: http://www.lucashale.com/timer-resolution/

Eu prefiro a primeira das duas, Windows System Timer Tool. Com isso eu poderia obter de forma confiável uma resolução de 1 msec via GetSystemTime(). GetLocalTime() também poderia ser usado de forma semelhante.

O código do script acima é um exemplo de como o novo código MT4 pode ser muito melhor graças às estruturas. No antigo MT4 acessando GetSystemTime() exigia o uso de uma matriz inteira mais muita manipulação de bits confusos.

GetSystemTimeAsFileTime() Resolução

Finalmente, observei que Microsecond Resolution Time Services for Windows mencionou que GetSystemTimeAsFileTime() é uma função mais rápida para acessar o tempo do sistema, além de exigir uma estrutura menor e mais simples. Esta última é certamente verdadeira para o novo MT4, pois a "estrutura" pode ser reduzida a apenas um ulong.

Aqui está o código para um script para testar a resolução GetSystemTimeAsFileTiime():

// Script to test Millisecond Resolution via GetSystemTimeAsFileTime()

#import "kernel32.dll"
void GetSystemTimeAsFileTime(ulong &SystemTimeAsFileTime); // Returns the system time in 100 nsec units in a ulong
#import

void OnStart() {
  ulong startL, nowL;
  GetSystemTimeAsFileTime(startL);
  for (int j=0; j<1000000000; j++) {
    GetSystemTimeAsFileTime(nowL);
    if (nowL > startL) {
      int diff = int(nowL - startL);
      MessageBox(StringFormat("GetSystemTimeAsFileTime %llu -> %llu diff %d in 100 nsec units = %.1f msecs",
                 startL, nowL, diff, diff/10000.0), "Test Millisecond Resolution via GetSystemTimeAsFileTime");
      return;
    }
  }
}

Se o Windows System Timer Tool for usado para definir uma resolução de 0,5secs para o temporizador do sistema, esse pequeno script informa uma resolução de 5000 (ou às vezes 5001) unidades de 100 nsecs = 0,5 msecs.

O uso do GetSystemTimeAsFileTiime() é de fato mais simples e pode mostrar uma resolução mais fina.

Aqui estão algumas fotos deste em uso.

Após uma inicialização limpa:

Depois de uma bota limpa

Com a Ferramenta Timer usada para definir a resolução do temporizador do sistema para 1 ms:

Com a Ferramenta Temporizador utilizada para definir a resolução do temporizador do sistema para 1 ms

E com a Ferramenta Temporizador usada para definir a resolução do temporizador do sistema para 0,5 ms:

Com a Ferramenta Temporizador utilizada para definir a resolução do temporizador do sistema para 0,5 ms

Conclusão

A melhor função a ser usada para obter timings de milissegundos no MT4 é GetSystemTimeAsFileTiime() chamado como mostrado no script de teste acima, com um utilitário como o Windows System Timer Tool usado para definir a resolução desejada do timer do sistema.

1234
Novo comentário