Сравните 64 бита и 16 байт: 64 бита и 16 байт ; 10кбайт и 10600байт; 10байт и 80 бит; 20кбайт и 20480байт; 12бит и 2 байта; 9 байт и 70бит. СРОЧНО НУЖНА ВАША ПОМОЩЬ…

Б) Пе­ре­дать по ка­на­лу связи без ис­поль­зо­ва­ния ар­хи­ва­то­ра.

Какой спо­соб быст­рее и на­сколь­ко, если

– сред­няя ско­рость пе­ре­да­чи дан­ных по ка­на­лу связи со­став­ля­ет 2¹⁸ бит в се­кун­ду,

– объем сжа­то­го ар­хи­ва­то­ром до­ку­мен­та равен 80% от ис­ход­но­го,

– время, тре­бу­е­мое на сжа­тие до­ку­мен­та – 35 се­кунд, на рас­па­ков­ку – 3 се­кун­ды?

В от­ве­те на­пи­ши­те букву А, если спо­соб А быст­рее или Б, если быст­рее спо­соб Б. Сразу после буквы на­пи­ши­те ко­ли­че­ство се­кунд, на­сколь­ко один спо­соб быст­рее дру­го­го. Так, на­при­мер, если спо­соб Б быст­рее спо­со­ба А на 23 се­кун­ды, в от­ве­те нужно на­пи­сать Б23. Слов «се­кунд», «сек.», «с.» к от­ве­ту до­бав­лять не нужно.

Решение:

Спо­соб А. Общее время скла­ды­ва­ет­ся из вре­ме­ни сжа­тия, рас­па­ков­ки и пе­ре­да­чи. Время пе­ре­да­чи t рас­счи­ты­ва­ет­ся по фор­му­ле t = V / q, где V — объём ин­фор­ма­ции, q — скорость пе­ре­да­чи дан­ных.

Объем сжатого документа: 5 * 0,8 = 4 Мб =4 * 2²³ бит.

Найдём общее время: t = 35 с + 3 с + 4 * 2²³ бит / 2¹⁸ бит/с = 38 + 2⁷ с = 166 с.

Спо­соб Б. Общее время сов­па­да­ет с вре­ме­нем пе­ре­да­чи: t = 5 * 2²³ бит / 2¹⁸ бит/с = 5 * 2⁵ с = 160 с.

Спо­соб Б быст­рее на 166 — 160 = 6 с.

Ответ: Б6

Определение времени передачи данных

Пример 7.

Ско­рость пе­ре­да­чи дан­ных через ADSL─со­еди­не­ние равна 128000 бит/c. Через дан­ное со­еди­не­ние пе­ре­да­ют файл раз­ме­ром 625 Кбайт. Опре­де­ли­те время пе­ре­да­чи файла в се­кун­дах.

Решение:

Время t = V / q, где V — объем файла, q — скорость пе­ре­да­чи дан­ных.

t = 625 * 2¹⁰ байт / (2 ⁷ * 1000) бит/c = 625 * 2¹³ бит / (125 * 2¹⁰) бит/c = 5 * 2³ с = 40 с.

Ответ: 40

Пример 8.

У Васи есть до­ступ к Ин­тер­нет по вы­со­ко­ско­рост­но­му од­но­сто­рон­не­му ра­дио­ка­на­лу, обес­пе­чи­ва­ю­ще­му ско­рость по­лу­че­ния им ин­фор­ма­ции 2¹⁷ бит в се­кун­ду. У Пети нет ско­рост­но­го до­сту­па в Ин­тер­нет, но есть воз­мож­ность по­лу­чать ин­фор­ма­цию от Васи по низ­ко­ско­рост­но­му те­ле­фон­но­му ка­на­лу со сред­ней ско­ро­стью 2¹⁵ бит в се­кун­ду. Петя до­го­во­рил­ся с Васей, что тот будет ска­чи­вать для него дан­ные объ­е­мом 4 Мбай­та по вы­со­ко­ско­рост­но­му ка­на­лу и ре­транс­ли­ро­вать их Пете по низ­ко­ско­рост­но­му ка­на­лу. Ком­пью­тер Васи может на­чать ре­транс­ля­цию дан­ных не рань­ше, чем им будут по­лу­че­ны пер­вые 512 Кбайт этих дан­ных. Каков ми­ни­маль­но воз­мож­ный про­ме­жу­ток вре­ме­ни (в се­кун­дах), с мо­мен­та на­ча­ла ска­чи­ва­ния Васей дан­ных, до пол­но­го их по­лу­че­ния Петей? В от­ве­те ука­жи­те толь­ко число, слово «се­кунд» или букву «с» до­бав­лять не нужно.

