「CPU」の記事 - Crieit

乗算器のない8bit CPUで高速にべき乗剰余演算するコード

2022-05-27T07:07:11+09:00

目的

軽量で非常に良くできた8bit CPUのオープンソースWZetaを普及させるためにRSA暗号や楕円暗号などの公開鍵暗号で使われるべき乗剰余演算のアセンブラコードをCC0ライセンス(パブリックドメインと同じ)で公開したことのお知らせ。

注意!!! CC0であるのは、べき乗剰余演算のWZetaのアセンブラコードのみ

WZetaとは

WZetaはトランジスタ数当たりの性能、命令セット内パリティ、ハードマクロ命令など8bit CPUにして新技術を多数持ち、常識を破る変則的な命令セットですが、高い効率であることが確認されつつあるCPU。

1024bitのべき乗剰余演算(事前定数有版)

###################################################################
### WZeta powmod 1024bit 2022/05/27 by Naoki Hirayama 
### 
### These codes are licensed under CC0.(Public Domain)
### http://creativecommons.org/publicdomain/zero/1.0/deed.ja
### 
### Montgomery multiplication method with radix 2,
### which is famous for being used in ICF3(1999).
###
### This code is for Open source 8bit CPU WZeta.
### https://wzeta.idletime.tokyo/
###
### download WZeta simulator
### https://subnote.icf3.net/wz660/download/
### 
### How to do simulation.
### > wzsim (this file)
### 
###################################################################
### ---------------------------------------------------------------
###  Subroutine powmod1024  y = g^x mod p
###  INOUT g,r(=y) 128,128 !0x100
###  IN    x,p     128,128 !0x100
###  r = R^2 mod p
### ---------------------------------------------------------------
    MEMORY 4
    MODEL TINY
###     MEMORY 8
###     MODEL HALF

    .PROG
    LD A,&powmod_gr.H
    ST %_b_powmod_gr,A
    LD A,&powmod_px.H
    ST %_b_powmod_px,A

    LD A, ^_b_powmod1024.H
    LD B, ^_b_powmod1024.L
    BAL A:B

    LD A,32
    ST %_b_powmod_i,A
    LD A, &ANS.H
    LD B,0x80
        LD C,0x00
copy_ans:           # ans <- powmod_y
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    DEC %_b_powmod_i
    JRZ0 ^copy_ans

        $PRINT &ANS 128
    NOP
        $PRINT &powmod_exp 128
        EXIT    

### ---------------------------------------------------------------
###  [%h:%l] =[%h:%l] * g R-1mod p
###  IN %h:%l : pointer
###  CONST p,g
### ---------------------------------------------------------------
_b_powmod1024_mm:
    ST %_b_powmod_retA,A
    ST %_b_powmod_retB,B

    LD A,&_b_powmod_a.H # a = 0
    LD B,&_b_powmod_a.L
    LD C,128        # repeat 129
    LOOPZERO

    ZERO %_b_powmod_m
_b_powmod1024_mm_loop_m:        # for m=0 to 127
    LD A,8
    ST %_b_powmod_n,A

        LD A, %_b_powmod_m
    ADD A, %_b_powmod_l
    LD B,A
        LD A, %_b_powmod_h
    LD A,[A:B]
    ST %_b_powmod_x,A
_b_powmod1024_mm_loop_n:        # for n=0 to 7
### loop body start --------------------------
    LD A, %_b_powmod_x
    LD B, 0
    AND A,[&powmod_g:B]
    XOR A,[&_b_powmod_a:B]
    ST %_b_powmod_u,A

    SHRC %_b_powmod_x
    JRC0 ^_b_powmod1024_mm2 # yi = 0 skip a += g

    LD B,0          # a += g
    CLC
    LD C,15
_b_powmod1024_mm1:
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    ADDC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm1
    INCC [&_b_powmod_a:B]

_b_powmod1024_mm2:
    SHRC %_b_powmod_u
    JRC0 ^_b_powmod1024_mm4 # u=0 skip +p

    LD B,0          # a += p
    CLC
    LD C,15
_b_powmod1024_mm3:
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    ADDC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm3
    INCC [&_b_powmod_a:B]

_b_powmod1024_mm4:      # a >>= 1
    LD A, &_b_powmod_a.H
    LD B,128
    LD C,128
    CLC
    LOOPSHRC
### loop body end   --------------------------
    DEC %_b_powmod_n
    JRZ0 ^_b_powmod1024_mm_loop_n

    INCX %_b_powmod_m   # A=m++
    XOR A,0x7F
    JRZ0 ^_b_powmod1024_mm_loop_m

### Final Substruct
    INC %_b_powmod_n    # n=1
_b_powmod1024_mm5:  
    LD A,32         # y=a(before sub)
    ST %_b_powmod_m,A   # 32 = 128 / 4
    LD A,%_b_powmod_h
    LD C,%_b_powmod_l
    LD B,0
_b_powmod1024_mm6:
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    DEC %_b_powmod_m
    JRZ0 ^_b_powmod1024_mm6

    LD C,%_b_powmod_n
    LOOPINC ^_b_powmod1024_mm8 # if C!=0 jump

_b_powmod1024_mm7:      # return
    LD A,%_b_powmod_retA
    LD B,%_b_powmod_retB
    JMP A:B

_b_powmod1024_mm8:
    LD B,0          # a -= p
    LD A,0
    SUB A,C         # CF=1
    LD C,31
_b_powmod1024_mm9:
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    SUBC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm9
    DECC [&_b_powmod_a:B]
    JRC0 ^_b_powmod1024_mm7
    ZERO %_b_powmod_n
    JR ^_b_powmod1024_mm5
### ---------------------------------------------------------------

### ---------------------------------------------------------------
###  Subroutine powmod1024
###        INOUT g,r(=y) 128,128 !0x100
###  const IN    x,p     128,128 !0x100
###  work _b_powmod_a    129     !0x100
###  r : R2modP
### ---------------------------------------------------------------
_b_powmod1024:
    ST %_b_powmod_RETA,A
    ST %_b_powmod_RETB,B

### CALL powmod_1024mm
    LD A, %_b_powmod_gr # y = y(r) * g R-1mod p
    ST %_b_powmod_h , A
    LD A, 0x80
    ST %_b_powmod_l , A
    BR ^_b_powmod1024_mm

### COPY y -> g
    LD A, %_b_powmod_gr
        LD C,0x7F
    LD B,0xFF
copy_y_g:   
    STAC [A:B]
    LOOPDEC ^copy_y_g       # if c--==0 jump -1

# powmod_y = 1 start    
    LD A, %_b_powmod_gr
    LD B,0x80       # y
    LD C, 1
    !ST [A:B],C     # y[0] = 1
    LD C,126        # repeat 127
    LOOPZERO

    ZERO %_b_powmod_i           # for i=0 to 127
powmod_loop_i:
    LD A,8
    ST %_b_powmod_j,A           # for j=0 to 7

    LD A, &powmod_x.L
    ADD A, %_b_powmod_i
    LD B,A
    LD A,[&powmod_x:B]
    ST %_b_powmod_y,A
powmod_loop_j:
### 
### loop main
### 
    SHRC %_b_powmod_y
    JRC0 ^powmod1024_lbl3   # skip yi=0

### CALL powmod_1024mm (y*g)
    LD A, &powmod_y.H
    ST %_b_powmod_h , A
    LD A, &powmod_y.L
    ST %_b_powmod_l , A
    LD B, ^_b_powmod1024_mm.L
    BAL ^_b_powmod1024_mm:B

