Arduino.ru

Угу.

Чтоб оптимизатор не повырезал выполняемые команды, результат выполнения пишется в массив. Длина массива физически фиксирована, соответственно, количество элементов разных типов различно.

То есть, это не результат отдельной операции, а результат операции + вычисление индекса в массиве + запись в массив .. так? :)

Угу. Еще + организация цикла. Именно поэтому таблица начинается с проверки времени заполнения массива.

Не лучший подход. Я бы делал так. В измерительном цикле вызов функции через указатель на неё. И набор функций для тестирования операций плюс одна пустая функция, только с return;. Вначале указатель устанавливаем на пустую. Меряем время прохождения измерительного цикла. Затем ставим указатель на функцию с операцией. Снова мерим время, вычитаем из него первое время, для пустой и разность делим на кол-во циклов. Так и издержки на организацию учтутся и компилятор с своей оптимизацией не помешает.

Побаловался.

 long int tst(void (*Fn)(void), long int t)
 {
  long int m;
  m=micros();
  for(int i=0;i<10000;i++) {Fn();}
  m=micros()-m-t;
  if(t)
  {
    Serial.print(" t=");
    Serial.print(m/10000.0);
     Serial.print("usec ");
    Serial.print(16*m/10000.0);
    Serial.println("cycles");
   delay(50);
  }
  return m;
 }
 
 void Fpusto(void){return;}
 void FarduinoRead(void){digitalRead(5);return;}
 void FarduinoWrite(void){digitalWrite(5, 0);return;}
 void FarduinoPort(void){PORTB|=0x20;return;}


void setup() 
{ 
  Serial.begin(9600);

  for(;;)
  {
    long int tb=tst(Fpusto, 0);
  Serial.print("t0="); Serial.println(tb=tst(Fpusto, 0));
  Serial.print("arduinoRead   ");tst(FarduinoRead,tb);
  Serial.print("arduinoWrite  ");tst(FarduinoWrite,tb);
  Serial.print("arduinoPort  ");tst(FarduinoPort,tb);

  delay(10000);
 
  }

}

Выдало.

Меня больше смущает, что первая строчка Fill bytes дает примерно вдвое большее время, чем последующие.

Продублировал первый цикл перед первым измерением - время первого измерения снизилось до величины последующих.

Интересно было бы узнать о причине такого снижения производительности при первом проходе. На PC наблюдается похожее поведение, но там это связано с работой в защищенном режиме - под массив выделяется только первые 4к памяти, а последующие выделяются уже только в процессе реального обращения к этой памяти.

Так к автору теста обратитесь. Может разяснит.

Вобще такое с кешем бывает. А у Дуо (Вы не указали у которого вдвое большее время, я вижу у Дуо) ядро ARM? а от этой херни любую подлянку можна ожидать.

volatile разве не помогает в борьбе с компилятором?

И снова тестим железяку ардуиновскую. ESP8266-12E из IDE 1.6.5 по коду из #205. Только вместо прямой работы с портом сделал вызов милиса. Не умея я с портом работать у этой железки. Собственно основной вопрос теста и был, нужно ли напрямую с портом или итак сойдет. Заодно добавил  + и * Имеем. 

Что быстрее?

if (a)  i++;  // bool a

Или

i += a;  // bool a

стандартом С не гарантируется, что a будет = 1, если true.

Допустим 

a = digitalRead(pin);

Или вообще, а или 0 или 1.

Вопрос не об этом, а о том, что быстрее.

a = digitalRead(pin);

если a = digitalRead(pin); , то нет смысла заморачиваться о скорости исполнения if (a)  i++;  // bool a

C if-ом быстрее. 

А если так?

a = PINB& (1<<pin)

Это что было? Заявка на проведение работ по определению времени выполнения кода? Так иди пожалуйста в соответствующий раздел. 

решил поднять старую тему, итак есть процедура вывода на 8и разрядный семисегментный led индикатор

с 8 ступенчатой ШИМ регулировкой яркостью, все работает, все хорошо.

