สามารถใช้ตัวชี้ขนาด 4 บิต 8 บิต 16 บิตหรือ 32 บิตบนเครื่อง 64 บิตได้หรือไม่?

ฉันแค่คำนวณคร่าวๆ ขนาดสูงสุดของจำนวนเต็ม 64 บิตที่ไม่ได้ลงนาม , ซึ่งเป็น:

18,446,744,073,709,551,615
q5 q4  t   b   m   t   h

มองไปที่ ข้อมูลจำเพาะฮาร์ดแวร์ของ AWS สำหรับเครื่องจักรที่ใหญ่ที่สุดของพวกมัน 3,904GB, ซึ่งเป็น:

3,904,000,000,000,000,000 bytes
5 q4  t   b   m   t   h

สำหรับฉันนั่นหมายถึง พอยน์เตอร์จะถูกเก็บเป็นจำนวนเต็ม 64 บิต . ฉันยังใหม่กับการคิดเกี่ยวกับความทรงจำและพอยน์เตอร์ แต่ต้องการอธิบายให้ชัดเจน

ฉันยังสับสนอยู่เล็กน้อย ตัวชี้ คือ "โครงสร้างการเขียนโปรแกรมภาษา" ดังนั้นทางเทคนิคแม้ในเครื่อง 64 บิตหากคุณใช้งานน้อยกว่า ~ 4 พันล้าน จำนวนเต็ม (ขนาดจำนวนเต็มสูงสุด 32- บิต) แล้วฉันสงสัยว่าทำไมคุณไม่สามารถมีพอยน์เตอร์เป็น 32 บิตได้ ด้วยวิธีนี้พอยน์เตอร์คือ 32- บิตจนกว่าคุณจะหมดพื้นที่จากนั้นคุณสามารถเริ่มใช้พอยน์เตอร์ 64- บิต จากนั้นมันจะให้พื้นที่เพิ่มขึ้นอีกเล็กน้อยเพื่อให้มีวัตถุมากขึ้น

ยังคงสับสนอยู่ ตัวชี้เก็บตำแหน่งของ ที่อยู่ในหน่วยความจำ . มันบอกว่า "ที่อยู่" คือ 64- บิต ดังนั้นหากเราต้องมีพอยน์เตอร์ 32- บิตชี้ไปที่ชิ้น 32- บิตในหน่วยความจำ 64- บิตฉันไม่แน่ใจว่าสิ่งที่จะมีลักษณะหรือหมายถึง ดูเหมือนว่าคุณจะต้องทำ ชดเชย (แต่ฉันก็ไม่เข้าใจเช่นกัน)

หากสงสัยว่ามีใครสามารถสาธิตใน C, Assembly หรือ JavaScript ได้ว่าจะเก็บพอยน์เตอร์ 32 บิตในพื้นที่ที่อยู่ 64 บิตได้อย่างไร ถ้า C จัดการให้คุณโดยอัตโนมัติแล้วแอสเซมบลีทำหน้าที่อย่างไร

ฉันต้องการทราบว่าฉันสามารถใช้หน่วยความจำขนาดใหญ่เช่นด้านบนได้อย่างไร แต่เก็บตัวชี้ 32- บิตจนกว่าจะถึงจำนวนสูงสุดแล้วใช้ตัวชี้ 64- บิตและไม่แน่ใจว่าสิ่งที่จะดูเหมือน ฉันจะพยายามวาดแผนภาพอธิบายว่าฉันคิดอย่างไร

  | The bars and . are like a ruler and mark the bit positions.
  - Each row under a number (1, 2, 3, ...) means a memory address.
  ⬚ Means no data in memory address.
  ⬒ Means data of type 1 in memory address.
  ■ Means data of type 2 in memory address.
  ● Means a bit of integer pointer is plugged into memory address slot.
  ◌ Means no bit of integer pointer is plugged into memory address slot.
                                                                                                                                 |
                                                                 |                                                               |
                                 |                               |                               |                               |
                 |               |               |               |               |               |               |               |
         |       |       |       |       |       |       |       |       |       |       |       |       |       |       |       |
   . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . |

1. Empty 64-bit memory.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ...
   ...
   ...

2. 64-bit memory filled with 32-bit pieces of data (type 1 ⬒, type 2 ■).
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ...
   ...
   ...

3. 64-bit memory filled with 64-bit pieces of data.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

4. 64-bit memory filled with 4-bit pieces of data.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ...
   ...
   ...

5. 64-bit memory filled with 32-bit pieces of data, with second 32-bits accessed by a 32-bit pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ 
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ... 
   ...
   ...

6. 64-bit memory filled with 64-bit pieces of data, with second 64-bits accessed by a 64-bit pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

7. 64-bit memory filled with 4-bit pieces of data, with second piece of data accessed by a pointer.
   ◌ ◌ ◌ ◌ ● ● ● ● ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ...
   ...
   ...

8. 64-bit memory filled with 8-bit pieces of data, with second piece of data accessed by a pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ● ● ● ● ● ● ● ● ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ 
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

สิ่งที่ฉันจินตนาการคือจำนวนเต็มเปรียบเสมือนกุญแจสำหรับล็อค (ซึ่งเป็นที่อยู่หน่วยความจำ) รูกุญแจว่างเปล่าดูเหมือนว่า 64 in ในแถวใน (1) รูกุญแจแบบเต็มสำหรับที่อยู่ 64- บิตดูเหมือนว่าอยู่ในแถวที่ 64 ● (6) ถ้าฉันให้ที่อยู่หน่วยความจำ 64 บิตพื้นที่ 32 บิต สำคัญเหมือนว่ามันจะมีลักษณะเหมือน (5) ดังนั้นมันจะไม่เติมเต็มในรูกุญแจยาว 64- บิต (64- ◌) มันจะเติม (ในกรณีนี้) ครึ่งหลังของมันเท่านั้น และดูเหมือนว่าจะไม่ตรงกับที่อยู่ แต่ฉันกำลังพยายามชี้ไปที่ข้อมูล 32 บิตที่นั่นในช่วงครึ่งหลัง! เพื่อให้ตรงกับที่อยู่ดูเหมือนว่าคุณจะต้องกรอกข้อมูลลงในรูกุญแจในแถว 64- บิตเต็มเช่นเดียวกับใน (6) ฉันสงสัยว่าความเข้าใจของฉันจะยุ่งเหยิงที่นี่โปรดแจ้งให้ฉันทราบว่าฉันอยู่ที่ไหน

ในกรณีที่ยังไม่ชัดเจนตัวเลขแรกที่ 1-4 ในแผนภูมิแสดงข้อมูลที่วางในหน่วยความจำ (โดยที่ 1 เป็นหน่วยความจำว่าง) ตัวเลขที่สอง 5-8 แสดงให้เราเห็นถึงความพยายาม ทางเข้า ข้อมูลโดยใช้ตัวชี้ (วงกลมสีดำ●ในแถวเป็นตัวชี้ / คีย์ไปยังการล็อกที่อยู่หน่วยความจำ)

ในที่สุดฉันมีหนึ่งประเด็นสุดท้าย ฉันสงสัยว่าคุณสามารถนำไปใช้เพิ่มเติมและจัดเก็บข้อมูลที่ชิ้นเล็กลง เช่นการจัดเก็บข้อมูล 4 บิตเช่นเดียวกับใน (7) นี่เป็นเพียงการสาธิตวิธีการทำงานของระบบตัวชี้ / ที่อยู่อย่างละเอียดยิ่งขึ้น ฉันไม่รู้ว่าคุณสามารถมี ตัวชี้ 4 บิต ชี้ไปที่หน่วยความจำ 4 บิต ดูเหมือนว่าเนื่องจากข้อกำหนดการจัดตำแหน่งคุณจะต้องดึงข้อมูลอย่างน้อย 8 บิตในแต่ละครั้ง แต่ก็ไม่เป็นไร ฉันแค่ต้องการตรวจสอบให้แน่ใจว่าเป็นไปไม่ได้หรือไม่สามารถใช้ตัวชี้ n-bit เพื่อเข้าถึงข้อมูลบิตในพื้นที่หน่วยความจำ 64 บิต