powmod1024_lbl3:
### CALL powmod_1024mm (g*g)
    LD A, &powmod_g.H
    ST %_b_powmod_h , A
    LD A, &powmod_g.L
    ST %_b_powmod_l , A
    LD B, ^_b_powmod1024_mm.L
    BAL ^_b_powmod1024_mm:B

    DEC %_b_powmod_j
    JRZ0 ^powmod_loop_j

    INCX %_b_powmod_i           # A=[i++]
    XOR A,0x7F
    JRZ0 ^powmod_loop_i

    LD A,%_b_powmod_RETA
    LD B,%_b_powmod_RETB
    JMP A:B

    .DATA
    REG 16 _reg02
    ALIAS _b_powmod_gr _reg02 0
    ALIAS _b_powmod_px _reg02 1
    ALIAS _b_powmod_x  _reg02 2
    ALIAS _b_powmod_y  _reg02 3
    ALIAS _b_powmod_i  _reg02 4
    ALIAS _b_powmod_j  _reg02 5
    ALIAS _b_powmod_m  _reg02 6
    ALIAS _b_powmod_n  _reg02 7
    ALIAS _b_powmod_h  _reg02 8
    ALIAS _b_powmod_l  _reg02 9
    ALIAS _b_powmod_u  _reg02 10
    ALIAS _b_powmod_retA  _reg02 11 # child sub
    ALIAS _b_powmod_retB  _reg02 12 # child sub
    ALIAS _b_powmod_RETA  _reg02 13
    ALIAS _b_powmod_RETB  _reg02 14

    MEM 129 _system_work !0x100
    ALIAS _b_powmod_a _system_work 0

    MEM 256 powmod_gr !0x100 \
        0x3A 0x43 0xCE 0xEB 0xEC 0x52 0x88 0x94 0x4B 0x42 0x09 0xF6 0x91 0x70 0x7B 0x7F
        0x25 0x1F 0xB8 0x44 0x32 0x0F 0x05 0x7F 0xF9 0xDD 0xA5 0x94 0x58 0x32 0x70 0x1E
        0xCD 0x91 0x16 0xAC 0x21 0x16 0x90 0x79 0xCC 0xC2 0x66 0xC1 0x88 0x85 0x06 0x3B
        0xF5 0x66 0xF2 0x31 0x89 0x74 0x2C 0x87 0x1D 0xBF 0x93 0x85 0x80 0x40 0x20 0xD3
        0x18 0x47 0x16 0xE1 0xC5 0xB7 0xEB 0x70 0xF6 0xF0 0x2C 0x34 0x1A 0xBA 0xD5 0x9C
        0x8C 0xA4 0xEE 0xDD 0x3C 0xD8 0xD9 0x7B 0xC4 0xA6 0x15 0xB3 0xAC 0x26 0x3D 0x45
        0x21 0x7B 0x67 0x43 0xA7 0x63 0x16 0x7B 0x83 0x3C 0x1B 0xAE 0x6A 0x8F 0x9E 0x49
        0xBE 0x99 0x01 0x92 0x1A 0xDE 0x6A 0xC5 0x7B 0x48 0xBA 0xF9 0x0A 0x29 0x82 0x46
        0x3E 0x9C 0xD5 0x81 0xDB 0xC7 0x70 0xFD 0xEB 0x6C 0x52 0x37 0x07 0xF8 0x61 0x3F
        0x79 0x31 0x57 0x32 0xC4 0x44 0x51 0x54 0x10 0x14 0x98 0x82 0x6B 0x0D 0xE5 0x50
        0xA8 0xC0 0xC2 0x11 0x48 0xF1 0x38 0x4B 0x86 0xAC 0xF0 0xA5 0x34 0x37 0x52 0x67
        0x89 0x88 0x93 0x4A 0x08 0x1E 0x92 0x17 0xE5 0x15 0xE5 0x14 0xB9 0x0C 0xCE 0x89
        0xC7 0x0F 0x92 0xC5 0x1C 0xA3 0xF6 0x77 0xB8 0x88 0x50 0xF0 0x57 0xC8 0x62 0xED
        0x34 0x89 0xE8 0x33 0xD2 0x22 0x6D 0x1B 0x45 0xC7 0xEB 0x84 0x32 0x13 0x18 0x84
        0x84 0x69 0x24 0xD5 0x87 0xC0 0x5D 0x82 0xE8 0x55 0x2A 0x1A 0x77 0xEC 0x04 0xA5
        0x21 0x86 0x16 0x04 0x25 0x9D 0x6D 0x66 0x11 0x9A 0x0E 0xBD 0xA9 0xB1 0xD1 0x4A
    ALIAS powmod_g powmod_gr 0x00
    ALIAS powmod_y powmod_gr 0x80 # = R2modP

    MEM 256 powmod_px !0x100 \
        0xA1 0x63 0xD2 0x90 0x0B 0xD0 0x3A 0xAC 0xB4 0x15 0x75 0xEA 0x5E 0x05 0x57 0x86
        0x55 0x12 0x36 0xE2 0xF8 0x07 0xCD 0x3E 0xE5 0x65 0x6E 0x70 0xE0 0x57 0xAE 0x5E
        0x2D 0x21 0x53 0xE1 0xF0 0xC4 0xE5 0x96 0xB9 0x83 0xB3 0x5C 0x37 0xE2 0x3C 0x54
        0xBF 0xF7 0x0F 0x4A 0xD8 0x19 0x2C 0xCA 0x3C 0xCA 0xD9 0x28 0xC3 0x76 0x75 0x5B
        0x13 0x93 0xA3 0xC4 0x98 0x4E 0x6B 0x99 0x33 0x79 0xDC 0xCE 0x9C 0xB0 0xE8 0xBA
        0x71 0xCD 0x27 0x5E 0xFA 0x8D 0xB0 0x7C 0x08 0xCF 0xF6 0x24 0x1B 0xD4 0xDA 0xCC
        0x09 0x27 0x72 0x9C 0x5F 0x8D 0x08 0x6D 0x95 0x33 0x28 0xEE 0xAF 0x5D 0xED 0xB2
        0x6E 0xB0 0xC3 0xE4 0xA3 0x70 0x4E 0x6B 0xF2 0xF9 0x6E 0x9C 0x4F 0xAB 0xFB 0xD8
        0xC0 0xFA 0x69 0x4E 0x7C 0xBF 0x6D 0x94 0x18 0xE7 0x5C 0xB7 0xE8 0xE2 0xF4 0xCB
        0x4B 0x75 0x3B 0x93 0x78 0x55 0xFC 0x0A 0x0D 0x00 0xEE 0xFE 0x16 0x0A 0x1D 0xAF
        0x28 0xD0 0x9B 0xF2 0x09 0x4B 0x31 0xDE 0xF5 0x54 0x0E 0xCD 0xFE 0x4E 0x98 0x73
        0x31 0x07 0x7E 0x90 0x1E 0xC6 0x98 0xD0 0xD8 0x1F 0xE8 0x0B 0x34 0xB7 0xFF 0x73
        0x4A 0x86 0x82 0x48 0x20 0x52 0x9C 0x57 0xD4 0x38 0x5F 0x8F 0x43 0x33 0xB6 0x91
        0xC1 0x14 0x5D 0xA6 0xAF 0x7B 0x13 0xA8 0xFB 0x89 0xAC 0xC8 0xFA 0x40 0x1F 0x21
        0x14 0x7C 0xE7 0x64 0xCE 0xFF 0x48 0x49 0x7F 0xFD 0x9B 0x1A 0xA5 0x97 0x42 0x4A
        0x94 0xB9 0xD6 0x70 0x83 0x38 0xAE 0xB3 0x78 0xBF 0xA6 0x48 0x24 0x4D 0x81 0x8C
    ALIAS powmod_p powmod_px 0x00
    ALIAS powmod_x powmod_px 0x80

    MEM 128 ANS &0xF00
    MEM 128 powmod_exp \
        0xB4 0xBB 0x5B 0xB6 0x58 0x7A 0x9D 0x7A 0xEB 0x1C 0xE9 0x79 0xBF 0x94 0xF6 0x60
        0x57 0x37 0x87 0x60 0x20 0x85 0xB3 0xB6 0xDD 0x9B 0xF4 0xA5 0xD8 0xFA 0x4C 0xC6
        0xAD 0x84 0x39 0xCC 0xEC 0xD3 0xDD 0x23 0x86 0x4A 0x2C 0x50 0x93 0xEC 0xD6 0xAD
        0x0D 0xD6 0xC4 0xBC 0xA1 0xD7 0x36 0x4F 0x2A 0x80 0x3F 0xC3 0x0C 0x0F 0xCD 0x4F
        0x6C 0x6D 0xF1 0x5F 0x3D 0x58 0xAF 0xB5 0x1A 0x5B 0x85 0xF4 0xB8 0x77 0x11 0xD0
        0x48 0x94 0xD7 0xC4 0xFF 0xFD 0x21 0xC1 0x41 0xA4 0x34 0xBB 0xC3 0x01 0x3A 0x36
        0x4A 0x30 0xC3 0x3E 0x91 0xB2 0x86 0x2E 0x82 0xB0 0x87 0x63 0x81 0xCF 0x9E 0x33
        0xC0 0x22 0x73 0x3B 0x05 0x95 0x8D 0xEA 0x80 0xA1 0xEE 0x33 0x47 0xD7 0xF2 0x84