void showLedBuf() {
  for (byte lp = 0; lp <= LED_PWM; ++lp) {
    unsigned long tms = micros();
    for (byte i = 0; i <= 7; i++) {
      PB3_LOW;
      for (byte j = 0; j <= 7; j++) {
        if (bitRead(LED_BUF[i], (7 - j))) {
          PB4_HIGH;
        } else {
          PB4_LOW;
        }
        PB2_HIGH;
        PB2_LOW;
      }
      for (byte j = 0; j <= 7; j++) {
        if (bitRead(LED_NU[i], (7 - j))) {
          PB4_HIGH;
        } else {
          PB4_LOW;
        }
        PB2_HIGH;
        PB2_LOW;
      }
      PB3_HIGH;
    }
    tms = micros() - tms;
    Serial.println(tms,DEC);
  }
  for (byte lp = 0; lp < (7 - LED_PWM); ++lp) {
    for (byte i = 0; i <= 7; i++) {
      PB3_LOW;
      for (byte j = 0; j <= 7; j++) {
        if (bitRead(LED_BUF[i], (7 - j))) {
          PB4_HIGH;
        } else {
          PB4_HIGH;
        }
        PB2_HIGH;
        PB2_LOW;
      }
      for (byte j = 0; j <= 7; j++) {
        if (bitRead(LED_NU[i], (7 - j))) {
          PB4_HIGH;
        } else {
          PB4_HIGH;
        }
        PB2_HIGH;
        PB2_LOW;
      }
      PB3_HIGH;
    }
  }
}

но вторая часть данной процедуры - фактически говнокод, его задача погасить все индикаторы

на время примерное равное 540 микросекунд, какой одной командой можно реализовать задержку МК?

торможу, отмена вопросу

вот же есть команда delayMicroseconds

если на сутки, то: гражданин, МК, вы задержаны за участие в несанкционированном путинге.

За прошедшее время пощупал еще несколько камешков:

(на каждый камень по два столбца: первый - время выполнения в мкс, второй - в тактах)

                 Uno            Due            ESP8266        stm32f103      stm32f407	
                 mcs     cyc    mcs     cyc    mcs     cyc    mcs     cyc    mcs      cyc
Fill bytes      0.48    7.71   0.21   17.29   0.08    6.09   0.13    9.11   0.04     7.04
Fill bytes(L)   0.48    7.76   0.10    8.54   0.09    7.09   0.13    9.02   0.04     7.06
Fill ints       0.62    9.89   0.10    8.29   0.09    7.19   0.13    9.04   0.05     8.08
Fill longs      0.90   14.35   0.10    8.62   0.10    8.36   0.22   16.03   0.05     8.08
Fill floats     0.90   14.35   0.10    8.63   0.08    6.64   0.22   16.03   0.05     8.04
Fill doubles                   0.15   12.22   0.10    7.66   0.31   22.08   0.07    11.07
millis(b):      1.81   28.90   0.34   28.20   4.41  352.75   0.27   19.12   0.06    10.07
millis(i):      1.94   31.03   0.32   27.11   4.41  352.77   0.17   12.06   0.04     7.03
millis(L):      2.22   35.49   0.36   30.23   4.43  354.06   0.13    9.21   0.05     8.04
micros(L):      4.00   64.00   1.46  122.71   0.70   56.33   0.87   62.65   0.26    44.09
int MUL         0.77   12.32   0.13   10.75   0.09    7.19   0.13    9.07   0.04     7.05
int DIV        15.35  245.62   0.24   20.44   1.21   96.56   0.27   19.20   0.08    13.35
int ADD         0.77   12.32   0.24   20.24   0.09    6.99   0.17   12.06   0.05     8.06
int SUB         0.77   12.32   0.22   18.22   0.09    7.15   0.17   12.06   0.05     8.06
long MUL        1.38   22.11   0.10    8.14   0.08    6.33   0.26   18.98   0.05     9.06
long DIV       42.48  679.76   0.33   27.71   3.18  254.45   0.46   33.19   0.12    20.67
long ADD        1.47   23.47   0.28   23.80   0.09    7.34   0.38   27.14   0.07    11.07
long SUB        1.43   22.88   0.17   13.88   0.10    7.66   0.32   23.13   0.07    11.07
int64 MUL                                     0.19   15.47   0.31   22.22   0.08    14.11
int64 DIV                                     7.20  575.78   2.89  208.27   1.01   169.56
int64 ADD                                     0.19   15.47   0.32   23.20   0.08    14.11
int64 SUB                                     0.23   18.28   0.32   23.20   0.08    14.11
int->float      4.47   71.56   0.87   73.02   0.52   41.33   0.85   61.17   0.22    37.28
float MUL      13.89  222.25   3.00  251.81   3.26  261.17   3.03  217.90   0.87   145.73
float DIV      34.93  558.93  12.25 1028.62  11.05  884.22  13.63  981.49   4.17   701.16
float ADD      12.67  202.67   3.33  279.80   1.73  138.59   3.39  244.20   0.99   166.20
float SUB      12.62  201.89   3.45  289.40   2.05  164.22   3.43  247.29   1.08   180.63
sin(float)    123.55 1976.82  52.99 4451.54  49.58 3966.17  54.35 3913.17  18.17  3052.88
int->double                    1.08   90.99   0.50   40.31   1.04   75.09   0.34    57.42
double MUL                     2.54  213.06   2.81  224.53   2.60  187.45   0.77   128.62
double DIV                    11.84  994.65  10.60  848.12  13.15  946.55   4.07   684.14
double ADD                     2.86  240.27   1.29  103.28   3.07  221.06   0.89   149.13
double SUB                     3.19  268.00   1.62  129.37   3.10  223.17   0.96   161.36
sin(double):                  52.59 4417.79  48.47 3877.50  53.75 3869.72  17.42  2926.55
digitalWrite:   5.80   92.85   1.77  148.30   1.25  100.39   0.91   65.43   0.19    32.24
digitalWrite:   7.38  118.06   2.25  189.34   1.25  100.23   0.78   56.36   0.18    30.23
digitalWrite:   5.81   92.90   2.36  198.36   1.23   98.16   0.84   60.52   0.18    30.23
pinOut:         0.90   14.40
pinOutHihh+Low: 0.56    8.92
digitalRead:    4.57   73.12  1.16   97.24   0.60    48.32   0.73   52.44   0.18    30.22
digitalRead:    5.99   95.90   1.21  101.24   0.61   49.10   0.74   53.53   0.18    30.22
analogRead:   112.20 1795.20   4.48  376.57  95.30 7623.95   7.05  507.76   3.38   568.33
pinMode:        5.27   84.27   3.14  263.54
shiftOut:     182.21 2915.39  53.06 4457.16  27.27 2181.25  13.41  965.57   3.86   649.11
delayMs(1):     1.24   19.88   1.04   87.22   1.80  144.14   1.19   85.62   1.07   180.28
delayMs(10):   10.35  165.53  10.06  845.11  10.80  864.08  10.18  732.96  10.08  1692.74
delayMs(100): 100.89 1614.21 100.16 8413.77 100.80 8064.10 100.40 7228.60 100.10 16817.22