และถ้าเป็นเช่นนั้นจะมีลักษณะอย่างไรทั้งใน C หรือ Assembly หรือ JavaScript ก็จะทำงานได้เช่นกัน

ฉันต้องการทราบวิธีการนี้เพื่อทราบว่าคุณควรจะเก็บข้อมูลในหน่วยความจำ 64 บิตอย่างไรและคุณได้รับอนุญาตให้ทำอะไรกับตัวชี้เนื่องจาก "ที่อยู่หน่วยความจำคือ 64- บิต" นั่นคือถ้าฉันสามารถทำได้ memory.get(a32BitPointer) และให้มันคืนค่าข้อมูล 32 บิตจากสล็อตหน่วยความจำที่จัดชิดแบบ 32 บิต (หรือเทียบเท่าบิตข้อมูลบิตหรือตัวชี้ขนาด 4, 8, 16 ฯลฯ )

ตัวชี้ ชี้ไปที่ มี ที่อยู่ที่แน่นอน

หากคุณต้องการเพิ่มค่าก่อนที่จะใช้ตัวชี้สิ่งที่คุณมีคือ สาขา ไม่ใช่ตัวชี้ที่แท้จริง

ใน C ตัวชี้โมฆะสามารถเป็นตัวชี้ฟังก์ชันเช่น คุณสามารถเรียกฟังก์ชั่นผ่านมันได้ เพื่อให้สามารถใช้งานได้คุณจำเป็นต้องใช้ทั้ง 64 บิตหาก CPU อยู่ในโหมด 64 บิต

หาก CPU ของคุณรองรับ 64 บรรทัดที่อยู่ (อาจมีน้อยกว่าทางกายภาพ) แสดงว่ามีพื้นที่ที่อยู่เป็น 2 ^ 64 ซึ่งเป็น 0x1 0000 0000 0000 0000 - ตั้งแต่ 0x0000 0000 0000 0000 ไปยัง 0xFFFF FFFF FFFF FFFF.

หากคุณต้องการให้ตัวชี้ของคุณสามารถใช้งานได้โดยคำแนะนำของ CPU โดยไม่จำเป็นต้องใช้คำสั่ง CPU เพิ่มเติมเพื่อค้นหาสิ่งที่คุณหมายถึงจริงๆ (รหัส CPU ดั้งเดิมสามารถจัดการกับตัวชี้โดยตรง) จากนั้นจะต้องกว้างเท่ากับพื้นที่ที่อยู่ของ CPU

ออฟเซ็ตจะช้าลงเนื่องจาก CPU ต้องเพิ่มเพื่อรับที่อยู่ที่คุณต้องการแม้ว่า CPU จะมีคำสั่งพื้นฐานที่ทำเช่นนั้นด้วย

ฉันไม่ใช่ผู้เชี่ยวชาญสุดยอดกับ x86-64 ISA แต่อาจมีคำสั่ง CPU ที่ให้ค่า 32 บิตเป็นค่า 64- บิตกับ 32 บิตแรกที่สันนิษฐานว่าเป็น 0 CPU ยังมีภายใน "ขยาย" ของจริง ค่าถึง 64 บิต

ใน x86 และ x86-64 คุณสามารถใช้ 8, 16, 32 และ 64 บิตได้อย่างแน่นอน ชดเชย (ไม่มีคำสั่งซีพียู x86 / x86 ที่ใช้งานได้เพียงค่า 4 บิต)

ก่อนอื่นหน่วยความจำ 3904GB ต้องการที่อยู่เพียง 42 บิต มันประกอบด้วยเท่านั้น 3 904 000 000 000 ไบต์แทนสิ่งที่คุณคำนวณ

PS C:\> [math]::Log(3904GB, 2)
41.9307373375629