解説(事前定数有版)

y = g ^ x mod p ( r: R^2 mod p )

rはpの値によって決まるモンゴメリ乗算の事前定数。モンゴメリ乗算の基数2はICF3(1999年)でも使われていました。1024bitべき乗剰余演算のサブルーチンの入力パラメータは256バイトのブロック2個。powmod_grとpowmod_pxです。grは前半128バイトがg、後半128バイトがr。　pxは前半128バイトがp(奇数)、後半128バイトがx。サブルーチンが終了するとrの場所に演算結果yが入っています。

1024bitのべき乗剰余演算(事前定数無版)

###################################################################
### WZeta powmod 1024bit 2022/06/10 by Naoki Hirayama 
### 
### These codes are licensed under CC0.(Public Domain)
### http://creativecommons.org/publicdomain/zero/1.0/deed.ja
### 
### Montgomery multiplication method with radix 2,
### which is famous for being used in ICF3(1999).
###
### This code is for Open source 8bit CPU WZeta.
### https://wzeta.idletime.tokyo/
###
### download WZeta simulator
### https://subnote.icf3.net/wz660/download/
### 
### How to do simulation.
### > wzsim (this file)
### 
###################################################################
### ---------------------------------------------------------------
###  Subroutine powmod1024  y = g^x mod p
###  INOUT g,y     128,128 !0x100
###  IN    x,p     128,128 !0x100
### ---------------------------------------------------------------
    MEMORY 4
    MODEL TINY
###     MEMORY 8
###     MODEL HALF

    .PROG
    LD A,&powmod_gy.H
    ST %_b_powmod_gy,A
    LD A,&powmod_px.H
    ST %_b_powmod_px,A

    LD A, ^_b_powmod1024.H
    LD B, ^_b_powmod1024.L
    BAL A:B

    LD A,32
    ST %_b_powmod_i,A
    LD A, &ANS.H
    LD B,0x80
        LD C,0x00
copy_ans:           # ans <- powmod_y
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    STACP [&powmod_y:B]
    DEC %_b_powmod_i
    JRZ0 ^copy_ans

        $PRINT &ANS 128
    NOP
        $PRINT &powmod_exp 128
        EXIT    

### ---------------------------------------------------------------
###  [%h:%l] =[%h:%l] * g R-1mod p
###  IN %h:%l : pointer
###  CONST p,g
### ---------------------------------------------------------------
_b_powmod1024_mm:
    ST %_b_powmod_retA,A
    ST %_b_powmod_retB,B

    LD A,&_b_powmod_a.H # a = 0
    LD B,&_b_powmod_a.L
    LD C,128        # repeat 129
    LOOPZERO

    ZERO %_b_powmod_m
_b_powmod1024_mm_loop_m:        # for m=0 to 127
    LD A,8
    ST %_b_powmod_n,A

        LD A, %_b_powmod_m
    ADD A, %_b_powmod_l
    LD B,A
        LD A, %_b_powmod_h
    LD A,[A:B]
    ST %_b_powmod_x,A
_b_powmod1024_mm_loop_n:        # for n=0 to 7
### loop body start --------------------------
    LD A, %_b_powmod_x
    LD B, 0
    AND A,[&powmod_g:B]
    XOR A,[&_b_powmod_a:B]
    ST %_b_powmod_u,A

    SHRC %_b_powmod_x
    JRC0 ^_b_powmod1024_mm2 # yi = 0 skip a += g

    LD B,0          # a += g
    CLC
    LD C,15
_b_powmod1024_mm1:
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_g:B]
    ADDC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm1
    INCC [&_b_powmod_a:B]

_b_powmod1024_mm2:
    SHRC %_b_powmod_u
    JRC0 ^_b_powmod1024_mm4 # u=0 skip +p

    LD B,0          # a += p
    CLC
    LD C,15
_b_powmod1024_mm3:
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    !ADDC [&_b_powmod_a:B],A
    LD  A,[&powmod_p:B]
    ADDC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm3
    INCC [&_b_powmod_a:B]

_b_powmod1024_mm4:      # a >>= 1
    LD A, &_b_powmod_a.H
    LD B,128
    LD C,128
    CLC
    LOOPSHRC
### loop body end   --------------------------
    DEC %_b_powmod_n
    JRZ0 ^_b_powmod1024_mm_loop_n

    INCX %_b_powmod_m   # A=m++
    XOR A,0x7F
    JRZ0 ^_b_powmod1024_mm_loop_m

### Final Substruct
    INC %_b_powmod_n    # n=1
_b_powmod1024_mm5:  
    LD A,32         # y=a(before sub)
    ST %_b_powmod_m,A   # 32 = 128 / 4
    LD A,%_b_powmod_h
    LD C,%_b_powmod_l
    LD B,0
_b_powmod1024_mm6:
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    STACP [&_b_powmod_a:B]
    DEC %_b_powmod_m
    JRZ0 ^_b_powmod1024_mm6

    LD C,%_b_powmod_n
    LOOPINC ^_b_powmod1024_mm8 # if C!=0 jump

_b_powmod1024_mm7:      # return
    LD A,%_b_powmod_retA
    LD B,%_b_powmod_retB
    JMP A:B

_b_powmod1024_mm8:
    LD B,0          # a -= p
    LD A,0
    SUB A,C         # CF=1
    LD C,31
_b_powmod1024_mm9:
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    !SUBC [&_b_powmod_a:B],A
    LD A,[&powmod_p:B]
    SUBC [&_b_powmod_a:B],A
    LOOPINC ^_b_powmod1024_mm9
    DECC [&_b_powmod_a:B]
    JRC0 ^_b_powmod1024_mm7
    ZERO %_b_powmod_n
    JR ^_b_powmod1024_mm5
### ---------------------------------------------------------------

### ---------------------------------------------------------------
###  Subroutine powmod1024
###        INOUT g,y     128,128 !0x100
###  const IN    x,p     128,128 !0x100
###  work _b_powmod_a    129     !0x100
### ---------------------------------------------------------------
_b_powmod1024:
    ST %_b_powmod_RETA,A
    ST %_b_powmod_RETB,B

### g = gR mod p
    LD A,4
    ST %_b_powmod_i,A   # for i=4 to 1
    ZERO %_b_powmod_j   # for j=0 to 255
powmod_loop_gi:
    ### always %_b_powmod_j = 0
powmod_loop_gj:

    LD A,&powmod_g.H    # g<<=1
    LD B,0
    LD C,0x7F
    CLC
    LOOPSHLC
    GETFLAG [0]
    JRC1 ^_b_powmod1024_lbl1 # skip copy

    LD A,&_b_powmod_a.H  # copy a <- g
    LD B,0
    LD C,0x7F
_b_powmod1024_loop1:
    STAB [&powmod_g:B]
    LOOPINC ^_b_powmod1024_loop1

_b_powmod1024_lbl1:
    LD B,0
    LD A,[&powmod_p:B]
    SUB [&powmod_g:B],A
    !LD C,126
_b_powmod1024_loop2:
    LD A,[&powmod_p:B]
    SUBC [&powmod_g:B],A
    LOOPINC ^_b_powmod1024_loop2
    JRC1 ^_b_powmod1024_lbl2
    SHL [0]
    JRC1 ^_b_powmod1024_lbl2

    LD A,&powmod_g.H     # copy g <- a
    LD B,0
    LD C,0x7F
_b_powmod1024_loop3:
    STAB [&_b_powmod_a:B]
    LOOPINC ^_b_powmod1024_loop3

_b_powmod1024_lbl2:
    DEC %_b_powmod_j
    JRZ0 ^powmod_loop_gj
    DEC %_b_powmod_i
    JRZ0 ^powmod_loop_gi