Из интересного следующее:

- ESP8266, пожалуй занимает одно из лучших мест по соотношению цена/производительность, где первое место, безусловно, у BluePill, однако, у последнего маловато памяти. ESP8266 почти за те же деньги предлагает в разы больше памяти.

- как и следовало ожидать, лидер по производительности stm32f407vet6 с частотой 168 МГц. Любопытно, что у него производительность выше, чем у stm32f103 даже на единицу тактовой частоты.

- еще одна непонятка с stm32f407: хотя у него заявлено FPU, на результатах этого не заметно. Одно из возможны объяснений - в нынешнем состоянии Arduino IDE эту возможность не поддерживает.

andriano, было бы очень здорово увидеть в общем зачете результаты ESP32. По идее, кроме повышенной частоты еще и обновленная архитектура ядер должны давать прирост в микрос, относительно 8266

Скетч из первопоста, ESP32 (WROOM-32) на двух частотах (выбираются в Arduino IDE):

40 MHz

Time Measurements, byte size:	1320,	int size:	660,	float size:	330
Fill bytes:	0.02 mcs	0.28 cycles	1320
Fill bytes(L):	0.01 mcs	0.21 cycles	1320
Fill ints:	0.01 mcs	0.22 cycles	660
Fill longs:	0.02 mcs	0.24 cycles	330
Fill floats:	0.02 mcs	0.24 cycles	330
millis(b):	1.16 mcs	18.61 cycles	1320
millis(i):	1.17 mcs	18.64 cycles	660
millis(L):	1.18 mcs	18.81 cycles	330
micros(L):	0.83 mcs	13.24 cycles	330
int MUL:	0.01 mcs	0.22 cycles	660
int DIV:	0.03 mcs	0.51 cycles	660
int ADD:	0.01 mcs	0.22 cycles	660
int DIV:	0.01 mcs	0.22 cycles	660
long MUL:	0.02 mcs	0.24 cycles	330
long DIV:	0.07 mcs	1.07 cycles	330
long ADD:	0.02 mcs	0.24 cycles	330
long SUB:	0.02 mcs	0.24 cycles	330
int => float:	0.02 mcs	0.29 cycles	330
float MUL:	0.73 mcs	11.64 cycles	330
float DIV:	2.99 mcs	47.81 cycles	330
float AD:	0.52 mcs	8.39 cycles	330
float SUB:	0.60 mcs	9.60 cycles	330
sin(float):	11.06 mcs	176.92 cycles	330
digitalWrite:	0.15 mcs	2.47 cycles	1320
digitalWrite:	0.15 mcs	2.42 cycles	1320
digitalRead:	0.18 mcs	2.91 cycles	1320
digitalRead:	0.18 mcs	2.82 cycles	1320
analogRead:	9.66 mcs	154.52 cycles	660
pinMode:	0.42 mcs	6.72 cycles	660
shiftOut:	3.11 mcs	49.75 cycles	660
delayMs(1):	1.83 mcs	29.35 cycles	1320
delayMs(10):	10.75 mcs	172.02 cycles	1320
delayMs(100):	100.43 mcs	1606.96 cycles	1320