ดังนั้นทางเทคนิคแม้กระทั่งบนเครื่อง 64 บิตหากคุณใช้จำนวนเต็มน้อยกว่า ~ 4 พันล้านเท่านั้น (ขนาดเต็มสูงสุด 32- บิต) ฉันก็สงสัยว่าทำไมคุณไม่สามารถให้พอยน์เตอร์เป็น 32 บิตได้ ด้วยวิธีนี้พอยน์เตอร์คือ 32- บิตจนกว่าคุณจะหมดพื้นที่จากนั้นคุณสามารถเริ่มใช้พอยน์เตอร์ 64- บิต จากนั้นมันจะให้พื้นที่เพิ่มขึ้นอีกเล็กน้อยเพื่อให้มีวัตถุมากขึ้น

x32 ABI คือ 64-bit x86 ABI ที่ใช้พอยน์เตอร์ 32- บิต กระบวนการมีพื้นที่ที่อยู่เพียง 32 บิตซึ่งหมายความว่าพวกเขาไม่สามารถใช้หน่วยความจำมากกว่า 4GB (ไม่มีปัญหาสำหรับแอปพลิเคชันผู้ใช้ส่วนใหญ่) แต่พวกเขาจะสามารถใช้ประโยชน์จากพื้นที่ลงทะเบียนที่ใหญ่และกว้างขึ้น พื้นที่หน่วยความจำส่วนกลางยังคงเป็น 64 บิตเนื่องจากถูกแก้ไขในฮาร์ดแวร์ดังนั้นตัวชี้แบบ 32 บิตจะถูกใช้เป็นออฟเซ็ตไปยังที่อยู่พื้นฐานของกระบวนการแทนที่จะเป็นตัวชี้โดยตรง การใช้งานเป็นแบบนี้

void* getRealPointer(uintptr_t base_addr, uint32_t ptr)
{
    return (void*)(base_addr + ptr); // value stored in pointer is the offset/distance from base
}

เทคนิคนี้เป็นเรื่องธรรมดาในสถาปัตยกรรม 64 บิตอื่น ๆ เช่น Sparc ( ทำไม Linux บนสถาปัตยกรรม sparc64 จึงใช้ตัวชี้แบบ 32 บิตในพื้นที่ผู้ใช้และตัวชี้แบบ 64 บิตในเคอร์เนลพื้นที่ ), MIPS หรือ PowerPC เนื่องจากเมื่อเปลี่ยนเป็น 64- บิตพวกเขาไม่ได้เพิ่มจำนวนการลงทะเบียนเช่น x86 และ ARM ซึ่งหมายความว่ากระบวนการแบบ 32 บิตน่าจะเร็วกว่าแบบ 64 บิตเว้นแต่ว่าจะต้องการ 64 บิต คณิตศาสตร์หรือมากกว่า 2/3 / 4GB of RAM

บนโปรเซสเซอร์ 64 บิตเช่น G5 Debian PPC ใช้เคอร์เนล 64 บิตพร้อมพื้นที่ผู้ใช้ 32 บิต นี่เป็นเพราะโปรเซสเซอร์ PowerPC 64 บิตไม่มี "โหมด 32 บิต" เช่นสถาปัตยกรรม Intel 64 / AMD64 ดังนั้นโปรแกรม PowerPC 64- บิตที่ไม่จำเป็นต้องใช้ฟังก์ชั่นทางคณิตศาสตร์ 64- บิตจะทำงานค่อนข้างช้ากว่าคู่ 32- บิตของพวกเขาเพราะตัวชี้ 64- บิตและจำนวนเต็มยาวใช้หน่วยความจำมากเป็นสองเท่าเติมแคชของ CPU ให้เร็วขึ้น การเข้าถึงหน่วยความจำบ่อย

https://lwn.net/Articles/395894/

อย่างไรก็ตามคุณไม่สามารถใช้พอยน์เตอร์ 32- บิตได้ until you run out of space then start using 64-bit pointersนั่นไม่สมเหตุสมผลเลย ประเภทจะมีขนาดคงที่เสมอ หากคุณจองพื้นที่สำหรับตัวชี้ 32 บิตเท่านั้นจะเกิดอะไรขึ้นเมื่อคุณต้องการใช้ตัวชี้แบบ 64 บิต คุณจะเก็บส่วนสูงไว้ที่ไหน