Решение:

Нужно опре­де­лить, сколь­ко вре­ме­ни будет пе­ре­да­вать­ся файл объ­е­мом 4 Мбай­та по ка­на­лу со ско­ро­стью пе­ре­да­чи дан­ных 2¹⁵ бит/с; к этому вре­ме­ни нужно до­ба­вить за­держ­ку файла у Васи (пока он не по­лу­чит 512 Кбайт дан­ных по ка­на­лу со ско­ро­стью 2¹⁷ бит/с).

Время скачивания дан­ных Петей: t₁= 4*2²³ бит / 2¹⁵ бит/с = 2¹⁰ c.

Время за­держ­ки: t₂ = 512 кб / 2¹⁷ бит/с = 2^{(9 + 10 + 3) — 17} c = 2⁵ c.

Пол­ное время: t₁ + t₂ = 2¹⁰ c + 2⁵ c = (1024 + 32) c = 1056 c.

Ответ: 1056

Пример 9.

Данные объемом 60 Мбайт передаются из пункта А в пункт Б по каналу связи, обеспечивающему скорость передачи данных 2¹⁹ бит в секунду, а затем из пункта Б в пункт В по каналу связи, обеспечивающему скорость передачи данных 2²⁰ бит в секунду. Задержка в пункте Б (время между окончанием приема данных из пункта А и началом передачи в пункт В) составляет 25 секунд. Сколько времени (в секундах) прошло с момента начала передачи данных из пункта А до их полного получения в пункте В? В ответе укажите только число, слово «секунд» или букву «с» добавлять не нужно.

Решение:

Полное время складывается из времени передачи из пункта А в пункт Б (t₁), задержки в пункте Б (t2) и времени передачи из пункта Б в пункт В (t₃).

t₁ = (60 * 2²³) / 2¹⁹ =60 * 16 = 960 c

t₂ = 25 c

t₃ = (60 * 2²³) / 2²⁰ =60 * 8 = 480 c

Полное время t₁ + t₂ +t₃ = 960 + 25 + 480 = 1465 c

Ответ: 1465

Спасибо за то, что пользуйтесь нашими статьями. Информация на странице «Задача №9. Кодирование звуковой и графической информации. Передача информации, Время записи звукового файла, время передачи данных, определение объема информации.» подготовлена нашими авторами специально, чтобы помочь вам в освоении предмета и подготовке к экзаменам. Чтобы успешно сдать необходимые и поступить в высшее учебное заведение или техникум нужно использовать все инструменты: учеба, контрольные, олимпиады, онлайн-лекции, видеоуроки, сборники заданий. Также вы можете воспользоваться другими статьями из разделов нашего сайта.

Публикация обновлена: 07.04.2023

CMPXCHG8B/CMPXCHG16B — сравнение и обмен байтами

Код операции/Инструкция	Оп/Ан	64-битный режим	Режим совместимости/этапа	Описание
0F C7/1 CMPXCHG8B m64	М	Действительный	Действительно*	Сравните EDX:EAX с m64 . Если они равны, установите ZF и загрузите ECX:EBX в m64 . В противном случае очистите ZF и загрузите m64 в EDX:EAX.
REX.W + 0F C7/1 CMPXCHG16B m128	М	Действительный	Н.В.	Сравните RDX:RAX с m128 . Если равны, установите ZF и загрузите RCX:RBX в m128 . В противном случае очистите ZF и загрузите m128 в RDX:RAX.

* См. ниже раздел «Совместимость с архитектурой IA-32».

Кодирование операнда инструкции ¶

Описание ¶

Сравнивает 64-битное значение в EDX:EAX (или 128-битное значение в RDX:RAX, если размер операнда равен 128 битам) с операндом (целевым операндом). Если значения равны, 64-битное значение в ECX:EBX (или 128-битное значение в RCX:RBX) сохраняется в операнде назначения. В противном случае значение в операнде назначения загружается в EDX:EAX (или RDX:RAX). Операнд назначения представляет собой 8-байтовую ячейку памяти (или 16-байтовую ячейку памяти, если размер операнда равен 128 битам). Для пар регистров EDX:EAX и ECX:EBX EDX и ECX содержат старшие 32 бита, а EAX и EBX содержат младшие 32 бита 64-битного значения. Для пар регистров RDX:RAX и RCX:RBX RDX и RCX содержат старшие 64 бита, а RAX и RBX содержат младшие 64 бита 128-битного значения.

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