80MHz

Time Measurements, byte size:	1320,	int size:	660,	float size:	330
Fill bytes:	0.02 mcs	0.30 cycles	1320
Fill bytes(L):	0.01 mcs	0.21 cycles	1320
Fill ints:	0.02 mcs	0.27 cycles	660
Fill longs:	0.02 mcs	0.34 cycles	330
Fill floats:	0.02 mcs	0.24 cycles	330
millis(b):	1.12 mcs	17.95 cycles	1320
millis(i):	1.13 mcs	18.01 cycles	660
millis(L):	1.10 mcs	17.65 cycles	330
micros(L):	0.79 mcs	12.70 cycles	330
int MUL:	0.02 mcs	0.27 cycles	660
int DIV:	0.03 mcs	0.56 cycles	660
int ADD:	0.01 mcs	0.22 cycles	660
int DIV:	0.02 mcs	0.27 cycles	660
long MUL:	0.02 mcs	0.34 cycles	330
long DIV:	0.09 mcs	1.50 cycles	330
long ADD:	0.02 mcs	0.24 cycles	330
long SUB:	0.02 mcs	0.34 cycles	330
int => float:	0.02 mcs	0.39 cycles	330
float MUL:	0.75 mcs	12.07 cycles	330
float DIV:	3.01 mcs	48.10 cycles	330
float AD:	0.51 mcs	8.19 cycles	330
float SUB:	0.61 mcs	9.70 cycles	330
sin(float):	11.48 mcs	183.61 cycles	330
digitalWrite:	0.16 mcs	2.51 cycles	1320
digitalWrite:	0.16 mcs	2.52 cycles	1320
digitalRead:	0.18 mcs	2.82 cycles	1320
digitalRead:	0.18 mcs	2.92 cycles	1320
analogRead:	9.79 mcs	156.68 cycles	660
pinMode:	0.44 mcs	7.08 cycles	660
shiftOut:	3.12 mcs	49.96 cycles	660
delayMs(1):	2.01 mcs	32.10 cycles	1320
delayMs(10):	10.66 mcs	170.51 cycles	1320
delayMs(100):	100.54 mcs	1608.57 cycles	1320

Да, с первым постом я знатно протупил

Спасибо

int => float:	0.02 mcs	0.29 cycles	330
float MUL:	0.73 mcs	11.64 cycles	330
float DIV:	2.99 mcs	47.81 cycles	330
float AD:	0.52 mcs	8.39 cycles	330
float SUB:	0.60 mcs	9.60 cycles	330
sin(float):	11.06 mcs	176.92 cycles	330
.....

int => float:	0.02 mcs	0.39 cycles	330
float MUL:	0.75 mcs	12.07 cycles	330
float DIV:	3.01 mcs	48.10 cycles	330
float AD:	0.51 mcs	8.19 cycles	330
float SUB:	0.61 mcs	9.70 cycles	330
sin(float):	11.48 mcs	183.61 cycles	330
......

Фигню намерил..

Сразу видно - рост частоты в 2 раза не ускорил работу )))) Даже местами замедлил! Это не так.

Во первых, в том коде жестко забито соотношение времени и тактов 16, в стр.27. Т.к. на 16МГц за мксек 16 тактов. Потому на других частотах циклы заведомо не верны. 

Ну и время мерить просто за счет измерения времени выполнения цикла - херня. Время на организацию цикла включается в время измеряемой команды.  Более менее годится для сравнен разных команд на одной платформе (время на организацию цикла одинаково), но между разными платформами при коротких командах - отстой. Методику надо другую.

Утверждение во втором предложении не соответствует действительности. 

Соответственно, остальные утверждения - херня и отстой. Где что - решайте сами.

