Компилятор WINAVR
процессор AVR
пример взят из firmware WIZNET
uint size;
ulong wr_ptr,rd_ptr ;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr ;
else size = 0 - rd_ptr + wr_ptr ;
чем отличаются выражения для size
и какова последовательность неявных приведений для этого
компилятора ?
Полная версия этой страницы: Чем отличаются выражения ?
Ну так это просто арифметика по модулю 65536 в данном случае
Если от меьшего отнять большее - получим отрицательное число которое выглядит как большое положительное беззнаковое
Если от меьшего отнять большее - получим отрицательное число которое выглядит как большое положительное беззнаковое
"0 - rd_ptr" эквиавалентно переводу значения rd_ptr в дополнительный код, при сложении с wr_ptr в результате получается операция вычитания. Суть в том, что значение size получается положительным (разность по модулю) в результате любого ветвления. Кстати, обращаю внимание что переменная size здесь имеет тип unsigned int, а переменные rd_ptr и wr_ptr unsigned long. Если бы константой был не 0, который при любой раскладе = 0, то нужно было бы записывать как size = 0L - rd_ptr + wr_ptr ; или size = (ulong)0 - rd_ptr + wr_ptr ; в противном случае операция была бы не с ulong-овскими числами, а с uint-овскими и результат мог быть неверен. Хотя в этом примере видимо предполагается, что значение size не бывает больше, чем 65535.
Цитата(vladsizov @ Oct 27 2005, 05:37)
Компилятор WINAVR
процессор AVR
пример взят из firmware WIZNET
uint size;
ulong wr_ptr,rd_ptr ;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr ;
else size = 0 - rd_ptr + wr_ptr ;
чем отличаются выражения для size
и какова последовательность неявных приведений для этого
компилятора ?
процессор AVR
пример взят из firmware WIZNET
uint size;
ulong wr_ptr,rd_ptr ;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr ;
else size = 0 - rd_ptr + wr_ptr ;
чем отличаются выражения для size
и какова последовательность неявных приведений для этого
компилятора ?
Ничем. Такое ощущение, что у визнета какой-то второкурсник общепромышленного ПТУ писал - там и таких мест несколько (я все повыкидывал), и модифицируемые в прерываниях переменные не обозваны volatile, и где-то массив масок сделан long, хотя хватило бы uint16_t и т.п.
Без слёз читать невозможно...
Один их цикл в sysinit
Код
for(i = 0; i < MAX_SOCK_NUM; i++) {
SSIZE[i] = 0;
RSIZE[i] = 0;
if(ssum < 8192) {
switch ((sbufsize >> i * 2) & 0x03) {
case 0:
SSIZE[i] = 1024;
SMASK[i] = 0x000003FF;
break;
case 1:
SSIZE[i] = 2048;
SMASK[i] = 0x000007FF;
break;
case 2:
SSIZE[i] = 4096;
SMASK[i] = 0x00000FFF;
break;
case 3:
SSIZE[i] = 8192;
SMASK[i] = 0x00001FFF;
break;
}
}
if(rsum < 8192) {
switch ((rbufsize >> i * 2) & 0x03) {
case 0:
RSIZE[i] = 1024;
RMASK[i] = 0x000003FF;
break;
case 1:
RSIZE[i] = 2048;
RMASK[i] = 0x000007FF;
break;
case 2:
RSIZE[i] = 4096;
RMASK[i] = 0x00000FFF;
break;
case 3:
RSIZE[i] = 8192;
RMASK[i] = 0x00001FFF;
break;
}
}
ssum += SSIZE[i];
rsum += RSIZE[i];
SSIZE[i] = 0;
RSIZE[i] = 0;
if(ssum < 8192) {
switch ((sbufsize >> i * 2) & 0x03) {
case 0:
SSIZE[i] = 1024;
SMASK[i] = 0x000003FF;
break;
case 1:
SSIZE[i] = 2048;
SMASK[i] = 0x000007FF;
break;
case 2:
SSIZE[i] = 4096;
SMASK[i] = 0x00000FFF;
break;
case 3:
SSIZE[i] = 8192;
SMASK[i] = 0x00001FFF;
break;
}
}
if(rsum < 8192) {
switch ((rbufsize >> i * 2) & 0x03) {
case 0:
RSIZE[i] = 1024;
RMASK[i] = 0x000003FF;
break;
case 1:
RSIZE[i] = 2048;
RMASK[i] = 0x000007FF;
break;
case 2:
RSIZE[i] = 4096;
RMASK[i] = 0x00000FFF;
break;
case 3:
RSIZE[i] = 8192;
RMASK[i] = 0x00001FFF;
break;
}
}
ssum += SSIZE[i];
rsum += RSIZE[i];
чего стоит...
Это ведь так делается:
Код
for(i = 0; i < MAX_SOCK_NUM; i++) {
SSIZE[i] = 0;
if(ssum < 8192) {
uint8_t index = sbufsize & 0x03;
sbufsize >>= 2;
SSIZE[i] = 1024U << index;
SMASK[i] = SSIZE[i] - 1;
}
RSIZE[i] = 0;
if(rsum < 8192) {
uint8_t index = rbufsize & 0x03;
rbufsize >>= 2;
RSIZE[i] = 1024U << index;
RMASK[i] = RSIZE[i] - 1;
}
ssum += SSIZE[i];
rsum += RSIZE[i];
SSIZE[i] = 0;
if(ssum < 8192) {
uint8_t index = sbufsize & 0x03;
sbufsize >>= 2;
SSIZE[i] = 1024U << index;
SMASK[i] = SSIZE[i] - 1;
}
RSIZE[i] = 0;
if(rsum < 8192) {
uint8_t index = rbufsize & 0x03;
rbufsize >>= 2;
RSIZE[i] = 1024U << index;
RMASK[i] = RSIZE[i] - 1;
}
ssum += SSIZE[i];
rsum += RSIZE[i];
и в результате он занимает гораздо меньше места и в ПЗУ тоже...
Да, кстати, замена их процедуры копирования на
Код
IndirectWriteBuf(uint16_t StartAddr, const uint8_t * buf, uint16_t size)
{
uint8_t size1;
w3100_irq_disable();
IDM_OR |= 0x01;
IDM_AR0 = (uint8_t) (StartAddr >> 8);
IDM_AR1 = (uint8_t) (StartAddr);
size1 = size % 8;
size /= 8;
while(size1--)
IDM_DR = *buf++;
while(size--) {
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
}
IDM_OR &= 0xFE;
w3100_irq_enable();
}
{
uint8_t size1;
w3100_irq_disable();
IDM_OR |= 0x01;
IDM_AR0 = (uint8_t) (StartAddr >> 8);
IDM_AR1 = (uint8_t) (StartAddr);
size1 = size % 8;
size /= 8;
while(size1--)
IDM_DR = *buf++;
while(size--) {
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
IDM_DR = *buf++;
}
IDM_OR &= 0xFE;
w3100_irq_enable();
}
на ровном месте поднимает скорость передачи данных раза в полтора, если я правильно помню.
Цитата(rezident @ Oct 27 2005, 16:17)
"0 - rd_ptr" эквиавалентно переводу значения rd_ptr в дополнительный код, при сложении с wr_ptr в результате получается операция вычитания. Суть в том, что значение size получается положительным (разность по модулю) в результате любого ветвления.
size всегда получается >= 0, т.к. объявлен как uint.
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Цитата(rezident @ Oct 27 2005, 16:17)
Кстати, обращаю внимание что переменная size здесь имеет тип unsigned int, а переменные rd_ptr и wr_ptr unsigned long. Если бы константой был не 0, который при любой раскладе = 0, то нужно было бы записывать как size = 0L - rd_ptr + wr_ptr ; или size = (ulong)0 - rd_ptr + wr_ptr ; в противном случае операция была бы не с ulong-овскими числами, а с uint-овскими и результат мог быть неверен. Хотя в этом примере видимо предполагается, что значение size не бывает больше, чем 65535.
Не важно какого типа константа - uint или ulong. Мы ведь результат присваиваем переменной типа uint. Т.е. старшие биты обрежутся, если sizeof(int)<sizeof(long), и останутся неизменными, если равны.
Цитата(starter48 @ Oct 27 2005, 13:43)
size всегда получается >= 0, т.к. объявлен как uint.
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Нет, там написано именно то, что хотели, просто так хотели (неподумавши).
Там циклический буфер размеорм 1/2/4/8К, "указатели" IP - 32-битные, но в буфере может не более его размера, поэтому для размера (в другом месте - для свободного места в буфере) достаточно 16-битной переменной. Для количества принятых данных вычитать всегда надо из указателя головы указатель хвоста и всё.
Цитата(starter48 @ Oct 27 2005, 13:43)
Не важно какого типа константа - uint или ulong. Мы ведь результат присваиваем переменной типа uint. Т.е. старшие биты обрежутся, если sizeof(int)<sizeof(long), и останутся неизменными, если равны.
Полностью поддерживаю.
А поскольку размер данных гарантированно влазит в uint - то всё будет нормально.
Это тот же момент, что с таймерами и отсечением интервалов.
В смысле
Код
timer_type_t start = get_timer();
while( (timer_type_t)(get_timer() - start) < delay);
while( (timer_type_t)(get_timer() - start) < delay);
это абсолютно правильно и не надо никаких
Код
timer_type_t start = get_timer();
for(;;) {
tymer_type_t end = get_timer();
if( end < start )
// и так далее, как у визнета с указателями
}
for(;;) {
tymer_type_t end = get_timer();
if( end < start )
// и так далее, как у визнета с указателями
}
Цитата(ReAl @ Oct 27 2005, 17:54)
Цитата(starter48 @ Oct 27 2005, 13:43)
size всегда получается >= 0, т.к. объявлен как uint.
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Нет, там написано именно то, что хотели, просто так хотели (неподумавши).
Там циклический буфер размеорм 1/2/4/8К, "указатели" IP - 32-битные, но в буфере может не более его размера, поэтому для размера (в другом месте - для свободного места в буфере) достаточно 16-битной переменной. Для количества принятых данных вычитать всегда надо из указателя головы указатель хвоста и всё.
Если циклический буфер, то так писать можно при условии, что размер буфера равен макс. числу в перенной size (65536 для 16bit int). Иначе надо писать size = (wr_ptr - rd_ptr) % BUFFER_SIZE; без всяких if.
Или, для оригинального варианта, следует заменить 0 на BUFFER_SIZE:
Код
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
консенсус?
Цитата(starter48 @ Oct 27 2005, 16:43)
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Я это и хотел сказать.
Цитата(starter48 @ Oct 27 2005, 16:43)
Не важно какого типа константа - uint или ulong. Мы ведь результат присваиваем переменной типа uint. Т.е. старшие биты обрежутся, если sizeof(int)<sizeof(long), и останутся неизменными, если равны.
ИМХО важно чтобы константа в этом выражении была типа ulong, иначе результат вычисления может быть неверным.
Цитата(starter48 @ Oct 27 2005, 14:52)
Цитата(ReAl @ Oct 27 2005, 17:54)
Цитата(starter48 @ Oct 27 2005, 13:43)
size всегда получается >= 0, т.к. объявлен как uint.
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Нет, там написано именно то, что хотели, просто так хотели (неподумавши).
Там циклический буфер размеорм 1/2/4/8К, "указатели" IP - 32-битные, но в буфере может не более его размера, поэтому для размера (в другом месте - для свободного места в буфере) достаточно 16-битной переменной. Для количества принятых данных вычитать всегда надо из указателя головы указатель хвоста и всё.
Если циклический буфер, то так писать можно при условии, что размер буфера равен макс. числу в перенной size (65536 для 16bit int). Иначе надо писать size = (wr_ptr - rd_ptr) % BUFFER_SIZE; без всяких if.
Или, для оригинального варианта, следует заменить 0 на BUFFER_SIZE:
Код
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
консенсус?
Может быть тогда не
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
а
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = (0xFFFF + 1 ) - rd_ptr + wr_ptr;
для понятности
Цитата(starter48 @ Oct 27 2005, 14:52)
Если циклический буфер, то так писать можно при условии, что размер буфера равен макс. числу в перенной size (65536 для 16bit int). Иначе надо писать size = (wr_ptr - rd_ptr) % BUFFER_SIZE; без всяких if.
Или, для оригинального варианта, следует заменить 0 на BUFFER_SIZE:
Или, для оригинального варианта, следует заменить 0 на BUFFER_SIZE:
Код
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
Боже упаси. % BUFFER_SIZE просто нельзя. Если ошибок в получении wr_ptr и rd_ptr не было, то эта операция просто ничего не сделает вообще - как были нули в старших битах разности, так и останутся. Если ошибка была - то %BUFFER_SIZE заметёт её под коврик и она вылезет в другом месте.
А твой вариант "для оригинального варианта" (совсем, кстати, неэквивалентно % BUFFER_SIZE):
Для ulong wr_ptr и rd_ptr wr_ptr-rd_ptr равно как и -rd_ptr+wr_ptr - всегда неотрицательно. Итого в вети else у тебя выходит, например
Код
wr_ptr = 0;
rd_ptr = 0xFFFFFFFF;
// правильный size == 1
// у тебя выйдет BUFFER_SIZE+1
rd_ptr = 0xFFFFFFFF;
// правильный size == 1
// у тебя выйдет BUFFER_SIZE+1
Можешь проверить на бумажке с любым порядком суммирования в выражении
size = BUFFER_SIZE - rd_ptr + wr_ptr;
Цитата(starter48 @ Oct 27 2005, 14:52)
консенсус?
Хорошо, давай тогда так. Сначала забудем про размер буфера вообще.
Код
ulong full_size, wr_ptr, rd_ptr;
full_size = wr_ptr - rd_ptr; // всё, тут ПРАВИЛЬНАЯ длина
full_size = wr_ptr - rd_ptr; // всё, тут ПРАВИЛЬНАЯ длина
Претензии есть?
Теперь надо или
Код
uint size;
// параноидальній вариант
if( full_size > BUFFER_SIZE) big_error();
else size = (uint)full_size; // просто отбрасываем ГАРАНТИРОВАННО нулевые биты
// независимо от того - BUFFER_SIZE = 1K или 64К
// параноидальній вариант
if( full_size > BUFFER_SIZE) big_error();
else size = (uint)full_size; // просто отбрасываем ГАРАНТИРОВАННО нулевые биты
// независимо от того - BUFFER_SIZE = 1K или 64К
или не выделываться и
Код
// нормальній вариант
size = (unit)full_size;
//т.е.
size = wr_ptr - rd_ptr;
size = (unit)full_size;
//т.е.
size = wr_ptr - rd_ptr;
Для тех, кто в танке. Возьмите листик в клеточку, пусть wr_ptr rd_ptr будут 6-битные, size - 3-битный а буфер на 4 ячейки (т.е. меньше, чем может дать size).
И порисуйте картинки. Всё честно.
Варианта обработки может быть два - указанные мной как параноидальный и как нормальный. Визнетовский не подходит ни под один из них (реально он эквивалентен нормальному), он больше похож на результат плясок с бубном, когда одновремённо с ударом рукой по бубну (тот if-else) задели ещё что-то ногой (например, какую-то переменную со знаковой переделали в беззнаковую) и оно заработало. Дальше не анализировали и не трогали.
Цитата(vladsizov @ Oct 28 2005, 08:02)
Цитата(starter48 @ Oct 27 2005, 14:52)
Цитата(ReAl @ Oct 27 2005, 17:54)
Цитата(starter48 @ Oct 27 2005, 13:43)
size всегда получается >= 0, т.к. объявлен как uint.
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
И результат будет один и тот же при любом ветвлении.
Возможно там хотели написать else size = rd_ptr - wr_ptr;
Нет, там написано именно то, что хотели, просто так хотели (неподумавши).
Там циклический буфер размеорм 1/2/4/8К, "указатели" IP - 32-битные, но в буфере может не более его размера, поэтому для размера (в другом месте - для свободного места в буфере) достаточно 16-битной переменной. Для количества принятых данных вычитать всегда надо из указателя головы указатель хвоста и всё.
Если циклический буфер, то так писать можно при условии, что размер буфера равен макс. числу в перенной size (65536 для 16bit int). Иначе надо писать size = (wr_ptr - rd_ptr) % BUFFER_SIZE; без всяких if.
Или, для оригинального варианта, следует заменить 0 на BUFFER_SIZE:
Код
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
консенсус?
Может быть тогда не
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = BUFFER_SIZE - rd_ptr + wr_ptr;
а
uint size;
ulong wr_ptr,rd_ptr;
if(wr_ptr >= rd_ptr) size = wr_ptr - rd_ptr;
else size = (0xFFFF + 1 ) - rd_ptr + wr_ptr;
для понятности
Да, если BUFFER_SIZE=64k, но тогда можно написать просто size = wr_ptr - rd_ptr;
Но ReAl говорил, что буфер может быть 1/2/4/8k, тогда так писать нельзя.
Допустим, wr_ptr = 0;rd_ptr = 1; т.е. циклицеский буфер весь заполнен.
Тогда выполнится эта ветка else size = (0xFFFF + 1 ) - rd_ptr + wr_ptr;
и size будет равен (uint)((0xFFFF + 1 ) - 1 + 0), т.е. 0xFFFF, т.е. это выражение не учитывает размер буфера. Чтобы этого избежать можно сделать так:
Код
size = BUFFER_SIZE - rd_ptr + wr_ptr;//size = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) % BUFFER_SIZE;
//size = 0xFFFFFFF % BUFFER_SIZE = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) & (BUFFER_SIZE-1);
//size = 0xFFFFFFF & (BUFFER_SIZE-1) = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) % BUFFER_SIZE;
//size = 0xFFFFFFF % BUFFER_SIZE = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) & (BUFFER_SIZE-1);
//size = 0xFFFFFFF & (BUFFER_SIZE-1) = BUFFER_SIZE - 1
Скажи plz, где взять исходник оригинальный? А то у меня складывается ощущение, что я чего-то не понимаю
.
Цитата(starter48 @ Oct 28 2005, 13:39)
Да, если BUFFER_SIZE=64k, но тогда можно написать просто size = wr_ptr -rd_ptr;
Так можно делать при любом буфере размера степени 2.
Ещё раз прошу взять листик в клеточку и убедиться самостоятельно.
Или убедить меня - привести хотя бы один пример конкретных и корректных значений wr_ptr, rd_ptr и BUFFER_SIZE, при которых size = wr_ptr - rd_ptr; даёт неправильное значение.
Под корректными понимаются - BUFFER_SIZE есть (1 shl n) n=0,15; буфер не переполнен.
Цитата(starter48 @ Oct 28 2005, 13:39)
Но ReAl говорил, что буфер может быть 1/2/4/8k, тогда так писать нельзя.
Допустим, wr_ptr = 0;rd_ptr = 1; т.е. циклицеский буфер весь заполнен.
Допустим, wr_ptr = 0;rd_ptr = 1; т.е. циклицеский буфер весь заполнен.
Если wr_ptr и rd_ptr такие, то он не заполнен, а очень много раз переполнен (65535 для буфера размером 64К).
Ещё раз. wr_ptr и rd_ptr это не столько указатели, сколько IP "номера последовательности". Про то, что они - IP, а не указатели в буфере, я уже писал. Они же 32-битные.
Ну подумай сам. Пусть было rd_ptr ==1, wr_ptr == 1 (буфер пуст).
Сколько байт надо записать, чтобы 32-битный wr_ptr свернулся в колечко?
Я это и имел ввиду под параноидальным вариантом - но и тогда никакие BUFFER_SIZE при вычислении size не нужны.
Цитата(starter48 @ Oct 28 2005, 13:39)
Чтобы этого избежать можно сделать так:
Код
size = BUFFER_SIZE - rd_ptr + wr_ptr;//size = BUFFER_SIZE - 1
Вот и залетели. Не поймали переполнение, так как на самом деле в буфер
было записано 0xFFFFFFFF байт, в результате которых wr_ptr из 1 превратился в 0.
Цитата(starter48 @ Oct 28 2005, 13:39)
Код
или
size = (wr_ptr - rd_ptr) % BUFFER_SIZE;
//size = 0xFFFFFFF % BUFFER_SIZE = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) & (BUFFER_SIZE-1);
//size = 0xFFFFFFF & (BUFFER_SIZE-1) = BUFFER_SIZE - 1
size = (wr_ptr - rd_ptr) % BUFFER_SIZE;
//size = 0xFFFFFFF % BUFFER_SIZE = BUFFER_SIZE - 1
или
size = (wr_ptr - rd_ptr) & (BUFFER_SIZE-1);
//size = 0xFFFFFFF & (BUFFER_SIZE-1) = BUFFER_SIZE - 1
По этой причине и все эти % млм & не просто не нужны, а вредны
Цитата(starter48 @ Oct 28 2005, 13:39)
Скажи plz, где взять исходник оригинальный? А то у меня складывается ощущение, что я чего-то не понимаю .
.Имеем 1/2/4/8 - килобайтный буфер и 32-битные "указатели", которые наращиваются без учёта самого буфера (IP sequence numbers или как их там).
Младшие биты этих величин можно рассматривать как указатели в буфере, старшие - как число "сворачиваний" младших битов по модулю размера буфера.
Цитата(ReAl @ Oct 28 2005, 19:04)
Ещё раз. wr_ptr и rd_ptr это не столько указатели, сколько IP "номера последовательности". Про то, что они - IP, а не указатели в буфере, я уже писал. Они же 32-битные.
Ну подумай сам. Пусть было rd_ptr ==1, wr_ptr == 1 (буфер пуст).
Сколько байт надо записать, чтобы 32-битный wr_ptr свернулся в колечко?
Я это и имел ввиду под параноидальным вариантом - но и тогда никакие BUFFER_SIZE при вычислении size не нужны.
По этой причине и все эти % млм & не просто не нужны, а вредны
Имеем 1/2/4/8 - килобайтный буфер и 32-битные "указатели", которые наращиваются без учёта самого буфера (IP sequence numbers или как их там).
Младшие биты этих величин можно рассматривать как указатели в буфере, старшие - как число "сворачиваний" младших битов по модулю размера буфера.
Ну подумай сам. Пусть было rd_ptr ==1, wr_ptr == 1 (буфер пуст).
Сколько байт надо записать, чтобы 32-битный wr_ptr свернулся в колечко?
Я это и имел ввиду под параноидальным вариантом - но и тогда никакие BUFFER_SIZE при вычислении size не нужны.
По этой причине и все эти % млм & не просто не нужны, а вредны
Имеем 1/2/4/8 - килобайтный буфер и 32-битные "указатели", которые наращиваются без учёта самого буфера (IP sequence numbers или как их там).
Младшие биты этих величин можно рассматривать как указатели в буфере, старшие - как число "сворачиваний" младших битов по модулю размера буфера.
Я понял
. Меня в заблуждение ввело название wr_ptr и rd_ptr (ptr=pointer), и то, что ты их указателями назвал. Я думал это индексы для работы с буфером типа buffer[wr_ptr].Я тормоз. Ты прав, если wr_ptr является счётчиком записанных в буфер с момента старта в буфер байт, то писать надо size = wr_ptr - rd_ptr;
а if там просто лишний.
Цитата(starter48 @ Oct 28 2005, 16:02)
Я понял . Меня в заблуждение ввело название wr_ptr и rd_ptr (ptr=pointer), и то, что ты их указателями назвал. Я думал это индексы для работы с буфером типа buffer[wr_ptr].
Я тормоз. Ты прав, если wr_ptr является счётчиком записанных в буфер с момента старта в буфер байт, то писать надо size = wr_ptr - rd_ptr;
а if там просто лишний.
. Меня в заблуждение ввело название wr_ptr и rd_ptr (ptr=pointer), и то, что ты их указателями назвал. Я думал это индексы для работы с буфером типа buffer[wr_ptr].Я тормоз. Ты прав, если wr_ptr является счётчиком записанных в буфер с момента старта в буфер байт, то писать надо size = wr_ptr - rd_ptr;
а if там просто лишний.
А они и используются
Точнее, их младшие биты.Код
// инициализируются величинами SSIZE[i]-1, см письмо #4 в топике
uint16_t SMASK[MAX_SOCKET];
// указатель для доступа к буферу (сворачивание обрабатывается отдельно) сокета s
uint8_t *ptr = START[s] + rd_ptr & SMASK[s];
uint16_t SMASK[MAX_SOCKET];
// указатель для доступа к буферу (сворачивание обрабатывается отдельно) сокета s
uint8_t *ptr = START[s] + rd_ptr & SMASK[s];
Так что для адреса маскирование таки применяется, но для длины оно всё равно не нужно.
Для просмотра полной версии этой страницы, пожалуйста, пройдите по ссылке.