В 64-битном режиме размер операции по умолчанию составляет 64 бита. Использование префикса REX.W способствует работе до 128 бит. Обратите внимание, что CMPXCHG16B требует, чтобы операнд назначения (память) был выровнен по 16 байтам. См. сводную таблицу в начале этого раздела для кодирования данных и ограничений. Для получения информации о флаге CPUID, который указывает CMPXCHG16B, см. стр. 3-237.

¶

Эта кодировка инструкций не поддерживается процессорами Intel более ранними, чем процессоры Pentium.

Операция ¶

 IF (64-битный режим и OperandSize = 64)
    ЗАТЕМ
        TEMP128 := НАЗНАЧЕНИЕ
        ЕСЛИ (RDX:RAX = TEMP128)
            ЗАТЕМ
                ЗФ := 1;
                НАЗНАЧЕНИЕ := RCX:RBX;
            ЕЩЕ
                ЗФ := 0;
                RDX:RAX := TEMP128;
                НАЗНАЧЕНИЕ := TEMP128;
                ФИ;
        ФИ
    ЕЩЕ
        TEMP64 := НАЗНАЧЕНИЕ;
        ЕСЛИ (EDX:EAX = TEMP64)
            ЗАТЕМ
                ЗФ := 1;
                НАЗНАЧЕНИЕ := ECX:EBX;
            ЕЩЕ
                ЗФ := 0;
                EDX:EAX := TEMP64;
                НАЗНАЧЕНИЕ := TEMP64;
                ФИ;
        ФИ;
ФИ;
 

Затронутые флаги ¶

Флаг ZF устанавливается, если операнд назначения и EDX:EAX равны; в противном случае он очищается. Флаги CF, PF, AF, SF и OF не затрагиваются.

Исключения защищенного режима ¶

#УД	Если назначение не является операндом памяти.
#GP(0)	Если место назначения находится в недоступном для записи сегменте.
	Если эффективный адрес операнда памяти выходит за пределы сегмента CS, DS, ES, FS или GS.
	Если регистр DS, ES, FS или GS содержит селектор сегмента NULL.
#СС(0)	Если эффективный адрес операнда памяти выходит за пределы сегмента SS.
#PF(код неисправности)	Если происходит ошибка страницы.
#AC(0)	Если включена проверка выравнивания и выполняется невыровненная ссылка на память, когда текущий уровень привилегий равен 3.

Исключения режима реального адреса ¶

Исключения режима Virtual-8086 ¶

#УД	Если операнд назначения не является ячейкой памяти.
#GP(0)	Если эффективный адрес операнда памяти выходит за пределы сегмента CS, DS, ES, FS или GS.
#СС(0)	Если эффективный адрес операнда памяти выходит за пределы сегмента SS.
#PF(код неисправности)	Если происходит ошибка страницы.
#AC(0)	Если включена проверка выравнивания и делается невыровненная ссылка на память.

Исключения режима совместимости ¶

Те же исключения, что и в защищенном режиме.

Исключения 64-битного режима ¶

#СС(0)	Если адрес памяти, ссылающийся на сегмент SS, имеет неканоническую форму.
#GP(0)	Если адрес памяти имеет неканоническую форму.
	Если операнд памяти для CMPXCHG16B не выровнен по 16-байтовой границе.
	Если CPUID.01H:ECX.CMPXCHG16B[бит 13] = 0.
#УД	Если операнд назначения не является ячейкой памяти.
#PF(код неисправности)	Если происходит ошибка страницы.
#AC(0)	Если включена проверка выравнивания и делается невыровненная ссылка на память при текущем уровне привилегий 3.

Биты, размеры, знаковые и беззнаковые

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

Например:

 целочисленное значение=1; /* значение для проверки, начиная с первого (младшего) бита */
