На встраиваемых платформах более эффективно использовать unsigned int вместо (implicity sign) int?

Question

У меня появилась привычка всегда использовать целые числа без знака, где это возможно, в моем коде, потому что процессор может делить на две степени по типам без знака, чего нельзя делать со знаковыми типами. Скорость имеет решающее значение для этого проекта. Процессор работает до 40 MIPS.

Мой процессор имеет 18-тактное деление, но это занимает больше времени, чем одноцилиндровый сдвиг ствола. Так стоит ли использовать здесь целые числа без знака, чтобы ускорить процесс или они приносят другие недостатки? Я использую dsPIC33FJ128GP802 - представитель серии dsPIC33F от Microchip. Он имеет умножение на один цикл для целых чисел со знаком и без знака. У этого также есть знак и инструкции расширения нуля.

Например, он генерирует этот код при смешивании целых чисел со знаком и без знака.

026E4  97E80F     mov.b [w15-24],w0
026E6  FB0000     se w0,w0
026E8  97E11F     mov.b [w15-31],w2
026EA  FB8102     ze w2,w2
026EC  B98002     mul.ss w0,w2,w0
026EE  400600     add.w w0,w0,w12
026F0  FB8003     ze w3,w0
026F2  100770     subr.w w0,#16,w14

Я использую C (GCC для dsPIC.)

Answer 1

Я думаю, что всем нам нужно знать намного больше об особенностях вашего процессора, чтобы ответить на этот вопрос. Почему он не может делить на две степени по целым числам со знаком? Насколько я помню операция одинакова для обоих. * 1001 Т.е. *

10/2 = 00001010 переходит к 00000101

-10 / 2 = 11110110 переходит к 11111011

Возможно, вам следует написать какой-нибудь простой код, делающий деление без знака и деление со знаком, и сравнить скомпилированный вывод.

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

int s_numbers[] = { etc. etc. };
int s_array_size = sizeof(s_numbers);
unsigned int u_numbers[] = { etc. etc.};
unsigned int u_array_size = sizeof(u_numbers);
int i;
int s_result;
unsigned int u_result;

/* Start timer. */

for(i = 0; i < 100000000; i++)
{
  i_result = s_numbers[i % s_array_size] / s_numbers[(i + 1) % s_array_size];
}

/* Stop timer and print difference. */

/* Repeat for unsigned integers. */

Написано в спешке, чтобы показать принцип, пожалуйста, прости любые ошибки.

Это не даст точного бенчмаркинга, но должно дать общее представление о том, что быстрее.

Answer 2

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

Что касается недостатков: обнаружение арифметических переполнений, переполнение типа со знаком, потому что вы не осознавали этого при использовании unsigned и т. Д. Ничего не блокирует, просто другие вещи, которые нужно учитывать.

Answer 3

Генерация сборки в обоих направлениях и подсчет циклов.

Answer 4

Я не знаю много о наборе инструкций, доступном на вашем процессоре, но быстрый взгляд заставляет меня думать, что у него есть инструкции, которые могут использоваться как для арифметических, так и для логических сдвигов, что должно означать, что смещение значения со знаком стоит около то же самое, что смещение значения без знака и деление на степени 2 для каждого, использующего сдвиги, также должно стоить того же. (мои знания об этом получены из быстрого взгляда на некоторые встроенные функции для компилятора C, предназначенного для вашего семейства процессоров).

При этом, если вы работаете со значениями, которые должны интерпретироваться как неподписанные, вы можете также объявить их как неподписанные. В последние несколько лет я все больше и больше использую типы из stdint.h, и обычно я заканчиваю тем, что использую неподписанные версии, потому что мои значения либо по своей природе являются неподписанными, либо я просто использую их как битовые массивы.