# powmod_y = 1 start    
    LD A, %_b_powmod_gy
    LD B,0x80       # y
    LD C, 1
    !ST [A:B],C     # y[0] = 1
    LD C,126        # repeat 127
    LOOPZERO

    ZERO %_b_powmod_i           # for i=0 to 127
powmod_loop_i:
    LD A,8
    ST %_b_powmod_j,A           # for j=0 to 7

    LD A, &powmod_x.L
    ADD A, %_b_powmod_i
    LD B,A
    LD A,[&powmod_x:B]
    ST %_b_powmod_y,A
powmod_loop_j:
### 
### loop main
### 
    SHRC %_b_powmod_y
    JRC0 ^powmod1024_lbl3   # skip yi=0

### CALL powmod_1024mm (y*g)
    LD A, &powmod_y.H
    ST %_b_powmod_h , A
    LD A, &powmod_y.L
    ST %_b_powmod_l , A
    LD B, ^_b_powmod1024_mm.L
    BAL ^_b_powmod1024_mm:B

powmod1024_lbl3:
### CALL powmod_1024mm (g*g)
    LD A, &powmod_g.H
    ST %_b_powmod_h , A
    LD A, &powmod_g.L
    ST %_b_powmod_l , A
    LD B, ^_b_powmod1024_mm.L
    BAL ^_b_powmod1024_mm:B

    DEC %_b_powmod_j
    JRZ0 ^powmod_loop_j

    INCX %_b_powmod_i           # A=[i++]
    XOR A,0x7F
    JRZ0 ^powmod_loop_i

    LD A,%_b_powmod_RETA
    LD B,%_b_powmod_RETB
    JMP A:B

    .DATA
    REG 16 _reg02
    ALIAS _b_powmod_gy _reg02 0
    ALIAS _b_powmod_px _reg02 1
    ALIAS _b_powmod_x  _reg02 2
    ALIAS _b_powmod_y  _reg02 3
    ALIAS _b_powmod_i  _reg02 4
    ALIAS _b_powmod_j  _reg02 5
    ALIAS _b_powmod_m  _reg02 6
    ALIAS _b_powmod_n  _reg02 7
    ALIAS _b_powmod_h  _reg02 8
    ALIAS _b_powmod_l  _reg02 9
    ALIAS _b_powmod_u  _reg02 10
    ALIAS _b_powmod_retA  _reg02 11 # child sub
    ALIAS _b_powmod_retB  _reg02 12 # child sub
    ALIAS _b_powmod_RETA  _reg02 13
    ALIAS _b_powmod_RETB  _reg02 14

    MEM 129 _system_work !0x100
    ALIAS _b_powmod_a _system_work 0

    MEM 256 powmod_gy &0xE00 \
        0x3A 0x43 0xCE 0xEB 0xEC 0x52 0x88 0x94 0x4B 0x42 0x09 0xF6 0x91 0x70 0x7B 0x7F
        0x25 0x1F 0xB8 0x44 0x32 0x0F 0x05 0x7F 0xF9 0xDD 0xA5 0x94 0x58 0x32 0x70 0x1E
        0xCD 0x91 0x16 0xAC 0x21 0x16 0x90 0x79 0xCC 0xC2 0x66 0xC1 0x88 0x85 0x06 0x3B
        0xF5 0x66 0xF2 0x31 0x89 0x74 0x2C 0x87 0x1D 0xBF 0x93 0x85 0x80 0x40 0x20 0xD3
        0x18 0x47 0x16 0xE1 0xC5 0xB7 0xEB 0x70 0xF6 0xF0 0x2C 0x34 0x1A 0xBA 0xD5 0x9C
        0x8C 0xA4 0xEE 0xDD 0x3C 0xD8 0xD9 0x7B 0xC4 0xA6 0x15 0xB3 0xAC 0x26 0x3D 0x45
        0x21 0x7B 0x67 0x43 0xA7 0x63 0x16 0x7B 0x83 0x3C 0x1B 0xAE 0x6A 0x8F 0x9E 0x49
        0xBE 0x99 0x01 0x92 0x1A 0xDE 0x6A 0xC5 0x7B 0x48 0xBA 0xF9 0x0A 0x29 0x82 0x46
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
    ALIAS powmod_g powmod_gy 0x00
    ALIAS powmod_y powmod_gy 0x80

    MEM 256 powmod_px &0xD00 \
        0xA1 0x63 0xD2 0x90 0x0B 0xD0 0x3A 0xAC 0xB4 0x15 0x75 0xEA 0x5E 0x05 0x57 0x86
        0x55 0x12 0x36 0xE2 0xF8 0x07 0xCD 0x3E 0xE5 0x65 0x6E 0x70 0xE0 0x57 0xAE 0x5E
        0x2D 0x21 0x53 0xE1 0xF0 0xC4 0xE5 0x96 0xB9 0x83 0xB3 0x5C 0x37 0xE2 0x3C 0x54
        0xBF 0xF7 0x0F 0x4A 0xD8 0x19 0x2C 0xCA 0x3C 0xCA 0xD9 0x28 0xC3 0x76 0x75 0x5B
        0x13 0x93 0xA3 0xC4 0x98 0x4E 0x6B 0x99 0x33 0x79 0xDC 0xCE 0x9C 0xB0 0xE8 0xBA
        0x71 0xCD 0x27 0x5E 0xFA 0x8D 0xB0 0x7C 0x08 0xCF 0xF6 0x24 0x1B 0xD4 0xDA 0xCC
        0x09 0x27 0x72 0x9C 0x5F 0x8D 0x08 0x6D 0x95 0x33 0x28 0xEE 0xAF 0x5D 0xED 0xB2
        0x6E 0xB0 0xC3 0xE4 0xA3 0x70 0x4E 0x6B 0xF2 0xF9 0x6E 0x9C 0x4F 0xAB 0xFB 0xD8
        0xC0 0xFA 0x69 0x4E 0x7C 0xBF 0x6D 0x94 0x18 0xE7 0x5C 0xB7 0xE8 0xE2 0xF4 0xCB
        0x4B 0x75 0x3B 0x93 0x78 0x55 0xFC 0x0A 0x0D 0x00 0xEE 0xFE 0x16 0x0A 0x1D 0xAF
        0x28 0xD0 0x9B 0xF2 0x09 0x4B 0x31 0xDE 0xF5 0x54 0x0E 0xCD 0xFE 0x4E 0x98 0x73
        0x31 0x07 0x7E 0x90 0x1E 0xC6 0x98 0xD0 0xD8 0x1F 0xE8 0x0B 0x34 0xB7 0xFF 0x73
        0x4A 0x86 0x82 0x48 0x20 0x52 0x9C 0x57 0xD4 0x38 0x5F 0x8F 0x43 0x33 0xB6 0x91
        0xC1 0x14 0x5D 0xA6 0xAF 0x7B 0x13 0xA8 0xFB 0x89 0xAC 0xC8 0xFA 0x40 0x1F 0x21
        0x14 0x7C 0xE7 0x64 0xCE 0xFF 0x48 0x49 0x7F 0xFD 0x9B 0x1A 0xA5 0x97 0x42 0x4A
        0x94 0xB9 0xD6 0x70 0x83 0x38 0xAE 0xB3 0x78 0xBF 0xA6 0x48 0x24 0x4D 0x81 0x8C
    ALIAS powmod_p powmod_px 0x00
    ALIAS powmod_x powmod_px 0x80

    MEM 128 ANS &0xF00
    MEM 128 powmod_exp \
        0xB4 0xBB 0x5B 0xB6 0x58 0x7A 0x9D 0x7A 0xEB 0x1C 0xE9 0x79 0xBF 0x94 0xF6 0x60
        0x57 0x37 0x87 0x60 0x20 0x85 0xB3 0xB6 0xDD 0x9B 0xF4 0xA5 0xD8 0xFA 0x4C 0xC6
        0xAD 0x84 0x39 0xCC 0xEC 0xD3 0xDD 0x23 0x86 0x4A 0x2C 0x50 0x93 0xEC 0xD6 0xAD
        0x0D 0xD6 0xC4 0xBC 0xA1 0xD7 0x36 0x4F 0x2A 0x80 0x3F 0xC3 0x0C 0x0F 0xCD 0x4F
        0x6C 0x6D 0xF1 0x5F 0x3D 0x58 0xAF 0xB5 0x1A 0x5B 0x85 0xF4 0xB8 0x77 0x11 0xD0
        0x48 0x94 0xD7 0xC4 0xFF 0xFD 0x21 0xC1 0x41 0xA4 0x34 0xBB 0xC3 0x01 0x3A 0x36
        0x4A 0x30 0xC3 0x3E 0x91 0xB2 0x86 0x2E 0x82 0xB0 0x87 0x63 0x81 0xCF 0x9E 0x33
        0xC0 0x22 0x73 0x3B 0x05 0x95 0x8D 0xEA 0x80 0xA1 0xEE 0x33 0x47 0xD7 0xF2 0x84