PS. Да, опубликованный вариант теста привязан к тактовой частоте 16 МГц. В более поздних версиях от этого недостатка я избавился, заодно несколько изменив набор тестов. В планах - привести методику к виду более пригодному для адаптации к различным контроллерах. Но, увы, это не самые ближайшие планы. 

PPS. На всякий случай напомню, что тест опубликован примерно через 3 месяца после моего первого знакомства с Ардуино. На тот момент я ни о чем кроме 16-мегагерцовых вариантов AVR просто не имел понятия. Но, с одной стороны, хотелось иметь какое-то общее представление, чего от этих контроллеров можно ожидать в плане производительности, а с другой - имелся некоторый опыт по написанию тестов для оценки этой самой производительности. Т.е. это довольно грубый инструмент, позволяющий тем не менее, получить некоторые рекомендации, на что обращать внимание при написании критичных участков программ.

Что там "не соответствует"? Там инкремент итератора есть, проверка его есть. И это на каждом проходе требует времени. Как и сама проверяемая команда. Сумму этих времён и имеем.

Про другие версии. Ну не знаю, люди из первого поста пользуют. Я про их результат отписался. Он очевидная лажа. Другие версии ни они ни я не знаю. Сам я по другому меряю, там выше код. ESP32 у меня нет, а то б посетил.

Пс. Ты так пишеш, как будто тя кто обвиняет в чем. Народ просто не понимает что к чему пригодно' вот и получают такие результаты. Я пояснил им.

А вот по принципу ax+b?  Запускаем тест на 100- 1000-10000 проходов одной команды. Находим a b. Получи а - время выполнения команды - б накладные расходы. Позаботится что бы изменение количества проходов  менять размеры вспомогательных переменных. Большим числом контрольных точек проверить линейность нарастания времени.    

У меня есть, могу потестить. В каком сообщении код?

Если уж математически то измеренное время T=n*a+n*х+c где n-количество повторов, a-время организации одного прохода, инкремент счётчика, сравнение, переход...х-время на выполнение одной команды, его ищем, с-время инициализации цикла и на millis или что там есть. Влияние с уменьшаем увеличивая n. Если х>>а, то нормально и так, погрешность небольшая и для сравнения на одной платформе не существенна. 

///В каком сообщении код?

В #205. Но он тоже на 16МГц заточен. Правь стр.12

Ок, в среду вечером выложу результат

Из 205. ESP32. 80 МГц.

Не радикальная разница по цифирям.

Это не скажи. Особенно в циклах. Заметь, циклы всегда должны быть цифрой целой. Ну такова природа процессора. Понятно погрешность есть. Но в любом случае результат должен быть близок к целому, по крайней мере на коротких операциях, немного более целого.

Ещё момент. Разница между результатами двух программ, из стартового и #205, по одной и той же функции 0.04мксек. Не много. И можно бы считать что это как раз и есть время на организацию цикла, вычесть ее из результатов первой проги, и бинго. Но длительнос коротких операций там и так 0.02мксек, значить по ним вообще непонятка, скорей всего число повторов цикла надо увеличивать для коротких операций.

Да, не стесняйтесь, дописуйте кому чего интересно, я синусы с умножениями в тест не вносил, т.к. меня интересовал только вопрос разницы между способами работы с портом.

Ещё , рассматривая результаты. digitalRead/Write у 328р - нормальные подпрограммы, имеют около сотни тактов, потому и вызывают желание прямой работы с портом. А у ESP 9-11 тактов.. Для подпрограммы мало, для прямого обращения многовато вроде.. Странно.

Да, всё странно, даже очень. И сам изначальный вопрос, и то что ты там пытаешься донести. А какой в этом смысл вообще... не пробовал задуматься? Даже теоретически - это всё блеф, а практически - просто лишено какого-либо смысла, как такового. Но тема живёт! )))

Есть на руках Nano Every с ATMega4809 (20MHz). Каким скетчем промер сделать (если надо, конечное), чтобы академических споров не возникло?

Пока опубликован только один - самый первый вариант. Увы, его зачастую приходится дорабатывать при тестировании новых плат. В планах сделать скетч, который бы был более или менее универсальным. Но пока такого нет.

Итак, скетчем с первопоста протестирована такая штука: https://store.arduino.cc/usa/nano-every (натуральная, не с алиэкспресса).

Аддон фирмовый, через Board Manager ставленный. Несмотря на то, что сайт нам говорит о 20Mhz тактовой,  в boards.txt имеем : nona4809.build.f_cpu=16000000L