ดังนั้นหากเราต้องมีพอยน์เตอร์ 32- บิตชี้ไปที่ชิ้น 32- บิตในหน่วยความจำ 64- บิตฉันไม่แน่ใจว่าสิ่งที่จะมีลักษณะหรือหมายถึง

ที่เรียกว่า หน่วยความจำคำพูดได้ . แทนที่จะชี้ไปที่แต่ละไบต์ตอนนี้แต่ละค่าก็ชี้ไปที่อื่น คำ

• "การแก้ไขที่อยู่ในระดับไบต์" หมายความว่าอะไร
• หน่วยความจำที่แอดเดรสที่กำหนดคำได้มีไบต์มากกว่าหน่วยความจำที่กำหนดแอดเดรสของไบต์ได้หรือไม่
• แอดเดรสไบต์ / คำ
• สถาปัตยกรรมคอมพิวเตอร์สามารถตั้งคำได้อย่างไรเมื่อหน่วยความจำทางกายภาพสามารถกำหนดแอดเดรสแบบไบต์เท่านั้น ที่อยู่หน่วยความจำทั้งสองถูกรวมกันหรือไม่

มันจะง่ายกว่าที่จะจินตนาการว่าหน่วยความจำประกอบด้วยชุดของเส้นตรง เซลล์ ที่ระบุด้วยรหัสเฉพาะ ID เหล่านั้นคือสิ่งที่เราเรียกว่า "ที่อยู่" และเป็นสิ่งที่ถูกเก็บไว้ในพอยน์เตอร์ ขนาดของเซลล์โดยทั่วไปคือ 1 ไบต์บนระบบที่ทันสมัย ​​(เช่นหน่วยความจำที่สามารถระบุตำแหน่งไบต์ได้) อย่างไรก็ตาม ระบบเก่าหลายรุ่นเช่น Unisys หรือ PDP ใช้หน่วยความจำคำพูดได้ กับเซลล์มีคำ (36 บิตยาวในกรณีของสถาปัตยกรรมเหล่านั้น) ดังนั้นในระบบเหล่านั้น char* จะมีขนาดใหญ่กว่า int* เนื่องจากคุณจะต้องมีบิตเพิ่มเพื่อเก็บตำแหน่งของไบต์ที่คุณต้องการระบุ

ฉันไม่เข้าใจแผนภูมิของคุณมากนัก แต่คนไม่ค่อยจำเป็นต้องพูดถึงเรื่องแบบนี้เพราะลดหน่วยความจำทั้งหมดที่เราสามารถระบุได้ชัดเจน แม้ว่าจะมีความยุติธรรมมีอยู่ไม่กี่สถาปัตยกรรมที่มีหน่วยความจำบิตที่สามารถระบุตำแหน่งได้ส่วนใหญ่ระบบฝังตัว หากดูเหมือนว่าคุณต้องการค่า 32- บิตต่ำของ 64- บิตเมื่อคุณให้ CPU ที่อยู่ 32- บิต แต่มันไม่ทำงานอย่างนั้น ในการจัดการกับแต่ละครึ่งคุณจะต้องมีบิตที่สำคัญมากกว่าหนึ่งแทนที่จะเป็นครึ่งหนึ่งของจำนวนบิตเช่นนั้น หลักการง่าย ๆ : ถ้าเราใช้ขนาดเซลล์ที่ใหญ่กว่าจากนั้นในจำนวนหน่วยความจำเท่ากันจำเป็นต้องใช้เซลล์น้อยลงซึ่งหมายถึงต้องการบิตน้อยสำหรับ ID และในทางกลับกัน. ในระดับฮาร์ดแวร์ขนาดเซลล์จะได้รับการแก้ไขโดยทั่วไป

ด้านล่างนี้เป็นตัวอย่างสำหรับ 16 ไบต์แรกในหน่วยความจำ

