Há ali um resultado aleatório. A compilação desdobra o acesso a uma célula de memória com um valor de array, e o tamanho do array será obtido e colocado na célula de memória com antecedência, quando o array for formado, mesmo que o array seja dinâmico, e as células com um tamanho de array e com um valor variável terão o mesmo tempo de acesso.
E, a julgar pela frase que os compiladores fazem no curso de 3-4 anos de informática ... em geral, espero que um nível de pessoal suficientemente necessário não me deixe muito nervoso no ambiente MCL)
Acredite que o estudante médio normalmente FIVT é apenas zero com mais), já que há zero experiência, e o conhecimento sem experiência rapidamente não vai a lugar algum (esquecido), e seus exemplos são muito estranhos, levará anos até que o estudante entenda onde e como eles podem ser usados. Isto se você comparar com um programador experiente.
Acredite, o aluno médio da FIVT é geralmente um zero mais), porque não há experiência, e o conhecimento sem experiência rapidamente não vai a lugar algum (é esquecido), e seus exemplos são muito estranhos, levará anos até que o aluno entenda onde e como eles podem ser usados. Isto se você comparar com um programador experiente.
É compreensível. Eu não entendo porque você tem que ensinar como fazer um compilador. É como ensinar como criar a própria língua. É claro que uma língua é uma classe, mas nem todo pássaro pode voar a priori. Bem, como já mencionei acima, Erros, Erros, Insetos, Perguntas também são relevantes para a questão da otimização da compilação em tempo real.
Mas ainda não entendo, há sentido em definir código, por exemplo, funções definidas pelo usuário. Na esperança de que o código defunto seja executado mais rapidamente no arquivo executável. Ou é um mal-entendido? Porque a substituição é apenas uma ação de pré-compilação, e faz sentido apenas para acelerar a construção.
Mas ainda não entendo, há sentido em definir código, por exemplo, funções definidas pelo usuário. Na esperança de que o código defunto seja executado mais rapidamente no arquivo executável. Ou é um mal-entendido? Porque a substituição é apenas uma ação de pré-compilação, e é apenas lógico acelerar a construção.
Acabo de lhes mostrar um exemplo onde 3 funções externas são utilizadas. contra sua forma desdobrada. Portanto, não haverá aceleração.
Внешние функции, определенные в другом модуле, должны быть явно описаны. Описание включает в себя тип возвращаемого значения, имя функции и набор входных параметров с их типами. Отсутствие такого описания может привести к ошибкам при компиляции, компоновке или выполнении программы. При описании внешнего объекта используйте ключевое слово С...
Acabo de lhes mostrar um exemplo onde 3 funções externas são utilizadas. contra sua forma desdobrada. Portanto, não haverá aceleração.
Estou vendo. Então olá para fxsaber. Um adepto do desfunding de tudo.
Alexandr Andreev:
Prove que estou errado)
porque em meu teste eles são os mesmos por alguma razão.
Quanto a ArraySize() e variável. Mesmo assim, vou voltar a esta pergunta. Eis o que eu mudei no teste. O laço conta o número de PI. Na primeira amostra, a condição do laço utiliza o ArraySize(). No segundo exemplo, é utilizada a variável num_steps. Há uma diferença.
Função ArraySize()
voidOnStart()
{
int arr[];
int num_steps = ArrayResize(arr, 1000000000);
double x, pi, sum=0.0;
double step = 1.0/(double)num_steps;
ulong t = GetMicrosecondCount();
for (int i = 0; i<ArraySize(arr); i++)
{
x = (i + .5) * step;
sum = sum + 4.0 / (1.0 + x * x);
}
pi = sum*step;
t = GetMicrosecondCount() - t;
printf("The value of PI is %1.12f ", pi);
PrintFormat("Total time to calculate PI was %5.3f ms\n", t / 1000.0);
}
Três corridas do roteiro.
2020.11.0223:56:51.556 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0223:56:51.556 TestScript (USDJPY,M1) Total time to calculate PI was 4049.179 ms
2020.11.0223:56:51.556 TestScript (USDJPY,M1)
2020.11.0223:56:57.928 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0223:56:57.928 TestScript (USDJPY,M1) Total time to calculate PI was 4183.364 ms
2020.11.0223:56:57.928 TestScript (USDJPY,M1)
2020.11.0223:57:03.884 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0223:57:03.884 TestScript (USDJPY,M1) Total time to calculate PI was 4034.098 ms
Num_passo_variáveis.
voidOnStart()
{
int arr[];
int num_steps = ArrayResize(arr, 1000000000);
double x, pi, sum=0.0;
double step = 1.0/(double)num_steps;
ulong t = GetMicrosecondCount();
for (int i = 0; i<num_steps; i++)
{
x = (i + .5) * step;
sum = sum + 4.0 / (1.0 + x * x);
}
pi = sum*step;
t = GetMicrosecondCount() - t;
printf("The value of PI is %1.12f ", pi);
PrintFormat("Total time to calculate PI was %5.3f ms\n", t / 1000.0);
}
Três corridas do roteiro.
2020.11.0300:08:09.269 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0300:08:09.271 TestScript (USDJPY,M1) Total time to calculate PI was 3955.325 ms
2020.11.0300:08:09.271 TestScript (USDJPY,M1)
2020.11.0300:08:15.578 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0300:08:15.578 TestScript (USDJPY,M1) Total time to calculate PI was 3950.568 ms
2020.11.0300:08:15.578 TestScript (USDJPY,M1)
2020.11.0300:08:22.469 TestScript (USDJPY,M1) The value of PI is3.1415926535902020.11.0300:08:22.469 TestScript (USDJPY,M1) Total time to calculate PI was 3927.110 ms
Estou vendo. Então olá para fxsaber. Um fã de definir tudo de uma vez.
Quanto a ArraySize() e a variável. Mesmo assim, vou voltar a esta pergunta. Aqui está o teste que modifiquei. O laço conta o número de PI. Na primeira amostra, a condição do laço utiliza oArraySize(). No segundo exemplo, é utilizadaa variável num_steps. Há uma diferença.
Função ArraySize()
Três corridas do roteiro.
Num_passo_variáveis.
Três corridas do roteiro.
Não há uma diferença óbvia nestes cálculos. Coloco tudo isso em um código e os resultados são diferentes, há um em que a primeira variante vence
)) qualquer matriz em µl tem uma variável que é responsável pelo tamanho atual da matriz, portanto, na maioria dos idiomas.
A função ArraySize diz ao compilador para retornar o valor desta variável, ou seja, ela substitui esta variável em vez desta função. Como as arrays µl não podem ser referenciadas, o ponteiro é explicitamente para esta variável, diretamente para o endereço do crocette na memória. Tecnicamente, todos esses testes são uma tentativa de comparar duas variáveis regulares. Esta é a propriedade de desdobrar funções, no meu exemplo 4 funções perdoam funções 0, 3 das quais estão bem no corpo do loop, ou seja, há uma comparação de 40000000000 chamadas de funções versus nenhuma. E vemos uma diferença implícita que é muito pequena para notar - porque está colocando código no arquivo executável.... estamos comparando a mesma coisa.
E todos estes cálculos - quanto mais complicados são, menos sentido fazem.
É mais fácil dar um exemplo onde em um caso chamamos uma centena de funções, funções dentro de funções... E, no outro caso, tudo isso de forma ampliada - e não haverá diferença. Desde ArraySize(mas)== mas[].tamanho
Embora por alguma razão o exemplo pi tenha uma diferença ..... por excesso de freqüência, (redação) embora isso seja puramente aleatório.
e equivale a 1ms por 1 bilhão de saídas, embora isso não seja tentado explicitamente comparando variável com variável e a dispersão se torna ainda maior))
Não há uma diferença clara com estes cálculos. Coloque tudo em um código, e os resultados são diferentes, há alguns em que a primeira opção ganha
)) Cada matriz em µl tem uma variável responsável pelo tamanho atual da matriz, portanto, na maioria dos idiomas.
A função ArraySize diz ao compilador para retornar o valor desta variável, ou seja, ela substitui esta variável em vez desta função. Como as arrays µl não podem ser referenciadas, o ponteiro é explicitamente para esta variável, diretamente para o endereço do crocette na memória. Tecnicamente, todos estes testes são uma tentativa de comparar duas variáveis regulares. Esta é a propriedade de desdobrar funções, no meu exemplo 4 funções perdoam funções 0, 3 das quais estão bem no corpo do loop, ou seja, há uma comparação de 40000000000 chamadas de funções versus nenhuma. E vemos uma diferença implícita que é muito pequena para notar - porque está colocando código no arquivo executável.... estamos comparando a mesma coisa.
E todos estes cálculos - quanto mais complicados são, menos sentido fazem.
É mais fácil dar um exemplo onde em um caso chamamos uma centena de funções, funções dentro de funções... E no outro caso, tudo isso em forma ampliada - e não haverá diferença. Desde ArraySize(mas)== mas[].tamanho
Não importa o que é executado no corpo do loop. Isto é apenas uma carga para o teste. Os exemplos comparam a referência a uma função ou variável na condição de loop.
Não sou montador, mas acho que não é a mesma coisa do ponto de vista das instruções do montador. E se também é embrulhado em uma classe, certamente não é a mesma coisa.
Uma função tem uma instrução extra para recuperar um valor de uma célula de memória, ou seja, a função chama a célula de memória por um valor e só então retorna o resultado. Uma variável já tem este valor; a variável não faz referência a nada; ela retorna o resultado imediatamente.
Não importa o que é realizado no corpo do ciclo. É apenas uma carga para o teste. Os exemplos comparam a referência a uma função ou variável na condição de loop.
Não sou especialista em assembler, mas acho que do ponto de vista das instruções de montagem, não é a mesma coisa. E se também é embrulhado em uma classe, certamente não é a mesma coisa.
Uma função tem uma instrução extra para recuperar um valor de uma célula de memória, ou seja, a função chama a célula de memória por um valor e só então retorna o resultado. Uma variável já tem esse valor, a variável não se refere a lugar algum, ela retorna o resultado imediatamente.
) Bem, não é assim que funciona)
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
int mas[];
int mas1[300];
int mas2[300];
int mas3[300];
int mas4[300];
int mas5[300];
int mas6[300];
int z=300;
int size=100000000;
ArrayResize(mas,size);
ulong r=0;
ulong r1=0;
ulong r2=0;
int random;
ulong max=100;
int t=0;
int tr=0;
MathSrand(10);
int num_steps=ArraySize(mas);
double x, pi, sum=0.0;
double step = 1.0/(double)num_steps;
int v=size;
ulong t1 = GetMicrosecondCount();
// for(ulong z=0; z<max; z++)
{
for(ulong i=0; i<ArraySize(mas); i++)
{
r2+=ArraySize(mas);
r2+=ArraySize(mas1);
r2+=ArraySize(mas2);
r2+=ArraySize(mas3);
r2+=ArraySize(mas4);
r2+=ArraySize(mas5);
r2+=ArraySize(mas6);
r2+=ArraySize(mas1);
r2+=ArraySize(mas2);
r2+=ArraySize(mas3);
r2+=ArraySize(mas4);
r2+=ArraySize(mas5);
r2+=ArraySize(mas6);
r2+=ArraySize(mas1);
r2=r2/10;
}
}
ulong t2=GetMicrosecondCount();
//for(ulong z=0; z<max; z++)
{
for(ulong i=0; i<v; i++)
{
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1+=z;
r1=r1/10;
}
}
int pi2 = sum*step;
ulong t3=GetMicrosecondCount();
Print(t2-t1," ",t3-t2," ",r," ",r1," ",r2," ",pi," ",pi2);
// Templ();
}
//+------------------------------------------------------------------+//| void Funk(ulong &a){a++;}
void FunkRand(ulong &a){a+=rand();}
//+------------------------------------------------------------------+
Você não misturou nada em seu código, quem vai mudar o valor para você?
como faz na primeira versão.
Sim, falhei esse ponto. Corrigi meu posto.
Há ali um resultado aleatório. A compilação desdobra o acesso a uma célula de memória com um valor de array, e o tamanho do array será obtido e colocado na célula de memória com antecedência, quando o array for formado, mesmo que o array seja dinâmico, e as células com um tamanho de array e com um valor variável terão o mesmo tempo de acesso.
E, a julgar pela frase que os compiladores fazem no curso de 3-4 anos de informática ... em geral, espero que um nível de pessoal suficientemente necessário não me deixe muito nervoso no ambiente MCL)
Acredite que o estudante médio normalmente FIVT é apenas zero com mais), já que há zero experiência, e o conhecimento sem experiência rapidamente não vai a lugar algum (esquecido), e seus exemplos são muito estranhos, levará anos até que o estudante entenda onde e como eles podem ser usados. Isto se você comparar com um programador experiente.
Acredite, o aluno médio da FIVT é geralmente um zero mais), porque não há experiência, e o conhecimento sem experiência rapidamente não vai a lugar algum (é esquecido), e seus exemplos são muito estranhos, levará anos até que o aluno entenda onde e como eles podem ser usados. Isto se você comparar com um programador experiente.
É compreensível. Eu não entendo porque você tem que ensinar como fazer um compilador. É como ensinar como criar a própria língua. É claro que uma língua é uma classe, mas nem todo pássaro pode voar a priori. Bem, como já mencionei acima, Erros, Erros, Insetos, Perguntas também são relevantes para a questão da otimização da compilação em tempo real.
O tópico é sobre definições, não loops ))
Mas ainda não entendo, há sentido em definir código, por exemplo, funções definidas pelo usuário.
Na esperança de que o código defunto seja executado mais rapidamente no arquivo executável.
Ou é um mal-entendido? Porque a substituição é apenas uma ação de pré-compilação, e faz sentido apenas para acelerar a construção.
O tópico é sobre definições, não loops ))
Mas ainda não entendo, há sentido em definir código, por exemplo, funções definidas pelo usuário.
Na esperança de que o código defunto seja executado mais rapidamente no arquivo executável.
Ou é um mal-entendido? Porque a substituição é apenas uma ação de pré-compilação, e é apenas lógico acelerar a construção.
Acabo de lhes mostrar um exemplo onde 3 funções externas são utilizadas. contra sua forma desdobrada. Portanto, não haverá aceleração.
Fórum sobre comércio, sistemas automatizados de comércio e testes estratégicos
Pergunta para #define experts
Alexandr Andreev, 2020.11.02 19:49
500p pergunta (sem verificar) qual o caminho mais rápido. ver quantas funções externas são chamadas no método superior
Acabo de lhes mostrar um exemplo onde 3 funções externas são utilizadas. contra sua forma desdobrada. Portanto, não haverá aceleração.
Estou vendo. Então olá para fxsaber. Um adepto do desfunding de tudo.
Prove que estou errado)
porque em meu teste eles são os mesmos por alguma razão.
Quanto a ArraySize() e variável. Mesmo assim, vou voltar a esta pergunta.
Eis o que eu mudei no teste. O laço conta o número de PI.
Na primeira amostra, a condição do laço utiliza o ArraySize().
No segundo exemplo, é utilizada a variável num_steps.
Há uma diferença.
Função ArraySize()
Três corridas do roteiro.
Num_passo_variáveis.
Três corridas do roteiro.
Estou vendo. Então olá para fxsaber. Um fã de definir tudo de uma vez.
Quanto a ArraySize() e a variável. Mesmo assim, vou voltar a esta pergunta.
Aqui está o teste que modifiquei. O laço conta o número de PI.
Na primeira amostra, a condição do laço utiliza oArraySize().
No segundo exemplo, é utilizadaa variável num_steps.
Há uma diferença.
Função ArraySize()
Três corridas do roteiro.
Num_passo_variáveis.
Três corridas do roteiro.
Não há uma diferença óbvia nestes cálculos. Coloco tudo isso em um código e os resultados são diferentes, há um em que a primeira variante vence
)) qualquer matriz em µl tem uma variável que é responsável pelo tamanho atual da matriz, portanto, na maioria dos idiomas.
A função ArraySize diz ao compilador para retornar o valor desta variável, ou seja, ela substitui esta variável em vez desta função. Como as arrays µl não podem ser referenciadas, o ponteiro é explicitamente para esta variável, diretamente para o endereço do crocette na memória. Tecnicamente, todos esses testes são uma tentativa de comparar duas variáveis regulares. Esta é a propriedade de desdobrar funções, no meu exemplo 4 funções perdoam funções 0, 3 das quais estão bem no corpo do loop, ou seja, há uma comparação de 40000000000 chamadas de funções versus nenhuma. E vemos uma diferença implícita que é muito pequena para notar - porque está colocando código no arquivo executável.... estamos comparando a mesma coisa.
E todos estes cálculos - quanto mais complicados são, menos sentido fazem.
É mais fácil dar um exemplo onde em um caso chamamos uma centena de funções, funções dentro de funções... E, no outro caso, tudo isso de forma ampliada - e não haverá diferença. Desde ArraySize(mas)== mas[].tamanho
Embora por alguma razão o exemplo pi tenha uma diferença ..... por excesso de freqüência, (redação) embora isso seja puramente aleatório.
e equivale a 1ms por 1 bilhão de saídas, embora isso não seja tentado explicitamente comparando variável com variável e a dispersão se torna ainda maior))
Não há uma diferença clara com estes cálculos. Coloque tudo em um código, e os resultados são diferentes, há alguns em que a primeira opção ganha
)) Cada matriz em µl tem uma variável responsável pelo tamanho atual da matriz, portanto, na maioria dos idiomas.
A função ArraySize diz ao compilador para retornar o valor desta variável, ou seja, ela substitui esta variável em vez desta função. Como as arrays µl não podem ser referenciadas, o ponteiro é explicitamente para esta variável, diretamente para o endereço do crocette na memória. Tecnicamente, todos estes testes são uma tentativa de comparar duas variáveis regulares. Esta é a propriedade de desdobrar funções, no meu exemplo 4 funções perdoam funções 0, 3 das quais estão bem no corpo do loop, ou seja, há uma comparação de 40000000000 chamadas de funções versus nenhuma. E vemos uma diferença implícita que é muito pequena para notar - porque está colocando código no arquivo executável.... estamos comparando a mesma coisa.
E todos estes cálculos - quanto mais complicados são, menos sentido fazem.
É mais fácil dar um exemplo onde em um caso chamamos uma centena de funções, funções dentro de funções... E no outro caso, tudo isso em forma ampliada - e não haverá diferença. Desde ArraySize(mas)== mas[].tamanho
Não importa o que é executado no corpo do loop. Isto é apenas uma carga para o teste.
Os exemplos comparam a referência a uma função ou variável na condição de loop.
Não sou montador, mas acho que não é a mesma coisa do ponto de vista das instruções do montador.
E se também é embrulhado em uma classe, certamente não é a mesma coisa.
Uma função tem uma instrução extra para recuperar um valor de uma célula de memória, ou seja, a função chama a célula de memória por um valor e só então retorna o resultado.
Uma variável já tem este valor; a variável não faz referência a nada; ela retorna o resultado imediatamente.
Não importa o que é realizado no corpo do ciclo. É apenas uma carga para o teste.
Os exemplos comparam a referência a uma função ou variável na condição de loop.
Não sou especialista em assembler, mas acho que do ponto de vista das instruções de montagem, não é a mesma coisa.
E se também é embrulhado em uma classe, certamente não é a mesma coisa.
Uma função tem uma instrução extra para recuperar um valor de uma célula de memória, ou seja, a função chama a célula de memória por um valor e só então retorna o resultado.
Uma variável já tem esse valor, a variável não se refere a lugar algum, ela retorna o resultado imediatamente.
) Bem, não é assim que funciona)
Quase toda corrida o líder muda
o mais longo é a divisão))))