解説(事前定数無版)

y = g ^ x mod p

モンゴメリ乗算の基数2はICF3(1999年)でも使われていました。1024bitべき乗剰余演算のサブルーチンの入力パラメータは256バイトのブロック2個。powmod_gyとpowmod_pxです。gyは前半128バイトがg、後半128バイトは演算結果。　pxは前半128バイトがp(奇数)、後半128バイトがx。

実行環境

WZetaシミュレータで実際に演算させてみることが可能です。

> wzsim (アセンブラのファイル)

注意シミュレータにはC言語実装のシミュレータとverilogのバイナリがあります。verilogでは1024bitのべき乗剰余演算に１週間以上かかることもあるので、ご注意ください。

実行結果

実行後、演算が終了すると演算結果に続いて期待値が表示されます。期待値はコードの最後にあるpowmod_expの値が、そのまま表示されます。

性能について

乗算命令が無いため8bitの加算器1個で演算しています。絶対時間では非常に遅いため軽量な楕円暗号か、数時間の演算時間が許容されるIoTシステムなどでの利用に向いています。BIOSを通してアプリを作成すればアプリを改変することなく超高速な暗号プロセッサSnakeCubeに置き換えられることを考えているため、性能が必要になったところで、暗号プロセッサSnakeCubeに置き換えることが可能になる予想です。シミュレータの実行終了後、命令数が表示されます。WZetaのSDogコアでは1命令4サイクルなので命令数を4倍して周波数を計算すると1024bitのべき乗剰余演算１回の時間が求まります。値に依存しますが、上記、サンプルコードでは666530315命令。CPUの周波数に8MHzを想定した場合、1サイクル125[ns]なので
666530315 × 4 × 125 ÷ 10^9 ≒ 333秒 ( 512bitのべき乗剰余演算だと約42秒 )

脆弱性対策

今回のコードは脆弱性対策の無い単純に最も高速なプログラムになっています。また最上位ビットを高速モードとして使っています。サイドチャネル攻撃を対策をするには値に依存しないようにダミーの計算時間を入れます。WZetaの命令セットはオペコードに依存せずメモリアクセスをするという低消費電力でない特性がありますが、これが電力解析などのサイドチャネル攻撃への耐性を高めることにもなっています。トランジスタ数が少ないのでオペコードに依存しない動作で0、1の切り替えが多くなったとしても、全体としての消費電力は少ないという予想です。

サーバハードウェア（パーツ）ざっくりまとめ

2021-05-19T14:20:49+09:00

サーバハードウェアのパーツ

コンピュータアーキテクチャで7個くらいあったけど、ここでは
1.CPU
2.メモリ
3.ディスク
の3個についてまとめる

CPU

主に演算を担当しているパーツ
処理性能を左右する要素が3つある

1.クロック周波数と世代

クロック周波数が高ければ高いほど処理速度が上がる
また、同じ周波数でも世代が新しい物の方が性能は上

2.コア数

CPUの核になる部分。
基本数が多ければ多いほど並列処理の性能が上がる

3.キャッシュメモリ

アクセスしたいデータの一部をCPUの内部に保存できる場所
ここに保存されてるデータにアクセスするとき早くなる。
大きいほうがいい。サーバのはPCよりでかい。

メモリ（主記憶装置）

キャッシュメモリに入りきらないデータを入れる場所
ディスクより処理が早くキャッシュメモリより低速
メモリは容量が大きいほうがいい
データのエラーを検出、訂正ができる

ECC(Error Correction Code)

機能搭載が一般的

ディスク

OS、アプリケーションプログラム、データを格納する装置
電源を切ってもデータは消えないが処理速度は遅い
2種類ある

①ハードディスク
磁気でデータを記録するディスク
ハードディスクの中でまた二つの種類がある
①-1SATAハードディスク
PC用。一日8時間程度の稼働を想定している。
安くて大容量だけど遅い
①-2SASハードディスク
サーバ用。365日24時間稼働を想定
SSDより安くSATAより高速

②SSD
半導体でデータを記録するディスク
②-1SSD(Solid State Drive)
SATA、SAS、NVMeの接続規格に対応したものがある
ハードディスクよりかなり高価だけど圧倒的に速い

リレー式論理回路シミュレータを自作して1bit CPUまで動かした

2021-04-16T04:38:28+09:00

「1bit CPU」というのは、書籍『CPUの創りかた』に載っている「オリジナルCPU 試作3号機（エレキ式）」のことです。
※ ブログに書いていた記事のクロス投稿です。元の公開日は 2020-05-03 です。

概要

リポジトリ:
https://github.com/sonota88/kairo-gokko

デモ（ブラウザで動かせます）:
https://sonota88.github.io/kairo-gokko/pages/39/index.html

音量を小さめにしていますが、音が出ます
表示サイズや負荷の関係でPCブラウザ推奨です
- とりあえず富豪的に作っていて、まだ最適化などやってません
最初は発振するので、スイッチを適当に操作して発振を止める必要があります。操作についてはこちらも参照してください。

製作過程のメモ（どういうステップを踏んで何を実装していったか、具体的な話はこっちにまとめています）:
https://memo88.hatenablog.com/entry/2020/04/21/065800

動かしている様子です。

左下のスイッチがクロックで、右下のスイッチで命令（ MOV A, A と NOT A ）を切り替えています。

回路図を描いて動かすまでの流れ:

回路図を LibreOffice Draw で描いて .fodg 形式で保存
fodg ファイルを読んで前処理し、中間データ（JSON）に変換
シミュレータのプログラムと中間データを使ってブラウザで実行

LibreOffice Draw で描いた回路図はこんな感じ。

直線と矩形、矩形内のテキストだけです。部品はグリッドに合わせて配置します。ナナメの配線は禁止。

使っている部品:

導線
電池のプラス極・マイナス極
ランプ
スイッチ。マウスでクリックすると ON/OFF が切り替わります。
リレー（2種類）

ランプ、リレーには極性なし（プラス極・マイナス極を入れ替えても動作は変わらない）

小さい回路の例をいくつか:

NOT（を3つ繋げたもの）

NAND

XOR

RSフリップフロップ

ほぼ Ruby 製。ブラウザで動かす部分は DXOpal を使っています。

（一応残してあるが）不要になっている部分、補助ツール的なスクリプト、コメントなどを除くと主な部分は 2000行弱（2021-04-11 時点）。途中いろいろありましたができあがってみると意外と小さい。

$ wc -l *.rb
  283 child_circuit.rb
  456 circuit.rb
  114 drawer_dxopal.rb
  137 libo_draw.rb
  237 main.rb
   26 preprocess.rb
  307 unit.rb
  346 view.rb
 1906 合計

製作期間

2019-12-31 〜 2020-02-02
（プロトタイプを作り始めてから 1bit CPU が動くまで）

始める前からいろいろ調べたりはしていて、書き始めたのが 12/31 だったか 12/30 だったか。

回路図エディタの部分を LibreOffice Draw に丸投げすることにより、製作期間を短縮しシミュレータ部分に集中することができました。

どのくらいの電気の知識で始めたか

小学校、中学校の理科レベル
- 電池、エナメル線、豆電球、電磁石、直列・並列つなぎ
大学の頃にちょっとだけ電子工作やろうとするも鉱石ラジオ作った程度で終わった
『CPUの創りかた』のうっすらした記憶
リレーは名前は聞いたことあったけどどういうものか知らなかった
トランジスタの前は真空管を使っていたらしい
GND って何？

……という程度。

コンセプト・方針

