Skip to content

Array Processing

āĻ­ā§‚āĻŽāĻŋāĻ•āĻž: āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (Array Processor) āϕ⧀ āĻāĻŦāĻ‚ āϕ⧇āύ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ?

āφāĻŽāĻžāĻĻ⧇āϰ āĻĻ⧈āύāĻ¨ā§āĻĻāĻŋāύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻŋāĻ‚ā§Ÿā§‡ āĻ…āύ⧇āĻ• āϏāĻŽā§Ÿ āĻāĻŽāύ āĻ•āĻŋāϛ⧁ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ“ āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āϏāĻŽāĻ¸ā§āϝāĻž āφāϏ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϜāϟāĻŋāϞ āĻāĻŦāĻ‚ āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāϪ⧇āϰ āĻĄāĻžāϟāĻž (Massive and Complex Data) āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāĻžāϰ āĻĒā§āĻ°ā§Ÿā§‹āϜāύ āĻšā§ŸāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ: āφāĻŦāĻšāĻžāĻ“ā§ŸāĻž āĻĒā§‚āĻ°ā§āĻŦāĻžāĻ­āĻžāϏ, āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ• āϏāĻŋāĻŽā§āϞ⧇āĻļāύ, āĻŦāĻž āĻ—ā§āϰāĻžāĻĢāĻŋāĻ•ā§āϏ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚āĨ¤

āĻāχ āϧāϰāϪ⧇āϰ āĻŦāĻŋāĻļāĻžāϞ āĻĄāĻžāϟāĻž āφāĻŽāϰāĻž āĻāĻ•āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻŦāĻž āϏāύāĻžāϤāύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ (Conventional Computer) āĻĻāĻŋā§Ÿā§‡āĻ“ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāĻžāϤ⧇ āĻĒāĻžāϰāĻŋāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏāĻŽāĻ¸ā§āϝāĻž āĻšāϞ⧋, āϏāĻžāϧāĻžāϰāĻŖ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ āĻāχ āĻĄāĻžāϟāĻžāϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āϟāĻŋāϰ āĻĒāϰ āĻāĻ•āϟāĻŋ (Sequential) āĻĒā§āϰāϏ⧇āϏ āĻ•āϰ⧇āĨ¤ āĻĢāϞ⧇ āĻ“āχ āϜāϟāĻŋāϞ āĻĄāĻžāϟāĻž āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻ•āϰāϤ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āĻ…āύ⧇āĻ• āĻĻāĻŋāύ āĻŦāĻž āĻāĻŽāύāĻ•āĻŋ āĻ•ā§Ÿā§‡āĻ• āϏāĻĒā§āϤāĻžāĻš āϏāĻŽā§Ÿ āϞ⧇āϗ⧇ āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻāχ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āϏāĻŽāĻžāϧāĻžāύ āĻāĻŦāĻ‚ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž (Performance) āĻŦāĻšā§āϗ⧁āĻŖ āĻŦāĻžā§œāĻŋā§Ÿā§‡ āĻĻā§āϰ⧁āϤ āĻĢāϞāĻžāĻĢāϞ āĻĒāĻžāĻ“ā§ŸāĻžāϰ āϜāĻ¨ā§āϝ āϏāĻŦāĻĨ⧇āϕ⧇ āϏ⧇āϰāĻž āĻŦāĻŋāĻ•āĻ˛ā§āĻĒ āĻšāϞ⧋ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (Array Processor)āĨ¤

  • āĻŽā§‚āϞ āĻ•āĻžāϜ: āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āĻŽā§‚āϞāϤ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻĄāĻžāϟāĻžāϰ āĻ…ā§āϝāĻžāϰ⧇ (Large Array of Data)-āϰ āĻ“āĻĒāϰ āĻ•āĻŽā§āĻĒāĻŋāωāĻŸā§‡āĻļāύ āĻŦāĻž āĻ—āĻŖāύāĻž āĻ•āϰ⧇āĨ¤
  • āĻ•āĻžāĻœā§‡āϰ āĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž: āφāĻŽāϰāĻž āϝāĻ–āύ āĻāχ āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāϪ⧇āϰ āĻĄāĻžāϟāĻž āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āχāύāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĻāĻŋāχ, āϤāĻ–āύ āĻāϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĻā§āϰ⧁āϤ āĻ“ āύāĻŋāϖ⧁āρāϤāĻ­āĻžāĻŦ⧇ (Fastly & Quickly) āĻĄāĻžāϟāĻžāϗ⧁āϞ⧋āϕ⧇ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻ•āϰ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āφāωāϟāĻĒ⧁āϟ āĻŦāĻž āϰ⧇āϜāĻžāĻ˛ā§āϟ āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āĻĻā§‡ā§ŸāĨ¤

āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āĻĒā§āϰāĻ•āĻžāϰāϭ⧇āĻĻ (Types of Array Processors)

āĻ…āĻ­ā§āϝāĻ¨ā§āϤāϰ⧀āĻŖ āĻ—āĻ āύ āĻāĻŦāĻ‚ āϏāĻ‚āϝ⧋āϗ⧇āϰ āĻ“āĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰāϕ⧇ āĻŽā§‚āϞāϤ āĻĻ⧁āχ āĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžā§Ÿ āĻŦāĻž āĻĻ⧁āϟāĻŋ āωāĻĒāĻžā§Ÿā§‡ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžā§Ÿ:

  1. āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (Attached Array Processor)
  2. āĻāϏāφāχāĻāĻŽāĻĄāĻŋ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (SIMD Array Processor)

āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āύ⧋āϟ: āĻāχ āĻĻ⧁āϟāĻŋ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰāχ āĻŽā§‚āϞ āϞāĻ•ā§āĻˇā§āϝ āĻāĻ•â€”āωāϭ⧟āχ āϭ⧇āĻ•ā§āϟāϰ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ (Vector Instructions) āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻāĻŦāĻ‚ āĻŽā§āϝāĻžāύāĻŋāĻĒ⧁āϞ⧇āϟ āĻ•āϰ⧇āĨ¤ āĻĄāĻžāϟāĻž āĻĻā§āϰ⧁āϤ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāĻž āĻāĻŦāĻ‚ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻŦāĻžā§œāĻžāύ⧋āχ āĻāĻĻ⧇āϰ āĻ•āĻžāϜāĨ¤ āĻāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§‚āϞ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝāϟāĻŋ āĻšāϞ⧋ āĻāĻĻ⧇āϰ āĻ…āĻ­ā§āϝāĻ¨ā§āϤāϰ⧀āĻŖ āϏāĻžāĻ‚āĻ—āĻ āύāĻŋāĻ• āĻ•āĻžāĻ āĻžāĻŽā§‹ (Internal Organization) āĻŦāĻž āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ⧇āĨ¤

ā§§. āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (Attached Array Processor)

āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϏ⧇āϏāϰ āϝāĻž āĻ¸ā§āĻŦāĻžāϧ⧀āύāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āύāĻž āĻ•āϰ⧇ āĻāĻ•āϟāĻŋ āϏāĻšāĻžā§ŸāĻ• āĻĒā§āϰāϏ⧇āϏāϰ (Auxiliary Processor) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋāϕ⧇ āĻāĻ•āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻŦāĻž āϏāύāĻžāϤāύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ (General Purpose Computer) āϏāĻžāĻĨ⧇ āĻŦāĻžāĻšā§āϝāĻŋāĻ• āĻĄāĻŋāĻ­āĻžāχāϏ āĻŦāĻž āĻĒ⧇āϰāĻŋāĻĢ⧇āϰāĻžāϞ āĻĄāĻŋāĻ­āĻžāχāϏ (Peripheral Device) āĻšāĻŋāϏ⧇āĻŦ⧇ āϝ⧁āĻ•ā§āϤ āĻŦāĻž āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻ•āϰāĻž āĻšā§ŸāĨ¤

āϝāĻ–āύāχ āĻŽā§‡āχāύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ āĻ•āĻžāϛ⧇ āϕ⧋āύ⧋ āĻŦāĻŋāĻļāĻžāϞ āĻ“ āϜāϟāĻŋāϞ āĻĄāĻžāϟāĻžāϰ āĻ…ā§āϝāĻžāϰ⧇ āφāϏ⧇, āϤāĻ–āύ āϏ⧇ āύāĻŋāĻœā§‡ āϤāĻž āĻĒā§āϰāϏ⧇āϏ āύāĻž āĻ•āϰ⧇ āĻāχ āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āĻ•āĻžāϛ⧇ āĻĒāĻžāĻ āĻŋā§Ÿā§‡ āĻĻā§‡ā§ŸāĨ¤