Time Measurements, byte size:	1320,	int size:	660,	float size:	330
Fill bytes:	0.48 mcs	7.71 cycles	1320
Fill bytes(L):	0.49 mcs	7.81 cycles	1320
Fill ints:	0.48 mcs	7.66 cycles	660
Fill longs:	0.63 mcs	10.08 cycles	330
Fill floats:	0.92 mcs	14.74 cycles	330
millis(b):	1.52 mcs	24.34 cycles	1320
millis(i):	1.59 mcs	25.41 cycles	660
millis(L):	1.75 mcs	27.93 cycles	330
micros(L):	7.78 mcs	124.51 cycles	330
int MUL:	0.64 mcs	10.18 cycles	660
int DIV:	15.16 mcs	242.52 cycles	660
int ADD:	0.63 mcs	10.08 cycles	660
int DIV:	0.64 mcs	10.28 cycles	660
long MUL:	1.10 mcs	17.65 cycles	330
long DIV:	42.23 mcs	675.68 cycles	330
long ADD:	1.21 mcs	19.39 cycles	330
long SUB:	1.20 mcs	19.20 cycles	330
int => float:	4.27 mcs	68.27 cycles	330
float MUL:	13.45 mcs	215.27 cycles	330
float DIV:	34.70 mcs	555.25 cycles	330
float AD:	12.46 mcs	199.37 cycles	330
float SUB:	12.38 mcs	198.01 cycles	330
sin(float):	122.93 mcs	1966.93 cycles	330
digitalWrite:	7.34 mcs	117.48 cycles	1320
digitalWrite:	5.77 mcs	92.36 cycles	1320
digitalRead:	4.57 mcs	73.16 cycles	1320
digitalRead:	7.22 mcs	115.49 cycles	1320
analogRead:	112.23 mcs	1795.68 cycles	660
pinMode:	3.72 mcs	59.44 cycles	660
shiftOut:	139.78 mcs	2236.51 cycles	660
delayMs(1):	0.01 mcs	0.10 cycles	1320
delayMs(10):	9.44 mcs	150.98 cycles	1320
delayMs(100):	99.96 mcs	1599.37 cycles	1320

Моя Nano Every купленная на Али, но в упаковке с голограммой и брошюркой внутри. И я за 18 баксов брал в декабре.

10   Time Measurements, byte size:	1320,	int size:	660,	float size:	330
Fill bytes:	0.48 mcs	7.71 cycles	1320
Fill bytes(L):	0.48 mcs	7.76 cycles	1320
Fill ints:	0.48 mcs	7.66 cycles	660
Fill longs:	0.63 mcs	10.08 cycles	330
Fill floats:	0.93 mcs	14.93 cycles	330
millis(b):	1.52 mcs	24.29 cycles	1320
millis(i):	1.59 mcs	25.50 cycles	660
millis(L):	1.73 mcs	27.73 cycles	330
micros(L):	7.77 mcs	124.32 cycles	330
int MUL:	0.63 mcs	10.08 cycles	660
int DIV:	15.16 mcs	242.52 cycles	660
int ADD:	0.63 mcs	10.08 cycles	660
int DIV:	0.63 mcs	10.08 cycles	660
long MUL:	1.14 mcs	18.23 cycles	330
long DIV:	42.23 mcs	675.68 cycles	330
long ADD:	1.22 mcs	19.59 cycles	330
long SUB:	1.19 mcs	19.01 cycles	330
int => float:	4.27 mcs	68.27 cycles	330
float MUL:	13.45 mcs	215.27 cycles	330
float DIV:	34.70 mcs	555.25 cycles	330
float AD:	12.45 mcs	199.18 cycles	330
float SUB:	12.38 mcs	198.01 cycles	330
sin(float):	122.96 mcs	1967.32 cycles	330
digitalWrite:	7.34 mcs	117.48 cycles	1320
digitalWrite:	5.76 mcs	92.22 cycles	1320
digitalRead:	4.57 mcs	73.16 cycles	1320
digitalRead:	7.21 mcs	115.39 cycles	1320
analogRead:	112.24 mcs	1795.88 cycles	660
pinMode:	3.72 mcs	59.44 cycles	660
shiftOut:	139.77 mcs	2236.32 cycles	660
delayMs(1):	0.01 mcs	0.10 cycles	1320
delayMs(10):	9.44 mcs	150.98 cycles	1320
delayMs(100):	99.96 mcs	1599.37 cycles	1320