ガチャガチャ動く機械仕掛けのおもちゃ
ピタゴラ装置みたいなの
電圧や抵抗は考慮しない
- 難しそうなので
- 電気が流れているか、流れていないかだけ考える
小学校の理科の工作の延長程度のもの
なるべく寄り道せずに曳光弾を通す
- 遅すぎて辛い、ということがなければ最適化は後回し
- そもそも作れるのか、（論理）回路を動かすには最低限何が必要なのかなど、よく分かっていなかった

なぜ作ったか / 作り始めるまでの経緯

並行してボンヤリと考えていたのですっきりまとめることができませんが、思い出して雑に書き出してみました。

列挙の順序も適当です。

そもそもは『CPUの創りかた』

CPUの創りかた | マイナビブックス

最初に読んだのは 4年くらい前
かなり基本的なところから手取り足取り説明されていてとっても良い本だが、単に読むだけだと後半で分からなくなる
さすがに何も知らない私みたいなド素人がさらっと読んだだけで理解できるほど甘くはない
（自分のような初心者は）作りながら読まないと分からないのでは
- 回路図を読むところがネックになる
- 回路図というものは抽象化された図なわけで、そこから具体的な回路や動作がどうなるかよく分からない
しかし作るのは面倒
- 部品の調達
- また部屋が散らかる……
- 知識・経験がなさすぎてゴールが遠い
物理CPU作るのは老後の楽しみにしよう……
とはいえ、先にしくみだけでも理解したい
しくみを理解するには、やはり自分で作って電子回路についての経験を積む必要があるんだろうな……
- → 「しかし作るのは面倒」に戻る
- ブートストラップ問題
しくみを理解するだけなら、枝葉の部分を捨ててもっと簡素化してハードルを下げられないか

こういうのって、実際に手を動かして作って壊して、回路図とにらめっこしたり計算をやりなおして試行錯誤を繰り返すうちにだんだん勘が養われていくものだと思いますが、そういう経験がない状態なのでなかなか大変です。

論理回路シミュレータ

そもそも論理回路シミュレータというものをよく知らなかった
シミュレータで CPU（TD4など）を作っている人たちがいると知る
物理CPU作る前にこれで試すのは良さそう
- 手間・時間をかけずに好きなだけスクラップ＆ビルドできる
- 部屋も散らからない

nand2tetlis

O'Reilly Japan - コンピュータシステムの理論と実装

通称（？） nand2tetlis
物理的な電子回路でなぜ論理回路が動くのか、という部分がよく分からないまま HDL に進んでしまうのがちょっと不満
そこの部分のブラックボックス感を解消したいのに

そもそも論理回路が動くしくみがよく分かってない

入力側から電流が流れてきて、それが出力側に伝わるというのは分かる
NOTゲートってどうなってるの。謎。
- 入力が L で出力が H になる場合、その H の電力はどこから来てるの
- 省略されると分からない
フリップフロップ
- タイミングが絡んでくるし、入力がループするので、脳内でエミュレートできない
- （自分で作って）動かしてみないとどうも実感が湧かない
論理回路図というものは抽象化された図なわけで、どうすればそれを物理的な回路で実現できるかが分からない

今だからこうやって言語化できていますが、もっとボンヤリとモヤモヤしてました。「なんとなく……分かった気がする……たぶん……とりあえずそういうものだと飲み込んで先に進んでもいいが……（モヤモヤ）」みたいな。

リレー

トランジスタについてもよく分かっていなかったので、トランジスタ → 真空管 → リレーと遡って調べたりしていた
リレーについて知ることで「要するに何をやっているのか」「何のための部品なのか」が分かった
要するに「電気を使ってスイッチを切り替える装置」
- 英語版 Wikipedia の説明が簡潔で良いです。 "A relay is an electrically operated switch."
- 「それを早く教えてよ！」という気分に
リレー、めっちゃ良い。分かりやすい。小学生でも理解できる。電磁石まで知ってればあともう一歩。そのくせインパクトがでかい。
- 「小学校の理科でついでにリレーまで教えてくれてればよかったのに！」という気分に ¹
- 「小学校の理科の知識に、あとはリレーだけ付け加えれば CPU まで作れる」というのは、なんかいい。よくないですか？
トランジスタについても、「N型と P型があって正孔が……」という半導体自体の説明よりも、先に役割や目的について着目した方が（自分には）分かりやすかったと思います

たしか、ここがクリアされたことで「あ、これなら自分でも作れるかも？」みたいな気分になった気がします。

Minecraft や Oxygen Not Included の論理回路

楽しい
あの要素だけなら、自分でもなんとか作って遊べるのではないか？
- そう思わせてくれるところがとても良い。教育的。
グリッド配置にしたのはこれらの影響
他にも、マリオメーカーや Cities: Skylines などで作ってみた系の記事や動画を見て「その部分だけ抜き出したもの」程度なら自分でも作れないか、と妄想したり

水流モデル（失敗）

電気について詳しくないので水流モデルの方が分かりやすいかな、と思ってセルオートマトンで作ろうとした
逆に複雑で難しかったので中止

どうやって作るか

ググっても「論理回路シミュレータの作りかた」なんて解説は出てこない
- 自分のイメージに一番近かったのがこれ: A puzzle game that makes us build a complete computer - Joscha Bach
OSS なシミュレータのソースを読む手もあるが……
- Logisim とか ²
- そんなに本格的なものでなくてよい
- おもちゃみたいなのでよい
- 実用目的ではない。いわゆる「教育目的」なもの。
  枝葉を排して理解しやすさを優先したもの。
- 自分が作りたかったのは普通の論理回路シミュレータではなく、電池と導線と……で論理回路が動かせる、抽象化されていないシミュレータ
結局手探りで
詳しくは製作過程のメモの方に書きました

感想

おもしろかった！！
物理回路と論理回路との接続の部分が分かってよかった
1bit CPU を自分で実際に作れてよかった
- 生まれて初めて（シミュレータ上だけど）CPU を自作した！
- めでたい！
NOTゲートえらい
- NOTゲートが作れるようになるのでリレーは偉大な発明
- で、リレーで論理回路を作るアイデアはどこから出てきたんだ、誰が始めたんだ…… と調べていくとクロード・シャノンにたどり着きます。コンピュータの黎明期の話というとチューリングやノイマンが有名ですが、シャノンも非常に重要な仕事をしていたんですね（これも今回いろいろ調べていて知りました）。
  - 中嶋章についてのscivolaさんのコメントも参照
- 連載：インターネット・サイエンスの歴史人物館（2）クロード・シャノン | 情報通信（ICT） | スマートグリッドフォーラム
- プログラミングの10大基礎知識（3） | 日経クロステック（xTECH）
電気の知識がちょっと増えてよかった
- ふだんやらないことをやると知らないことだらけで楽しい
むちゃくちゃ難易度高いということもなく、動くと楽しいのでプログラミングのお題としてもおもしろいと思います。おすすめ。

TODO

気が向いたらやりたい

最適化・リファクタリング
- 現状ではだいぶ富豪的なので
タイミングチャート付ける
- そんなに難しくなさそう
- (2020-07-26) 付けました
1bit CPU から先
- これ以上規模が大きくなると大変そうだし、論理回路と物理回路の接続の理解についてはだいぶ気が済んだので、続きを作るとしたら既存の論理回路シミュレータを使えばよさそう
オブザーバーパターンや Actor モデルを使って書いてみる？

作った後に読んだもの

【東京書籍】一般書籍文芸コンピュータ、どうやってつくったんですか？
- 2020-12 に読んだ。リレーで説明されてて良い。
作ろう！CPU | マイナビブックス

指導要領の都合とかでいろいろあるんだと思います ↩︎
有名っぽいので Logisim を例に出しましたが、Logisim は開発が終わっているようなので他のものを探すのが良さそうです ↩︎

オープンソースのCPUの除算性能 RISC-V vs ICF3-Z

2020-03-19T20:19:01+09:00

はじめに

2020年1月15日に8bit CPU ICF3-Zを制限の緩いオープンソースのライセンスで公開しました。

CPUのようなハードウェアもオープンソースな時代になってきました。CPUのオープンソースで最も有名なのはRISC-Vです。RISC-Vを見てみるとオープンソースによるメリットを見つけることができます。RISC-Vは、とても広い範囲をカバーする32bit(64bit)のCPUですが低性能な領域でも万能というわけではないように思います。