āĻ…āĻ­ā§āϝāĻ¨ā§āϤāϰ⧀āĻŖ āĻ—āĻ āύ āĻ“ āĻŦā§āϞāĻ• āĻĄāĻžāϝāĻŧāĻžāĻ—ā§āϰāĻžāĻŽā§‡āϰ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž:

āĻāĻ•āϟāĻŋ āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻŽā§‚āϞāϤ āύāĻŋāĻšā§‡āϰ āĻ…āĻ‚āĻļāϗ⧁āϞ⧋ āύāĻŋā§Ÿā§‡ āĻ—āĻ āĻŋāϤ āĻšā§Ÿ:

  • āĻšā§‹āĻ¸ā§āϟ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ (Host / General Purpose Computer): āĻāϟāĻŋ āĻŽā§‚āϞ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ āϝāĻž āϏāĻžāϧāĻžāϰāĻŖ āĻ•āĻžāϜāϗ⧁āϞ⧋ āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰ⧇āĨ¤
  • āχāύāĻĒ⧁āϟ-āφāωāϟāĻĒ⧁āϟ āχāĻ¨ā§āϟāĻžāϰāĻĢ⧇āϏ (I/O Interface): āĻšā§‹āĻ¸ā§āϟ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ āĻāĻŦāĻ‚ āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āĻ•āĻžāĻœā§‡āϰ āĻ—āϤāĻŋ āĻāĻŦāĻ‚ āĻ…āĻ­ā§āϝāĻ¨ā§āϤāϰ⧀āĻŖ āĻ•āĻžāĻ āĻžāĻŽā§‹āϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧇ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āĻŦāĻž āĻ…āĻŽāĻŋāϞ āĻĨāĻžāϕ⧇, āϤāĻž āĻĻā§‚āϰ āĻŦāĻž āϰāĻŋāϜāϞāĻ­ (Resolve) āĻ•āϰāĻžāϰ āĻ•āĻžāϜ āĻ•āϰ⧇ āĻāχ āχāĻ¨ā§āϟāĻžāϰāĻĢ⧇āϏāϟāĻŋāĨ¤
  • āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ (Main Memory): āĻāϟāĻŋ āĻšā§‹āĻ¸ā§āϟ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻŽā§‡āĻŽā§‹āϰāĻŋ, āϝ⧇āĻ–āĻžāύ⧇ āϏāĻŽāĻ¸ā§āϤ āĻĒā§āϰāĻžāĻĨāĻŽāĻŋāĻ• āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻž āϜāĻŽāĻž āĻĨāĻžāϕ⧇āĨ¤
  • āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋ (Local Memory): āĻāϟāĻŋ āĻ¸ā§āĻŦ⧟āĻ‚ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻŽā§‡āĻŽā§‹āϰāĻŋāĨ¤
  • āĻšāĻžāχ-āĻ¸ā§āĻĒāĻŋāĻĄ āĻŽā§‡āĻŽā§‹āϰāĻŋ-āϟ⧁-āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻŦāĻžāϏ (High-Speed Memory-to-Memory Bus): āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻāĻŦāĻ‚ āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋāϕ⧇ āϏāϰāĻžāϏāϰāĻŋ āϝ⧁āĻ•ā§āϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāχ āĻŦāĻŋāĻļ⧇āώ āĻ“ āĻĻā§āϰ⧁āϤāĻ—āϤāĻŋāϰ āĻŦāĻžāϏāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤

āĻ•āĻžāĻ°ā§āϝāĻĒāĻĻā§āϧāϤāĻŋ āĻ“ āĻĄāĻžāϟāĻž āĻĢā§āϞ⧋ (Working & Data Flow):

  1. āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ āϏāĻŽāĻ¸ā§āϤ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻāĻŦāĻ‚ āĻŽā§āϝāĻžāϏāĻŋāĻ­ āĻĄāĻžāϟāĻž āϏāĻŦāĻžāϰ āĻĒā§āϰāĻĨāĻŽā§‡ āĻšā§‹āĻ¸ā§āϟ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ Main Memory-āϤ⧇ āĻ¸ā§āĻŸā§‹āϰ āĻŦāĻž āϜāĻŽāĻž āĻšā§ŸāĨ¤
  2. āĻāϰāĻĒāϰ, Massive/Complex Data → High-Speed Memory-to-Memory Bus āĻĻāĻŋāϝāĻŧ⧇ Local Memory-āϤ⧇ transfer āĻšāϝāĻŧ
  3. āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋāϤ⧇ āĻĄāĻžāϟāĻž āφāϏāĻžāϰ āĻĒāϰ, āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āϏ⧇āĻ–āĻžāύ āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻĢā§āϝāĻžāϚ (Fetch) āĻ•āϰ⧇āĨ¤
  4. āĻāĻ–āĻžāύ⧇ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ā§Ÿā§‡āϰ āĻ•āĻžāϜ āĻāĻ•āĻž āĻšā§Ÿ āύāĻž; āĻŦāϰāĻ‚ āϜāϟāĻŋāϞ āĻ•ā§āϝāĻžāϞāϕ⧁āϞ⧇āĻļāύāϗ⧁āϞ⧋āϕ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻĢāĻžāĻ‚āĻļāύāĻžāϞ āχāωāύāĻŋāĻŸā§‡āϰ (Multiple Functional Units) āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻŽāĻžāĻ¨ā§āϤāϰāĻžāϞāĻ­āĻžāĻŦ⧇ āĻŦāĻž āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞāĻŋ (Parallelly) āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻāϰ āĻĢāϞ⧇ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻ¸ā§āĻĒāĻŋāĻĄ āĻ…āύ⧇āĻ• āĻšāĻžāχ (High Performance) āĻšā§ŸāĨ¤
  5. āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāĻļāύ āĻļ⧇āώ āĻšāĻ“ā§ŸāĻžāϰ āĻĒāϰ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āĻĢāϞāĻžāĻĢāϞāϟāĻŋāϕ⧇ āĻĒ⧁āύāϰāĻžā§Ÿ āϤāĻžāϰ Local Memory-āϤ⧇ āϏ⧇āĻ­ āĻ•āϰ⧇āĨ¤
  6. āϏāĻŦāĻļ⧇āώ⧇, āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻĨ⧇āϕ⧇ āϏ⧇āχ āφāωāϟāĻĒ⧁āϟ āĻŦāĻž āϰ⧇āϜāĻžāĻ˛ā§āϟ āφāĻŦāĻžāϰ āĻšāĻžāχ-āĻ¸ā§āĻĒāĻŋāĻĄ āĻŦāĻžāϏ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻŽā§‡āχāύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ Main Memory-āϤ⧇ āĻĢ⧇āϰāϤ āϚāϞ⧇ āφāϏ⧇āĨ¤ āĻāĻ­āĻžāĻŦ⧇āχ āĻĒ⧁āϰ⧋ āĻ•āĻžāĻ°ā§āϝāĻĒā§āϰāĻ•ā§āϰāĻŋ⧟āĻž āϏāĻŽā§āĻĒāĻ¨ā§āύ āĻšā§ŸāĨ¤
    Attached Array Processor

⧍. āĻāϏāφāχāĻāĻŽāĻĄāĻŋ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ (SIMD Array Processor)

SIMD-āĻāϰ āĻĒā§‚āĻ°ā§āĻŖāϰ⧂āĻĒ āĻšāϞ⧋ Single Instruction Stream, Multiple Data Stream (āĻāĻ•āĻ• āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻ¸ā§āĻŸā§āϰāĻŋāĻŽ āĻāĻŦāĻ‚ āĻāĻ•āĻžāϧāĻŋāĻ• āĻĄāĻžāϟāĻž āĻ¸ā§āĻŸā§āϰāĻŋāĻŽ)āĨ¤ āĻāϰ āύāĻžāĻŽ āĻĨ⧇āϕ⧇āχ āĻŦā§‹āĻāĻž āϝāĻžā§Ÿ āϝ⧇, āĻāĻ–āĻžāύ⧇ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻŦāĻž āĻ•āĻŽāĻžāĻ¨ā§āĻĄ āĻĨāĻžāĻ•āĻŦ⧇ āĻŽāĻžāĻ¤ā§āϰ āĻāĻ•āϟāĻŋ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏ⧇āχ āĻāĻ•āϟāĻŋ āĻ•āĻŽāĻžāĻ¨ā§āĻĄ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻĄāĻžāϟāĻžāϰ āĻ“āĻĒāϰ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇āĨ¤

āĻāχ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻĄāĻžāϟāĻžāϰ āĻ…ā§āϝāĻžāϰ⧇āϕ⧇ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞāĻŋ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŽā§āϝāĻžāĻ˛ā§āϟāĻŋāĻĒāϞ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āχāωāύāĻŋāϟ (Multiple Processing Units) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤

āĻ…āĻ­ā§āϝāĻ¨ā§āϤāϰ⧀āĻŖ āĻ—āĻ āύ āĻ“ āĻŦā§āϞāĻ• āĻĄāĻžāϝāĻŧāĻžāĻ—ā§āϰāĻžāĻŽā§‡āϰ āĻŦā§āϝāĻžāĻ–ā§āϝāĻž:

āĻāϏāφāχāĻāĻŽāĻĄāĻŋ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ āĻŦāĻž āĻ—āĻ āύ āύāĻŋāĻšā§‡ āĻĻ⧇āĻ“ā§ŸāĻž āĻšāϞ⧋:
SIMD Array Processor
* āĻ•āĻŽāύ āĻ•āĻ¨ā§āĻŸā§āϰ⧋āϞ āχāωāύāĻŋāϟ (Common Control Unit / Master CPU): āĻāϟāĻŋ āĻĒ⧁āϰ⧋ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻŽāĻžāĻĨāĻž āĻŦāĻž āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĒā§āϰāϏ⧇āϏāϰāĨ¤ āĻāϰ āĻ•āĻžāϜ āĻšāϞ⧋ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻĨ⧇āϕ⧇ āφāύāĻž āĻāĻŦāĻ‚ āύāĻŋāĻšā§‡āϰ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟāϗ⧁āϞ⧋āϕ⧇ āύāĻŋ⧟āĻ¨ā§āĻ¤ā§āϰāĻŖ āĻ•āϰāĻžāĨ¤
* āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ (Main Memory): āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āϏāĻŋāĻĒāĻŋāχāω-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ āϝ⧁āĻ•ā§āϤ āĻĨāĻžāϕ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āϏāĻŽāĻ¸ā§āϤ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āϜāĻŽāĻž āĻĨāĻžāϕ⧇āĨ¤
* āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟāϏ (Processing Elements - PE): āĻāĻ–āĻžāύ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻĒā§āϰāϏ⧇āϏāϰ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞāĻŋ āĻŦāϏāĻžāύ⧋ āĻĨāĻžāϕ⧇, āϝāĻžāĻĻ⧇āϰ \(PE_1, PE_2, PE_3 ... PE_n\) āĻŦāϞāĻž āĻšā§ŸāĨ¤
* āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋ (Local Memory - M): āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ (PE) āύāĻŋāϜāĻ¸ā§āĻŦ āφāϞāĻžāĻĻāĻž āϞ⧋āĻ•āĻžāϞ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻĨāĻžāϕ⧇, āϝ⧇āϗ⧁āϞ⧋āϕ⧇ \(M_1, M_2, M_3 ... M_n\) āĻŦāϞāĻž āĻšā§ŸāĨ¤ āĻāĻ›āĻžā§œāĻžāĻ“ āĻĒā§āϰāϤāĻŋāϟāĻŋ PE-āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āϰ⧇āϜāĻŋāĻ¸ā§āϟāĻžāϰ āĻāĻŦāĻ‚ I/O āĻĄāĻŋāĻ­āĻžāχāϏ āĻĨāĻžāϕ⧇āĨ¤
* āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāχāĻœā§‡āĻļāύ āϏāĻ‚āϝ⧋āĻ—: āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āϏāĻŋāĻĒāĻŋāχāω āĻŦāĻž āĻ•āĻŽāύ āĻ•āĻ¨ā§āĻŸā§āϰ⧋āϞ āχāωāύāĻŋāϟāϟāĻŋ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āϏāĻžāĻĨ⧇ āϏāϰāĻžāϏāϰāĻŋ āϝ⧁āĻ•ā§āϤ āĻĨāĻžāϕ⧇ āϝāĻžāϤ⧇ āϏāĻŦāĻžāχāϕ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻāĻ•āχ āϤāĻžāϞ⧇ (Synchronized āĻ­āĻžāĻŦ⧇) āϚāĻžāϞāĻžāύ⧋ āϝāĻžā§ŸāĨ¤