╔══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╗
║ 0000 │ 0001 │ 0010 │ 0011 │ 0100 │ 0101 │ 0110 │ 0111 │ 1000 │ 1001 │ 1010 │ 1011 │ 1100 │ 1101 │ 1110 │ 1111 ║
╠══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╣
║ b0   │ b1   │ b2   │ b3   │ b4   │ b5   │ b6   │ b7   │ b8   │ b9   │ b10  │ b11  │ b12  │ b13  │ b14  │ b15  ║
╟──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────╢
║ w0 000      │ w1 001      │ w2 010      │ w3 011      │ w4 100      │ w5 101      │ w6 110      │ w7 111      ║
╟─────────────┴─────────────┼─────────────┴─────────────┼─────────────┴─────────────┼─────────────┴─────────────╢
║ dw0 00                    │ dw1 01                    │ dw2 10                    │ dw3 11                    ║
╟───────────────────────────┴───────────────────────────┼───────────────────────────┴───────────────────────────╢
║ o0                                                    │ o1                                                    ║
╚═══════════════════════════════════════════════════════╧═══════════════════════════════════════════════════════╝

คุณยังสามารถดูภาพประกอบได้ คำตอบนี้

หากเราพูดถึงคำ 2 ไบต์แต่ละคำนั้นคำที่ Nth จะมีที่อยู่ไบต์เป็น N * 2 เหมือนกับขนาดก้อนอื่น ๆ ที่สามารถคำนวณออฟเซตได้ offset*sizeof(chunk). ด้วยเหตุนี้บิตต่ำ 2 บิตในแอดเดรสที่ถูกจัดตำแหน่งแบบ 4 ไบต์บิตต่ำ 3 บิตในแอดเดรสที่จัดตำแหน่งแบบ 8 ไบต์จึงเป็นศูนย์เสมอ หากคุณไม่ได้ใช้พอยน์เตอร์ที่สามารถใช้คำได้ สามารถใช้ในการจัดเก็บข้อมูล ซึ่งเรียกว่า ตัวชี้ที่ติดแท็ก

JVM 64 บิตใช้เทคนิคนี้ด้วย บีบอัดโอ๊ะโอ . ดู เคล็ดลับเบื้องหลังการบีบอัด JVM โอ๊ะโอ วัตถุใน Java จะถูกจัดตำแหน่งให้อยู่ที่ 8 ไบต์เสมอดังนั้นพวกเขาจึงสามารถระบุที่อยู่ 8 * 4 = 32GB ของหน่วยความจำด้วยที่อยู่แบบ 32 บิต

พอยน์เตอร์ที่ได้รับการจัดการใน Java heap ชี้ไปที่วัตถุซึ่งจัดอยู่ในขอบเขตที่อยู่ 8 ไบต์ oops ที่ถูกบีบอัดแสดงถึงพอยน์เตอร์ที่ได้รับการจัดการ (ในหลาย ๆ ที่ แต่ไม่ใช่ทั้งหมดในซอฟต์แวร์ JVM) เป็นอ็อพเจ็กต์ 32- บิตออฟเซ็ตจากที่อยู่พื้นฐานของ Java heap 64 บิต เนื่องจากพวกมันเป็นอ็อฟเซ็ตอ็อพเจ็กแทนที่จะเป็นออฟเซ็ตไบต์พวกมันสามารถใช้เพื่อจัดการกับวัตถุได้มากถึงสี่พันล้านชิ้น (ไม่ใช่ไบต์) หรือขนาดฮีปสูงถึง 32 กิกะไบต์ ในการใช้พวกมันจะต้องถูกปรับสัดส่วนด้วย 8 และเพิ่มไปยังที่อยู่ฐานของฮีพ Java เพื่อค้นหาวัตถุที่พวกเขาอ้างถึง ขนาดของวัตถุที่ใช้โอ๊ะบีบอัดนั้นเปรียบได้กับขนาดในโหมด ILP32

https://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html#compressedOop

คำแนะนำในการใช้งานบนสถาปัตยกรรม RISC ส่วนใหญ่จะเก็บที่อยู่ของคำด้วยเนื่องจากไม่มีจุดที่สิ้นเปลืองพื้นที่อันมีค่าที่ช่วยประหยัดบิตที่ไม่เคยมีมาก่อน ตัวอย่างเช่น MIPS คำแนะนำสาขาและข้าม : JAL, J, BEQ, BLEZ, BGTZ ...