例えば通信系のハードウェアでは8bit単位で処理するものもあり32bitが無駄になる場合もあります。無駄になるだけなら問題はありませんが消費電力で不利です。

一方、8bit CPUは除算命令がなかったり、除算命令があっても8bit÷8bitで、使える範囲が狭いということがありました。8bit CPUのオープンソースも既に複数、存在していますが、高性能な除算を持ったものは、あまりないように思います。ICF3-Zはオープンソースで、少ないトランジスタ数であるにもかかわらず高速な除算が可能です。

除算性能の比較

実際に比較しないと、わからない人が多いと思っています。 ICF3-ZのZeviosを小型のRISC-VコアであるlowRISCのibexと比較してみました。 ICF3-ZのZeviosは8bit CPUですが、lowRISCのibexは除算器を持った32bit CPUです。

lowRISCのWebページにXilinxのローエンドのFPGA(7シリーズ)に実装した場合の周波数が50MHz、面積2500LUTと書かれてありました。除算のサイクル数は別のページに37サイクルと記述されています。

Zeviosは同じくXilinxのローエンドのFPGA(Artix-7)に実装した場合、周波数は150MHzになります。つまりibexの3倍の周波数で動作します。ibexが1命令を実行するのにZeviosは3命令を実行できる。

除算	ibexRISC-V[サイクル]	ZeviosICF3-Z[サイクル]	ibexを1とした倍率	周波数を考慮した倍率
16bit÷8bit	37	20	1.85	5.55
24bit÷8bit条件付き	37	21	1.76	5.29
32bit÷8bit	37	55	0.67	2.02
32bit÷16bit	37	約350	0.11	0.32

0除算などのチェックや演算レジスタへのロード、ストアの補正として3～6サイクル追加しています。
ZeviosはXilinxのFPGA XC7A35TICSG324-1Lに実装した場合です。

まとめ

ibexは2500LUTの面積ですが、Zeviosは400LUTの面積です。外部I/OなどZeviosに不足しているものがあるかもしれませんが5分の一の面積で5倍以上の性能が出ることは、考えるべき点ではないでしょうか。16bit÷8bitは32bit CPUであるRISC-Vに不利ということはありますが、制御など32bitの精度が必ずしも必要ない場合もあるように思います。

ICF3-Zは海外のパクリな構造ではなく僕の考えた独自アーキテクチャです。疑似パイプラインによって高周波数で動作することも、この圧倒的な面積当たりの性能(25倍)に貢献しています。

このオープンソースな8bit CPU ICF3-Zが、期待を含めれば2020年代に大きく産業に貢献していくかもしれません。

参考リンク

8bit CPU ICF3-ZのZeviosの除算性能のメモ

8bit CPU ATmega328の除算性能を測定してみた

仮想マシンの加速支援機構つきの新型8bit CPU

8bit CPU ICF3-ZのZeviosの除算性能のメモ

2020-01-16T06:22:14+09:00

はじめに

8bit CPU ICF3-Zのオリジナルのコア、Zeviosの除算性能について解説します。Zeviosは2020年1月15日に緩いオープンソースライセンスであるApache License 2.0で公開されました。FPGAに実装できるverilogファイルがあるので、いろいろ性能を測定することができます。

Zeviosの除算器について

正しくは除算器というものはなくて8bitの加算器を効率的に動作させることで1サイクルに1bitの商を演算するアーキテクチャです。除算器の性能としては低いのですが、マイコン向けのCPUでは除算器がないものも多く、小さい面積なのに高速に除算ができるものになっています。(除算器としての面積がほとんどない) その除算向けのアーキテクチャを使って8bitより大きい除算をソフトウェアで実装できます。一般の8bit CPUによる実装よりも高速に演算できます。

16bit÷8bitの除算

ICF3-Zでは加算器を使って効率的に演算できるようになっています。17サイクルで演算ができます。

24bit÷8bitの除算

ICF3-Zでは加算器を使って効率的に演算できるようになっています。17サイクルで演算ができます。
ただし被除数の最上位8bitが除数8bitよりも小さい場合に限ります。

32bit÷8bitの除算

16bit÷8bitの除算方法を応用したサンプルコードによる性能は50サイクルです。サンプルコードはgithubで公開されています。
sim2フォルダのpmem.asmzが32bit÷8bitのコードです。

32bit÷16bitの除算

ICF3-Zのアーキテクチャを駆使したサンプルコードによる性能は約350サイクルです。サンプルコードはgithubで公開されています。
sim1フォルダのpmem.asmzが32bit÷16bitのコードです。
ソフトウェアの実装によって性能は違ってくると思われます。もっと高速な方法もあるかもしれません。
除数が8bit × 8bitの因数に分解できるものなら32bit ÷ 8bitを2回演算したほうが高速です。

32bit÷15bitを230サイクルで演算するコードも作ったのですが、まだ十分に検証できていないため、今回は見送りました。

おわりに

ICF3-Z Zeviosは、とても少ないトランジスタ数(面積)で実装できるのに高速です。16bit÷8bit、24bit÷8bitの除算が有効につかえるアプリでは低消費電力が期待できるように思われます。

8bit CPU ATmega328の除算性能を測定してみた

2020-01-12T04:51:56+09:00

はじめに

ATmega328は Microchipの8bit CPU AVRの1種です。AVRは除算命令がなくArduinoで除算をするコードを書いた場合、どのくらいの性能になるのか測定しました。測定条件でソフトウェア処理が最適化されていないのでAVRのアセンブラを使って最適化をすれば、もっと高速になるはずですが、これはソフト開発環境Arduinoのソフトウエア除算性能の測定です。

測定条件

CPU : ATmega328 クロック 16MHz
ボード: Arduino
ソフト開発環境 : Arduino 1.8.10
性能を測定する除算 : 16bit ÷ 8bit / 24bit ÷ 8bit

測定コード(16bit÷8bit)

除算を1万回実行して、加算のみの場合との差分を除算1万回の実行時間とします。

void setup() {
    Serial.begin(9600);
    randomSeed(analogRead(0));
}

void loop() {
    unsigned long s, e, t;
    unsigned int i;
    unsigned short x,z;
    unsigned char y;

    t = millis();  /* dummy */      
    s = millis();
    for(i=0 ; i<10000 ; i++) {
        x = random(0,0xffff);
        y = random(2,0xff);
        z += x + y;    
    }
    e = millis();
    t = e - s;
    Serial.print("x="); Serial.print(x);
    Serial.print(" y=");  Serial.print(y);            
    Serial.print(" time1=");  Serial.print(t);      
    Serial.print("\n");

    s = millis();
    for(i=0 ; i<10000 ; i++) {
        x = random(0,0xffff);
        y = random(2,0xff);
        z += x / y;    
    }
    e = millis();
    t = e - s;
    Serial.print("x=");  Serial.print(x);
    Serial.print(" y=");  Serial.print(y);
    Serial.print(" z=");  Serial.print(z);             
    Serial.print(" time2=");
    Serial.print(t);      
    Serial.print("\n\n");
}

測定コード(24bit÷8bit)

除算を1万回実行して、加算のみの場合との差分を除算1万回の実行時間とします。

void setup() {
    Serial.begin(9600);
    randomSeed(analogRead(0));
}

void loop() {
    unsigned long s, e, t;
    unsigned int i;
    unsigned long x,z;
    unsigned char y;

    t = millis();  /* dummy */      
    s = millis();
    for(i=0 ; i<10000 ; i++) {
        x = random(0,0x7effff);
        y = random(0x7f,0xff);
        z += x + y;    
    }
    e = millis();
    t = e - s;
    Serial.print("x=");   Serial.print(x);
    Serial.print(" y=");   Serial.print(y);            
    Serial.print(" time1=");  Serial.print(t);      
    Serial.print("\n");

    s = millis();
    for(i=0 ; i<10000 ; i++) {
        x = random(0,0x7effff);
        y = random(0x7f,0xff);
        z += x / y;    
    }
    e = millis();
    t = e - s;
    Serial.print("x="); Serial.print(x);
    Serial.print(" y="); Serial.print(y);
    Serial.print(" z=");  Serial.print(z);             
    Serial.print(" time2=");
    Serial.print(t);      
    Serial.print("\n\n");
}

結果(16bit÷8bit)