āĻ­āĻŋāĻĄāĻŋāĻ“āϰ āωāĻĻāĻžāĻšāϰāĻŖāϏāĻš āĻ•āĻžāĻ°ā§āϝāĻĒāĻĻā§āϧāϤāĻŋ:

āϧāϰāĻž āϝāĻžāĻ•, āφāĻŽāĻžāĻĻ⧇āϰ āĻāĻ•āϟāĻŋ āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻĻ⧁āϟāĻŋ āĻ…ā§āϝāĻžāϰ⧇āϕ⧇ āϝ⧋āĻ— āĻ•āϰāϤ⧇ āĻšāĻŦ⧇:

\[A_i + B_i\]

āĻāĻ–āĻžāύ⧇ \(A\) āĻāĻŦāĻ‚ \(B\) āĻšāϞ⧋ āĻĄāĻžāϟāĻžāϰ āĻĻ⧁āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻ…ā§āϝāĻžāϰ⧇, āϝāĻž āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋāϤ⧇ āφāϛ⧇āĨ¤ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āϏāĻŋāĻĒāĻŋāχāω āĻŽā§‡āχāύ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻŋ āĻŽāĻžāĻ¤ā§āϰ āχāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āĻļāύ āĻŦāĻž āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āφāύāĻŦ⧇, āϤāĻž āĻšāĻ˛ā§‹â€”"āϝ⧋āĻ— (Addition) āĻ•āϰ⧋"āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĄāĻžāϟāĻž āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āĻŸā§‡ āĻ­āĻžāĻ— āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇:

  • \(PE_1\) (āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ ā§§): āϤāĻžāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻŽā§‡āĻŽā§‹āϰāĻŋ \(M_1\) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āϝ⧋āĻ— āĻ•āϰāĻŦ⧇ \(A_1 + B_1\)
  • \(PE_2\) (āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ ⧍): āϤāĻžāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻŽā§‡āĻŽā§‹āϰāĻŋ \(M_2\) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āϝ⧋āĻ— āĻ•āϰāĻŦ⧇ \(A_2 + B_2\)
  • \(PE_3\) (āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ ā§Š): āϝ⧋āĻ— āĻ•āϰāĻŦ⧇ \(A_3 + B_3\)
  • \(PE_n\) (āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ \(n\)): āĻļ⧇āώ āĻĄāĻžāϟāĻžāϟāĻŋ āϝ⧋āĻ— āĻ•āϰāĻŦ⧇ \(A_n + B_n\)

āĻĢāϞāĻžāĻĢāϞ: āϝ⧇āĻšā§‡āϤ⧁ āϏāĻŽāĻ¸ā§āϤ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ (PE) āĻāĻ•āχ āϏāĻŽā§Ÿā§‡ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞāĻŋ āύāĻŋāϜ āύāĻŋāϜ āĻĄāĻžāϟāĻžāϰ āĻ“āĻĒāϰ āĻ•āĻžāϜ āĻ•āϰāϛ⧇, āϤāĻžāχ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻĨā§āϰ⧁āϟāĻĒ⧁āϟ (Throughput) āĻŦāĻž āφāωāϟāĻĒ⧁āϟ āĻĻ⧇āĻ“ā§ŸāĻžāϰ āĻ—āϤāĻŋ āĻ•ā§Ÿā§‡āĻ• āϗ⧁āĻŖ āĻŦā§‡ā§œā§‡ āϝāĻžā§Ÿ āĻāĻŦāĻ‚ āϖ⧁āĻŦ āĻĻā§āϰ⧁āϤ āĻĢāϞāĻžāĻĢāϞ āĻĒāĻžāĻ“ā§ŸāĻž āϝāĻžā§ŸāĨ¤