for (целое число бит=0;бит<100;бит++) {
std::cout<<"в бите "<
 (Попробуйте сейчас в NetRun!)
 Поскольку "int" в настоящее время имеет 32 бита, если вы начнете с одного и добавите переменную к себе 32 раза, один переполнится и будет полностью потерян.
 В ассемблере есть удобная инструкция "jo" (переход при переполнении) для проверки переполнения из предыдущей инструкции. Однако компилятор C++ не удосуживается использовать jo!
 мов эди,1 ; переменная цикла
дв акс,0 ; прилавок
начинать:
добавить eax,1 ; приращение битового счетчика
добавить эди, эди ; добавить переменную к себе
Джо нет ; проверьте наличие переполнения в приведенном выше добавлении
cmp эди,0
начало
рет
нет: ; призвал к переполнению
движение eax, 999
рет
 
 (Попробуйте сейчас в NetRun!)
 Обратите внимание, что приведенная выше программа возвращает 999 при переполнении, которое должен проверить кто-то другой. (Правильно реагировать на переполнение на самом деле довольно сложно — см., например, взрыв Ariane 5, вызванный обнаруженным переполнением.)
 Размеры хранилища C++ 
 Восемь битов составляют «байт» (примечание: это произносится точно так же, как «укус», но всегда пишется с «y»), хотя в некоторых редких сетевых руководствах (и на французском языке) те же восемь битов будут называться «октетом». " (размеры жестких дисков указаны в гигабайтах "Go" при продаже на французском языке). В программировании для DOS и Windows 16 бит — это «WORD», 32 бита — это «DWORD» (двойное слово), а 64 бита — это «QWORD»; но в других контекстах «слово» означает естественный размер двоичной обработки машины, который в настоящее время колеблется от 32 до 64 бит. «слово» теперь следует считать двусмысленным. Указание фактического количества битов - лучший подход («Файл начинается с 32-битного двоичного целого числа, описывающего ...»).
  Объект 
  Имя С++ 
  Биты 
  байт 
 (8 бит) 
  Шестнадцатеричные цифры 
 (4 бита) 
  Восьмеричные цифры 
 (3 бита) 
  Диапазон без знака 
  Диапазон со знаком  
 Бит
 нет!
 1
 меньше 1
 меньше 1
 меньше 1
 0. .1
 -1..0
 Байт или октет
 символ
 8
 1
 2
 две и две трети
 255
 -128 .. 127
 Windows СЛОВО
 короткий
 16
 2
 4
 пять и одна треть
 65535
 -32768 .. +32767
 Двойное слово Windows
 число
 32
 4
 8
 десять и две трети
 >4 миллиарда
 -2Г . . +2Г
 Windows QWORD
 длинный
 64
 8
 16
 двадцать одна и одна треть
 >16 квадриллионов
 -8Q .. +8Q
  
 Размеры регистров в сборке 
 Как и переменные C++, регистры доступны в нескольких размерах:
 rax — 64-битный регистр «длинного» размера. Он был добавлен в 2003 году. Ниже я отметил красным цветом добавленные с 64-разрядными регистрами.
 eax - это 32-битный регистр размера "int". Он был добавлен в 1985 году. Я привык использовать этот размер регистра, так как они также работают в 32-битном режиме, хотя мне, вероятно, следует использовать более длинные регистры rax для всего.
 axe — это 16-битный регистр «короткого» размера. Он был добавлен в 1979 году.
 al и ah - это 8-битные части регистра размером "char". al — младшие 8 бит (например, ax&0xff), ah — старшие 8 бит (например, ax>>8). Они оригинальные до 1972.
 Любопытно, что вы можете записать 64-битное значение в rax, а затем считать младшие 32 бита из eax, или младшие 16 битx из ax, или младшие 8 бит из al — это всего лишь один регистр, но они сохраняют при продлении!
 ракс: 64-бит
 eax: 32-битный
 топор: 16-битный
 
 Например,
 мов rcx,0xf00d00d2beefc03; загрузить 64-битную константу 
 mov eax,ecx; вытащить младшие 32 бита 
 ret 
 (Попробуйте сейчас в NetRun!)
 Вот полный список регистров x86. 64-битные регистры показаны красным. Регистры «Scratch», которые вы можете перезаписывать и использовать для чего угодно.  Сохраненные регистры  " служат какой-то важной цели где-то еще, поэтому, как мы поговорим на следующей неделе, вы должны вернуть их обратно ("сохранить" регистр), если вы их используете - пока просто оставьте их в покое! 
 Примечания
 64-битный 
 длинный
 32-разрядный 
 целое число
 16-битный 
 короткий
 8-бит 
 символ
 Значения возвращаются из функций в этом регистре. Инструкции умножения также помещают сюда младшие биты результата.
 ракс
 эх
 топор
 ах и ал
 Типовой рабочий регистр. Некоторые инструкции используют его как счетчик (например, SAL или REP).
 РКС
 ЕСХ
 сх
 ч и кл
 Скретч-регистр. Инструкции умножения помещают сюда старшие биты результата.
 РДС
 эдкс
 дх
 ДХ и ДЛ
  Сохраненный регистр: не используйте его без сохранения! 
  рбкс 
  ebx 
  бх 
  ш и бл 
  Указатель стека. Указывает на вершину стека (подробности на следующей неделе!) 
  рсп 
  исп 
  сп 
  спл 
  Сохраненный реестр. Иногда используется для хранения старого значения указателя стека или «базы». 
  рбп 
  эбп 
  п.н. 
  баррель 
 Скретч-регистр. Также используется для передачи аргумента функции #2 в 64-битном режиме (в Linux).
 рупий
 ЕСИ
 и
 или
 Скретч-регистр. Аргумент функции №1.
 рди
 эди
 по
 до
 Скретч-регистр. Они были добавлены в 64-битном режиме, поэтому названия немного отличаются.
 р8
 р8д
 р8в
 р8б
 Скретч-регистр.
 р9
 р9д
 р9в
 р9б
 Скретч-регистр.
 р10
 р10д
 р10в
 р10б
 Скретч-регистр.
 р11
 р11д
 р11в
 р11б
  Сохраненный реестр. 
  р12 
  р12д 
  р12в 
  р12б 
  Сохраненный реестр. 
  р13 
  р13д 
  р13в 
  р13б 
  Сохраненный реестр. 
  р14 
  р14д 
  р14в 
  р14б 
  Сохраненный реестр. 
  р15 
  р15д 
  р15в 
  р15б 
  
 Подписанные и неподписанные номера 
 Если вы внимательно посмотрите прямо перед переполнением, вы увидите, что происходит нечто забавное:
 значение символа со знаком = 1; /* значение для проверки, начиная с первого (младшего) бита */
for (целое число бит=0;бит<100;бит++) {
std::cout<<"в бите "<
 (Попробуйте сейчас в NetRun!)
 Напечатает:
 в бите 0 значение равно 1
в бите 1 значение равно 2
в бите 2 значение равно 4
в бите 3 значение равно 8
в бите 4 значение равно 16
в бите 5 значение равно 32
в бите 6 значение равно 64
в бите 7 значение равно -128
Программа завершена. Возврат 0 (0x0) 
 Подождите, значение последнего бита равно -128? Да, это действительно так!
 Этот отрицательный старший бит называется «знаковым битом» и имеет отрицательное значение в числах со знаком, дополненных до двух. Это означает, что для представления -1, например, вы устанавливаете не только старший бит, но и все остальные биты: в беззнаковом, это максимально возможное значение. Причина, по которой двоичный код 11111111 представляет собой -1, та же самая, по которой вы можете выбрать 9.999 для представления -1 на 4-значном одометре: если вы добавите единицу, вы сделаете круг и достигнете нуля.
 Очень интересная вещь в дополнении до двух: сложение  — одна и та же операция , независимо от того, знаковые числа или беззнаковые — мы просто интерпретируем результат по-разному. Вычитание также идентично для знакового и беззнакового. Имена регистров идентичны в ассемблере для подписанных и неподписанных. Однако, когда вы изменяете размеры регистров с помощью такой инструкции, как «movsxd rax,eax», когда вы проверяете переполнение, когда вы сравниваете числа, умножаете или делите или сдвигаете биты, вам нужно знать, подписано ли число (имеет ли знак бит) или без знака (без бита знака, без отрицательных чисел).
 Сборка
  Подпись 
  Без знака 
  Язык 
 ряд
 целое число без знака
 C++, «int» имеет знак по умолчанию.
 знаковый символ
 беззнаковый символ
 C++, «char» может быть подписанным или беззнаковым.
 мовскд
 мовзд
 Сборка, расширение знака или расширение нуля для изменения размера регистра.
 ио
 джк
, «переполнение» вычисляется для значений со знаком, «перенос» — для значений без знака.
 джг
 и
 Сборка, «прыжок выше» подписан, «прыжок выше» не подписан.
Published in Разное
 Ваш комментарий будет первым
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
 Комментарий
 Имя* 
 Email* 
 Веб-сайт 
  
 Scroll to the top