除算1万回の実行時間は約128 [mS] 16MHzで動作しているのでサイクル数は2048000 cyc
除算1回のサイクル数は204.8 cyc
比較用の加算2サイクルの補正を追加すると
16bit÷8bit 除算1回のサイクル数は207 cyc

結果(24bit÷8bit)

除算1万回の実行時間は約373 [mS] 16MHzで動作しているのでサイクル数は5968000 cyc
除算1回のサイクル数は596.8 cyc
比較用の加算2サイクルの補正を追加すると
24bit÷8bit 除算1回のサイクル数は599 cyc
32bit÷16bitの性能と、ほとんど同じなので、24bit÷8bit用に除算ルーチンを作り直せば性能は向上するのではないだろうか。

仮想マシンの加速支援機構つきの新型8bit CPU

2020-01-09T13:37:32+09:00

概要

新型の8bit CPU(ICF3-Z)を設計してFPGAに実装。仮想マシンの加速支援機構を使った、簡単なスタックマシンで、サンプルプログラムがXilinx FPGA Artix-7(-1)の実機上で動作した。たった約400LUTの小さいCPUで。Intel 8051マイコンのFREEな実装にlight52があります。軽量なマイコンですがCPU部だけで約800LUTあるようです。light52は1命令、6サイクルですが、このICF3-Zは1命令、1サイクルが基本で、時に1サイクルに複数命令の実行ができます。周波数比較もICF3-Zが、おおよそ２倍のようで、圧倒的に勝ったのかも。他にあまり比較できるものがなかったという話もありますが。

仮想マシンの加速支援機構とは

新型8bit CPU(ICF3-Z)なのですが命令コードが32bitで、一般的な8bit CPUと比べてメモリ効率が悪い。そこで16bitの圧縮命令の機能を追加した。この機能が仮想マシンの加速支援機構なのです。
圧縮命令のために作られたもので、加速支援機構として、最終的に成立するのかは、わからないですが、需要があって無理がなければ、加速支援機構として考えていく方向です。

加速支援機構が何の役に立つのか？

超低スペックなCPUでは、ソフトウエアで仮想マシンを実装しても性能的な問題で用途が狭められることがあります。この加速支援機構があれば実用の範囲が広がります。

2019年11月23日追記
仮想マシンの命令列を大容量の安価なプログラムメモリに置けるので、容量の少ない高価なデータメモリを圧迫しないということも利点です。

なぜ低スペックなCPUで仮想マシンなのか?

仮想マシンをJavaのようなスタックマシンにしたり、レジスタ１個のマシンにしたりできます。
CPUのアーキテクチャの違いを吸収して、いろいろな言語のコンパイラの開発を容易にします。
非C言語が利用できるようになることで、より多くの人がIoTデバイスなどを開発できるようになります。

試作プログラム

プログラムの上部で簡単なスタックマシンの命令を実装して、仮想マシンの命令列をFPGAの実機で動作させたものです。独自のアセンブラなので多少、わかりにくかもしれません。自作したアセンブラでバイナリを生成して、FPGAのプログラムメモリに、置きます。
即値の5をPUSH、メモリの0番の値をPUSH、メモリの1番の値をPUSH、乗算、加算、LEDに結果を出力。
メモリ0番には、最初のところで2を書き込んでいます。メモリ1番には3。つまり3*2+5 = 11がLEDに出力されます。(確認しました)

########################################################
# vm (Virtual Machie)
#
# C Register : SP(Stack Pointer)
# D Register : PRINT (LED x 8)
# MEM[0-255] : Memory
#
# PUSHI: SP=SP-1 , MEM[SP]=nn                     (5cyc)
# PUSHR: SP=SP-1 , MEM[SP]=MEM[nn]                (5cyc)
# POP  : MEM[nn]=MEM[SP] , SP=SP+1                (4cyc)
# ADD  : MEM[SP+1]=MEM[SP]+MEM[SP+1] , SP=SP+1    (7cyc)
# MUL  : MEM[SP+1]=MEM[SP]*MEM[SP+1] , SP=SP+1    (16cyc)
# PRINT: PRINT MEM[SP]      
########################################################
# Initial MEM[0]=0x02 , MEM[1]=0x03
########################################################
    ADDL=N;N=0x02;A=ANS
    STORE;Z=0
    ADDL=N;N=0x03;A=ANS
    B(START)
    STORE;Z=1;C=ANS;D=ANS
########################################################
%NOP:
    JRETURN
%PUSHI:
    ADDR=C;ADDL=N;N=0xFF;C=ANS
    RETURN;COPR;ADDL=N;A=ANS
    ADDR=C;R(ADDR);STORE
%PUSHR:
    ADDR=C;ADDL=N;N=0xFF;C=ANS
    RETURN;R(N);COPR
    MOV;ADDR=C;R(ADDR);STORE
%POP:
    RETURN;R(ADDR);ADDR=C;ONE;C=ANS
    MOV;COPR;R(N);STORE
%ADD:
    R(ADDR);ADDR=C;ONE;C=ANS
    B=REG;R(ADDR);ADDR=C
    B=REG;ADDR=B;A=ANS
    RETURN;ADDL=A;ADDR=B;A=ANS
    R(ADDR);ADDR=C;STORE
%MUL:
    R(ADDR);ADDR=C;ONE;C=ANS;D=ANS
    C=REG;R(ADDR);ADDR=C
    C=REG;ADDR=C;A=ANS
    B=ANS;I=X;X=7
    MUL;ADDL=A;ADDR=B;B=RSH;C=RSH;WAIT
    RETURN;ADDR=C;A=ANS
    R(ADDR);ADDR=D;STORE;C=ANS
%PRINT:
    RETURN;R(ADDR);ADDR=C
    D=REG
START:
    _%PUSHI,0x05,%PUSHR,0x00
    _%PUSHR,0x01,%MUL,0x00
    _%ADD,0x00,%PRINT,0x00
    EXIT(0);@D
END:
    B(END)
    NOP

ちなみに

割込みの実装もついていて約400LUTです。2つの割込みを受けられます。

2019年12月29日更新

XilinxのFPGA(XC7A35TICSG324-1L)に搭載したArtyに実装して面積を確認しています。論理合成のオプションで結果が違うので、面積重視、性能重視の結果です。

合成方針	LUT数	FF数	BRAM数	LUT-RAM	周波数
面積重視	390	197	1.5	10	150MHz
面積重視	406	197	1.5	10	160MHz
性能重視	481	197	1.5	10	175MHz

BRAM 1.5の内訳はプログラムメモリ 4KBとデータメモリ 2KB

データメモリの先頭32バイトがレジスタ、先頭256バイトがスクラッチパッドメモリ。この合成結果はデータのアドレス線を8bitにしたものです。11bitにすればBRAMを消費することなく2KBのデータメモリをすべて使えます。データのアドレス線を16bitまで設定可能ですがBRAMを消費します。圧縮命令(仮想マシン)を利用する場合はプログラムメモリの先頭の領域を消費します。圧縮命令の命令数によって消費する領域が変化します。

割込みを使ったデバッグ機能の検証をしました。プログラムのコード中に、ブレークポイントを設定して、そこに、たどり着いた回数を計算して、設定した値(パスカウント)のとき、ブレークさせるみたいな機能が実現できます。具体的には毎サイクル割込みを入れて、アドレスを確認して、設定されたアドレスなら、指定された回数に到達したかをチェック。指定された回数の場合は、LEDを点灯させるというプログラムを作成して、FPGAの実機でテストしました。ちゃんと動いているようです。ただプログラムコード中の一部の命令ではパスカウントを正しく計算できません。遅延分岐で遅延スロットをキャンセルする命令などです。分岐命令の直後の命令にブレークポイントを設定した場合は、パスカウントは正しくありませんという仕様にしようかと考えています。割込み処理中でキャンセル信号をチェックしてもいいのですが、デバッグ機能のためにキャンセル信号をチェックする論理を追加するのは面積最小を追求するプロセッサでは、あまり良くないと考えてのことです。 (面倒とかではなくて)

約400 LUTの面積の小さいCPUで、追加のデバッグモジュールなしにパスカウントを使ったブレークポイントを設定できるのは、良くできるほうなんだろうと思うが、他のCPUの面積とかわからないから、なんとも。