āϏāĻžāϰāϏāĻ‚āĻ•ā§āώ⧇āĻĒ (Conclusion)

āĻ­āĻŋāĻĄāĻŋāĻ“āϰ āĻĒāϰāĻŋāĻļ⧇āώ⧇ āφāĻŽāϰāĻž āϜāĻžāύāϤ⧇ āĻĒāĻžāϰāϞāĻžāĻŽ āϝ⧇, āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ āĻšāϞ⧋ āϞāĻžāĻ°ā§āϜ āĻĄāĻžāϟāĻž āϏ⧇āϟāϕ⧇ āĻĻā§āϰ⧁āϤ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāĻžāϰ āĻāĻ•āϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āĻŽāĻžāĻ§ā§āϝāĻŽāĨ¤

  • āĻ…ā§āϝāĻžāϟāĻžāϚāĻĄ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇ āφāĻŽāϰāĻž āϏāĻžāϧāĻžāϰāĻŖ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ āϏāĻžāĻĨ⧇ āĻāĻ•āϟāĻŋ āĻāĻ•ā§āϏāϟāĻžāĻ°ā§āύāĻžāϞ āĻ…āĻ•ā§āϏāĻŋāϞāĻžāϰāĻŋ āĻĒā§āϰāϏ⧇āϏāϰ āϝ⧁āĻ•ā§āϤ āĻ•āϰ⧇ āĻŽā§‡āĻŽā§‹āϰāĻŋ-āϟ⧁-āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻŦāĻžāϏ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻ•āϰāĻŋāĨ¤
  • āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇, āĻāϏāφāχāĻāĻŽāĻĄāĻŋ āĻāϰ⧇ āĻĒā§āϰāϏ⧇āϏāϰ⧇ āĻāĻ•āϟāĻŋ āϏ⧇āĻ¨ā§āĻŸā§āϰāĻžāϞ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āϏāĻŋāĻĒāĻŋāχāω-āĻāϰ āĻ…āϧ⧀āύ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻāϞāĻŋāĻŽā§‡āĻ¨ā§āϟ (PE) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ•āχ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻāĻŋā§Ÿā§‡ āĻ­āĻŋāĻ¨ā§āύ āĻ­āĻŋāĻ¨ā§āύ āĻĄāĻžāϟāĻžāϰ āĻ“āĻĒāϰ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻŋā§Ÿā§‡ āĻĻā§āϰ⧁āϤāϤāĻŽ āϏāĻŽā§Ÿā§‡ āύāĻŋāϖ⧁āρāϤ āφāωāϟāĻĒ⧁āϟ āϞāĻžāĻ­ āĻ•āϰāĻŋāĨ¤


Introduction: What is an Array Processor & Why Do We Need It?

In modern computing, we often encounter complex scientific or mathematical problems that involve processing a vast amount of data, known as Massive and Complex Data (e.g., weather forecasting, graphics rendering, aerodynamic simulations).

We can technically execute this massive and complex data using a conventional or traditional computer. However, because a conventional computer processes data sequentially (one after another), executing such complex datasets could take days or even several weeks.

To overcome this limitation, optimize system performance, and obtain rapid outputs, the best alternative is to use an Array Processor.

  • Core Function: An array processor is specifically designed to perform computations on a large array of data.
  • Working Process: When we feed a large array of data into an array processor, it executes the operations extremely fast and generates the final output almost instantly.

Types of Array Processors

Based on their internal architecture and how they are integrated into a system, array processors can be structured in two ways:

  1. Attached Array Processor
  2. SIMD Array Processor

Key Takeaway: Ultimately, both types of array processors serve the same objective—they execute and manipulate Vector Instructions. Their primary goal is to accelerate computation and elevate system performance; they only differ in their Internal Organization and architectural design.

1. Attached Array Processor

An Attached Array Processor is not an independent system; rather, it acts as an Auxiliary Processor. It is connected as a peripheral or external device to a standard, traditional host computer (General Purpose Computer).

Whenever the host computer receives massive array-structured datasets, it offloads the heavy computation tasks to the attached array processor to enhance execution speed.

Internal Architecture & Block Diagram Explanation:

An Attached Array Processor system consists of the following fundamental blocks:

Attached Array Processor

  • Host Computer (General Purpose Computer): The main computer that manages standard system operations and controls the workflow.
  • Input-Output (I/O) Interface: This interface connects the host computer with the attached processor. Its primary job is to resolve any architectural or speed differences between the two units.
  • Main Memory: The host computer's proprietary memory where all primary instructions and incoming data are originally stored.
  • Local Memory: The dedicated internal memory belonging strictly to the attached array processor.
  • High-Speed Memory-to-Memory Bus: A dedicated, ultra-fast bus used to establish a direct connection between the Main Memory of the host and the Local Memory of the array processor.

Working Mechanism & Data Flow:

  1. All instructions and massive datasets are initially stored in the Main Memory of the host computer.
  2. The complex and large array of data is then transferred from the Main Memory to the Local Memory of the attached array processor via the High-Speed Memory-to-Memory Bus.
  3. Once the data lands in the local memory, the attached array processor fetches it for execution.
  4. Instead of executing the data sequentially, the complex tasks are distributed across Multiple Functional Units to be processed simultaneously or in parallel (Parallel Processing). This architecture ensures exceptionally high performance.
  5. After completing the execution, the array processor stores the computed results back into its Local Memory.
  6. Finally, these results/outputs are routed back from the Local Memory to the Main Memory of the host computer via the high-speed bus, completing the execution cycle.

2. SIMD Array Processor

SIMD stands for Single Instruction Stream, Multiple Data Stream. As the name implies, the system receives only a single instruction or command from the control unit, but that identical command is executed simultaneously across multiple distinct pieces of data.

This system uses Multiple Processing Units running synchronously to compute large arrays of data in parallel.

Internal Architecture & Block Diagram Explanation:

The architectural layout of an SIMD Array Processor includes:
SIMD Array Processor
* Common Control Unit (Master CPU): This is the brain or master controller of the entire architecture. It fetches instructions from the memory and orchestrates the processing elements.
* Main Memory: Directly connected to the Master CPU, this memory holds all the primary instructions waiting to be executed.
* Processing Elements (PE): This consists of an array of multiple parallel processing units designated as \(PE_1, PE_2, PE_3 ... PE_n\).
* Local Memory (M): Every individual Processing Element (PE) has its own dedicated local memory unit, labeled as \(M_1, M_2, M_3 ... M_n\), along with its own set of registers and I/O handlers.
* Synchronization Link: The Common Control Unit is directly connected to every single Processing Element, ensuring that all PEs perform operations in perfect synchronization.

Working Mechanism with the Video Example:

Let's understand the execution flow using the exact example from the video. Suppose we need to perform an array addition operation:

\[A_i + B_i\]

Here, \(A\) and \(B\) are large data arrays stored in the Main Memory. The Master CPU fetches a single instruction from the memory, which is "ADD". While the instruction remains a single command, the actual data arrays are divided among the multiple Processing Elements (PEs):

  • \(PE_1\) (Processing Element 1): Utilizes its local memory \(M_1\) to simultaneously execute: \(A_1 + B_1\)
  • \(PE_2\) (Processing Element 2): Utilizes its local memory \(M_2\) to simultaneously execute: \(A_2 + B_2\)
  • \(PE_3\) (Processing Element 3): Simultanously executes: \(A_3 + B_3\)
  • \(PE_n\) (Processing Element \(n\)): Executes the final data set in the array: \(A_n + B_n\)

Result: Because all the Processing Elements (PEs) are executing their designated data chunks at the exact same time (parallelly), the system's Throughput (output rate) increases exponentially, producing final results rapidly.


Summary (Conclusion)

To conclude based on the video lecture, an array processor is a highly powerful architectural component designed to fast-track large datasets.

  • In an Attached Array Processor, we link an external auxiliary processor to a conventional host computer and achieve parallel processing via a high-speed memory-to-memory bus.
  • In an SIMD Array Processor, we leverage multiple Processing Elements (PEs) controlled by a central Master CPU to run a single instruction over multiple data streams synchronously, maximizing computational speed and efficiency.