1216t

module top;

wire A, B, C, D, Y1, Y2, Y3, Y4, NY, Y, NA, NB, NC, ND;
system_clock #1600 clock1(A);
system_clock #800 clock2(B);
system_clock #400 clock3(C);
system_clock #200 clock4(D);

nor n1(NA, A, A);
nor n2(NB, B, B);
nor n3(NC, C, C);
nor n4(ND, D, D);
nor o1(Y1, A, B, D);
nor o2(Y2, A, NB, NC);
nor o3(Y3, NA, B, NC);
nor o4(Y4, NC, D);
nor o5(NY, Y1, Y2, Y3, Y4);
nor o6(Y, NY, NY);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>2000)$stop;

endmodule

1202測驗

module top;

wire A, B, C, D, NA, NB, NC, ND, F1, F2, F3, F4, F;
system_clock #800 clock1(A);
system_clock #400 clock2(B);
system_clock #200 clock3(C);
system_clock #100 clock4(D);
nand n1(NA, A, A);
nand n2(NB, B, B);
nand n3(NC, C, C);
nand n4(ND, D, D);
nand a1(F4, A ,NC , ND);
nand a2(F2, NA, NB, D);
nand a3(F3, B, NC, ND);
nand a4(F1, C, D);
nand r1(F, F4, F2, F3, F1);



endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

1202測驗

module top;

wire A, B, C, D, NA, NB, NC, ND, NF, F1, F2, F3, F4, F;
system_clock #800 clock1(A);
system_clock #400 clock2(B);
system_clock #200 clock3(C);
system_clock #100 clock4(D);

nor a1(NA, A, A);
nor a2(NB, B, B);
nor a3(NC, C, C);
nor a4(ND, D, D);
nor r1(F1,NC,ND);
nor r2(F2,A,B,ND);
nor r3(F3,NB,C,D);
nor r4(F4,NA,C,D);
nor r5(NF,F1,F2,F3,F4);
nor r6(F,NF,NF);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

測驗題目

module top;

wire A, B, C, D, NA, NB, NC, ND, F1, F2, F3, F4, F;
system_clock #800 clock1(A);
system_clock #400 clock2(B);
system_clock #200 clock3(C);
system_clock #100 clock4(D);
not n1(NA, A);
not n2(NB, B);
not n3(NC, C);
not n4(ND, D);
and a1(F4, A ,NC , ND);
and a2(F2, NA, NB, D);
and a3(F3, B, NC, ND);
and a4(F1, C, D);
or r1(F, F4, F2, F3, F1);



endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

三位元全加器(行為模式)

module fulladder (c_out, sum, a, b, c_in);
wire s1, c1, c2;
output c_out;
output sum;
input a, b, c_in;

assign{c_out,sum}=a+b+c_in;
endmodule

module adder3( c_out, sum, a,  b, c_in);
wire [2:0] c;
output [2:0] sum;
output c_out;
input [2:0] a;
input [2:0] b;
input c_in;

fulladder fa1(c[1], sum[0], a[0], b[0], c_in) ;
fulladder fa2(c[2], sum[1], a[1], b[1], c[1]) ;
fulladder fa3(c_out, sum[2], a[2],b[2], c[2]) ;


endmodule

module main;
reg [2:0] a;
reg [2:0] b;
wire [2:0] sum;
wire c_out;

adder3 DUT (c_out, sum, a, b, 1'b0);

initial
begin
  a = 3'b111;
  b = 3'b000;
end

always #50 begin
  b=b+1;
  $monitor("%dns monitor: a=%d b=%d sum=%d", $stime, a, b, sum);
end

initial #2000 $finish;

endmodule

三位元全加器(結構模式)

module fulladder (c_out, sum, a, b, c_in);
wire s1, c1, c2;
output c_out;
output sum;

xor g1(s1, a, b);
xor g2(sum, s1, c_in);
and g3(c1, a,b);
and g4(c2, s1, c_in) ;
xor g5(c_out, c2, c1) ;

endmodule

module adder3( c_out, sum, a,  b, c_in);
wire [2:0] c;
output [2:0] sum;
output c_out;
input [2:0] a;
input [2:0] b;
input c_in;

fulladder fa1(c[1], sum[0], a[0], b[0], c_in) ;
fulladder fa2(c[2], sum[1], a[1], b[1], c[1]) ;
fulladder fa3(c_out, sum[2], a[2],b[2], c[2]) ;


endmodule

module main;
reg [2:0] a;
reg [2:0] b;
wire [2:0] sum;
wire c_out;

adder3 DUT (c_out, sum, a, b, 1'b0);

initial
begin
  a = 3'b111;
  b = 3'b000;
end

always #50 begin
  b=b+1;
  $monitor("%dns monitor: a=%d b=%d sum=%d", $stime, a, b, sum);
end

initial #2000 $finish;

endmodule

一位元全加器(行為模式)

module test_adder1;

 reg a,b;
 reg carry_in ;
 wire sum;
 wire carry_out;

 adder1_behavorial A1(carry_out, sum, a, b, carry_in);

 initial
  begin

    carry_in = 0; a = 0; b = 0;
    # 100 if ( carry_in != 0 | sum !== 0)
                $display(" 0+0+0=00 sum is WRONG!");
              else
                $display(" 0+0+0=00 sum is RIGHT!");
    carry_in = 0; a = 0; b = 1;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 0+0+1=01 sum is WRONG!");
              else
               $display(" 0+0+1=01 sum is RIGHT!");
    carry_in = 0; a = 1; b = 0;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 0+1+0=01 sum is WRONG!");
              else
               $display(" 0+1+0=01 sum is RIGHT!");
    carry_in = 0; a = 1; b = 1;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 0+1+1=10 sum is WRONG!");
              else
               $display(" 0+1+1=10 sum is RIGHT!");
    carry_in = 1; a = 0; b = 0;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 1+0+0=01 sum is WRONG!");
              else
               $display(" 1+0+0=01 sum is RIGHT!");
    carry_in = 1; a = 0; b = 1;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 1+0+1=10 sum is WRONG!");
              else
               $display(" 1+0+1=10 sum is RIGHT!");
    carry_in = 1; a = 1; b = 0;
    # 100 if ( carry_in != 0 | sum !== 1)
               $display(" 1+1+0=10 sum is WRONG!");
              else
               $display(" 1+1+0=10 sum is RIGHT!");

    carry_in = 1; a = 1; b = 1;
    # 100 if ( carry_in != 1 | sum !== 1)
               $display(" 1+1+1=11 sum is WRONG!");
              else
               $display(" 1+1+1=11 sum is RIGHT!");
    $finish;
  end
endmodule



module adder1_behavorial (carry_out, sum, a, b, carry_in);
 input a, b, carry_in;
 output carry_out, sum;
  assign sum = (~a&b&~carry_in)|(~carry_in&a&~b)|(a&b&carry_in)|(~a&~b&carry_in);
  assign carry_out = a&carry_in|a&b|b&carry_in;
endmodule

1位元全加器(結構模式)

module top;

wire A, B, CIN, COUT, SUM, A1, A2, A3, A4, X1;
system_clock #400 clock1(A);
system_clock #200 clock2(B);
system_clock #800 clock2(CIN);
and a3(A3, A, CIN);
and a2(A2, CIN, B);
and a1(A1, A, B);
xor x1(X1, A, B);
or a4(A4, A1, A2);
or a5(COUT, A3, A4);
xor x2(SUM, X1, CIN);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

行為模式的二位元多工器

module top;
  integer ia,ib,is,ic,id;
  reg  a,b,s,c,d;
  wire out0,out1;

  mux2_behavioral mux2(out0, out1,a,c,b,d,s);

  initial
    begin
      for (is=0; is<=1; is = is + 1)
        begin
          s = is;
          for (ia=0; ia<=1; ia = ia+1)
            begin
              a = ia;
              for (ib=0; ib<=1; ib = ib + 1)
                begin
                  b = ib;
                 begin
                   for (ic=0; ic<=1; ic = ic+1)
                     begin
                       c = ic;
                       for (id=0; id<=1; id = id + 1)
                         begin
                           d = id;
                             #100 $display("a=%d b=%d c=%d d=%d s=%d   out0=%d out1=%d",a,b,c,d,s,out0,out1);
                           
                           end
                         end
                       end
                     end
                   end
                 end
               end

endmodule


module mux2_behavioral(OUT1, OUT2, A0, A1, B0, B1, SEL);
 output OUT1, OUT2;
 input A0, A1, B0, B1, SEL;
 wire  A0, A1, B0, B1, SEL;
 reg   OUT1, OUT2;
 always @(A1 or B1 or SEL)
  OUT2 = (A1 & SEL)|(B1 & ~SEL );
 always @(A0 or B0 or SEL)
  OUT1 = (A0 & SEL)|(B0 & ~SEL );
endmodule

行為模式的1位元多工器

module top;
  integer ia,ib,is;
  reg  a,b,s;
  wire out;

  mux_behavioral mux1(out,a,b,s);

  initial
    begin
      for (is=0; is<=1; is = is + 1)
        begin
          s = is;
          for (ia=0; ia<=1; ia = ia+1)
            begin
              a = ia;
              for (ib=0; ib<=1; ib = ib + 1)
                begin
                  b = ib;
                 #120 $display("a=%d b=%d s=%d   out=%d",a,b,s,out);
               end
            end
        end
    end
endmodule

module mux_behavioral(OUT, A, B, SEL);
 output OUT;
 input A,B,SEL;
 wire  A,B,SEL;
 reg    OUT;

  always @(A or B or SEL)
   OUT = (A & SEL)|(B & ~SEL );
endmodule

2個1位元多工器組成1個2位元多工器

module top;
wire OUT0, OUT1, A0, A1, B;
wire  SEL;
system_clock #800 clock1(A0);
system_clock #400 clock2(A1);

system_clock #200 clock5(B0);
system_clock #100 clock6(B1);

system_clock #1600 clock9(SEL);

mux m1(OUT0, A0, B0, SEL);
mux m2(OUT1, A1, B1, SEL);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;
initial clk=0;
always
 begin
#(PERIOD/2) clk=~clk;
 end
always@(posedge clk)
 if($time>2000)$stop;
endmodule

module mux(OUT, A, B, SEL);
output OUT;
input A,B,SEL;
not I5 (sel_n, SEL);
and I6 (sel_a, A, SEL);
and I7 (sel_b, sel_n, B);
or I4 (OUT, sel_a, sel_b);
endmodule

2個2位元多工器組成4位元多工器

module top;
wire [3:0]OUT, A, B;
wire  SEL;
system_clock #12800 clock1(A[0]);
system_clock #6400 clock2(A[1]);
system_clock #3200 clock3(A[2]);
system_clock #1600 clock4(A[3]);
system_clock #800 clock5(B[0]);
system_clock #400 clock6(B[1]);
system_clock #200 clock7(B[2]);
system_clock #100 clock8(B[3]);
system_clock #25600 clock9(SEL);

mux2 a1(OUT[1:0], A[1:0], B[1:0],SEL);
mux2 a2(OUT[3:2], A[3:2], B[3:2], SEL);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;
initial clk=0;
always
 begin
#(PERIOD/2) clk=~clk;
 end
always@(posedge clk)
 if($time>30000)$stop;
endmodule

module mux(OUT, A, B, SEL);
output OUT;
input A,B,SEL;
not I5 (sel_n, SEL);
and I6 (sel_a, A, SEL);
and I7 (sel_b, sel_n, B);
or I4 (OUT, sel_a, sel_b);
endmodule

module mux2(OUT, A, B, SEL);
output [1:0] OUT;
input [1:0] A,B;
input SEL;
mux hi (OUT[1], A[1], B[1], SEL);
mux lo (OUT[0], A[0], B[0], SEL);
endmodule

1個2位元多工器與1個1位元多工器組合成3位元多工器

module top;
wire [2:0]OUT, A, B;
wire  SEL;
system_clock #3200 clock1(A[0]);
system_clock #1600 clock2(A[1]);
system_clock #800 clock3(A[2]);
system_clock #400 clock4(B[0]);
system_clock #200 clock5(B[1]);
system_clock #100 clock6(B[2]);
system_clock #6400 clock7(SEL);

mux a1(OUT[0], A[0], B[0],SEL);
mux2 a2(OUT[2:1], A[2:1], B[2:1], SEL);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;
initial clk=0;
always
 begin
#(PERIOD/2) clk=~clk;
 end
always@(posedge clk)
 if($time>7000)$stop;
endmodule

module mux(OUT, A, B, SEL);
output OUT;
input A,B,SEL;
not I5 (sel_n, SEL);
and I6 (sel_a, A, SEL);
and I7 (sel_b, sel_n, B);
or I4 (OUT, sel_a, sel_b);
endmodule

module mux2(OUT, A, B, SEL);
output [1:0] OUT;
input [1:0] A,B;
input SEL;
mux hi (OUT[1], A[1], B[1], SEL);
mux lo (OUT[0], A[0], B[0], SEL);
endmodule

3位元多工器(2)

module top;

wire A0, A1, A2, B0, B1, B2, SEL, OUT1, OUT2, OUT3;
system_clock #200 clock1(A0);
system_clock #100 clock2(B0);
system_clock #800 clock1(A1);
system_clock #400 clock2(B1);
system_clock #3200 clock2(A2);
system_clock #1600 clock2(B2);
system_clock #6400 clock1(SEL);
mux m1 (OUT1, A0, B0, SEL);
mux m2 (OUT2, A1, B1, SEL);
mux m3 (OUT3, A2, B2, SEL);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>7000)$stop;

endmodule

module mux(OUT, A, B, SEL);
output OUT;
input A,B,SEL;
not I5 (sel_n, SEL);
and I6 (sel_a, A, SEL);
and I7 (sel_b, sel_n, B);
or I4 (OUT, sel_a, sel_b);
endmodule

3位元多工器

module top;

wire A0, A1, A2, B0, B1, B2, NSEL, SEL, OUT1, OUT2, OUT3, OUT4, OUT5, OUT6, OUT7, OUT8, OUT9;
system_clock #200 clock1(A0);
system_clock #100 clock2(B0);
system_clock #800 clock1(A1);
system_clock #400 clock2(B1);
system_clock #3200 clock2(A2);
system_clock #1600 clock2(B2);
system_clock #6400 clock1(SEL);
not b1(NSEL, SEL);
and a1(OUT1, A1, SEL);
and a2(OUT2, B1, NSEL);
or a5(OUT6, OUT1, OUT2);

and a3(OUT3, A0, SEL);
and a7(OUT7, A2, SEL);

and a4(OUT4, B0, NSEL);
and a8(OUT8, B2, NSEL);

or a6(OUT5, OUT3, OUT4);
or a6(OUT9, OUT7, OUT8);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>7000)$stop;

endmodule

2位元多工器

module top;

wire A0, A1, B0, B1, NSEL, SEL, OUT1, OUT2, OUT3, OUT4, OUT5,OUT6;
system_clock #200 clock1(A0);
system_clock #100 clock2(B0);
system_clock #200 clock1(A1);
system_clock #100 clock2(B1);
system_clock #400 clock1(SEL);




and a1(OUT1, A1, SEL);
and a3(OUT3, A0, SEL);
not b1(NSEL, SEL);

and a2(OUT2, B1, NSEL);
and a4(OUT4, B0, NSEL);
or a5(OUT5, OUT1, OUT2);
or a6(OUT6, OUT3, OUT4);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

4對1多工器

module top;

wire A0, A1, B0, B1, NSEL, SEL, OUT1, OUT2, OUT3, OUT4, OUT5,OUT6,OUT7,OUT8,OUT9,S2,NS2;
system_clock #200 clock1(A0);
system_clock #100 clock2(B0);
system_clock #200 clock1(A1);
system_clock #100 clock2(B1);
system_clock #400 clock1(SEL);
system_clock #800 clock1(S2);



and a1(OUT1, A1, SEL);
and a3(OUT3, A0, SEL);
not b1(NSEL, SEL);
not b2(NS2, S2);
and a2(OUT2, B1, NSEL);
and a4(OUT4, B0, NSEL);
or a5(OUT5, OUT1, OUT2);
or a6(OUT6, OUT3, OUT4);
and a7(OUT7, OUT5, S2);
and a8(OUT8, OUT6, NS2);
or a9(OUT9, OUT7, OUT8);
endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>2000)$stop;

endmodule

多工器

多工器

10/07 作業

這次比較複雜
module top;

wire A, B, C, D, E, OUT1, OUT2, OUT3, OUT4, OUT5;
system_clock #1600 clock1(A);
system_clock #800 clock2(B);
system_clock #400 clock2(C);
system_clock #200 clock2(D);
system_clock #100 clock2(E);

not a1(OUT1, A);
and a2(OUT2, OUT1, B);
nor a3(OUT3, C, D);
and a4(OUT4, OUT3, E);
or a5(OUT5, OUT2, OUT4);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>3200)$stop;

endmodule

小小改變2

經過今天的學習，我覺得Verilog是很有趣的，隨著漸漸搞懂它，我漸漸喜歡上她了。
module top;

wire A, B, C, D, OUT1, OUT2, OUT3;
system_clock #800 clock1(A);
system_clock #400 clock2(B);
system_clock #200 clock3(C);
system_clock #100 clock4(D);

and a1(OUT1, A, B);
and a2(OUT2, C, D);
or  a3(OUT3, OUT1, OUT2);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

and-or

稍微改一下
module top;

wire A, B, C, OUT1, OUT2;
system_clock #400 clock1(A);
system_clock #200 clock2(B);
system_clock #100 clock3(C);

and a1(OUT1, A, B);
or a2(OUT2, OUT1, C);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

3輸入AND

開始有一點點理解
module top;

wire A, B, C, OUT1, OUT2;
system_clock #400 clock1(A);
system_clock #200 clock2(B);
system_clock #100 clock3(C);

and a1(OUT1, A, B);
and a2(OUT2, OUT1, C);

endmodule

module system_clock(clk);
parameter PERIOD=100;
output clk;
reg clk;

initial clk=0;

always
 begin
#(PERIOD/2) clk=~clk;
 end

always@(posedge clk)
 if($time>1000)$stop;

endmodule

And邏輯閘

arm intel

華碩低價位帶手機ZenFone一推出就掀起市場話題，除台灣訂價與規格在中國發表之後掀起一陣波濤，許多人也對ZenFone所採用的Intel Atom處理器有所意見，深怕其相容性問題無法正確執行應用程式App，這究竟是怎麼回事呢？

Intel近幾年一直很想進軍手機或是平板的行動市場，特別是採用Android作業系統這一塊大餅（忘了MeeGo吧！），所採取的戰術便是盡量降低Atom系列處理器的功耗，使其符合手機長時間待機的要求，實際使用第一世代的產品即為Atom Z24x0系列，而Asus ZenFone則是採用第二世代的產品，Atom Z25x0系列。相較於前代，Z25x0變成雙核心四執行緒，GPU的部分則是從PowerVR SGX540大幅升級至PowerVR SGX544MP2。

ARM在手機上奠定基礎

Android起初發展之際，並沒有限定在何種平台上執行，只不過在當時的時空環境背景因素下，第一台市售Android手機HTC Dream（G1）採用了Qualcomm MSM7201A，這是款ARMv6指令集的產品。

之後的情形大家都曉得了，ARM開始如日中天，絕大部分Android手機皆採用相容ARM指令集的應用處理器（少數為MIPS指令集），Apple的iPhone和iPad系列產品更是全程採用。在這後PC時代，Intel於行動裝置市場的影響力實在不大，過去還有XScale這個產品線可在PDA上佔有一席之地，甚至它的高效能吸引了不少人指定購買，但之後Intel把XScale賣給了Marvell，也就沒有適合手機使用的處理器了。

Atom被抓來打ARM

在2011年9月時，Intel和Google共同發表聲明，兩者將一同最佳化未來Android版本在x86系統上的表現；也就是說，原本用在netbook和UMPC上的Atom處理器，現在也要進軍手機市場了。

不過針對半路殺出的Intel x86架構，市場上已經有許多應用程式針對ARM最佳化，若是像採用MIPS架構的Android裝置一樣，程式相容性不佳的話，大概也就能直接判斷Atom出師未捷身先死，所以Intel製作了Binary Translation這個中介轉譯層，用以相容ARM最佳化的程式。

▲如果Android程式以Java寫成並丟入Dalvik虛擬機執行，在使用Intel Atom的Android手機中執行絕大部分沒有問題。

x86架構如何相容ARM程式

要了解Binary Translation的原理，首先要了解Android程式是如何運作的。起先Android程式皆使用Eclipse開發環境和Android SDK，以Java語言寫成，經過封裝轉換成Bytecode後丟入Android裝置中，1個稱為Dalvik的虛擬機器中執行。

不過稍微了解程式運作的人都知道，虛擬機雖然能夠帶來跨平台、不限硬體規格執行的好處，但同時也會因為虛擬機器的轉換，降低執行效率。因此後來Andriod除了SDK（Software Development Kit）以外，也推出NDK（Native Development Kit），讓開發人員能夠繞過Dalvik轉譯造成的效能損失，同時又能夠使用Java以外的程式語言撰寫（如C/C++）。

由於程式經過NDK轉譯之後，出來的東西是硬體能夠直接執行的機器碼，執行效率較高，但同時帶來了相容性的問題－－編譯給ARM處理器的機器碼一定跟編譯給x86處理器的不一樣，這就導致Intel的Atom處理器無法正常執行部分程式（通常是3D遊戲，因為這些程式對於效能要求較高）。如果Intel放棄掉這些程式，想必消費者絕對無法接受，於是便有了Binary Translation這個中介轉譯層，可把ARM的機器碼轉給x86執行。

▲Intel Binary Translator用來轉換那些使用ARM NDK的應用程式，讓他們能夠在Intel Atom上正確執行。

ARM本身也有相容性問題

有了Binary Translation的關係，所以Intel Atom能夠執行已對ARM處理器編譯的程式，但是效能會比在ARM處理器執行時略為下降，同時此Binary Translation也並非100％完全相容，偶爾也會有無法執行或是執行到一半跳出的情況。

但也別以為ARM本身不會出現相容性問題，因為ARM採用授權方式，因此各家處理器的GPU部分並不相同，例如Qualcomm使用自家的Adreno、NVIDIA使用GeForce ULP、Samsung使用ARM的Mali或是PowerVR的SGX，由於GPU對於規格的支援度不同（如材質壓縮格式），導致各方也必須為不同的應用處理器推出不同的版本，這現象在3D遊戲中特別嚴重。

開發商態度才是關鍵

目前Android市場上還是以ARM處理器的手機為大宗，如果開發商無力支援各平台，當然會以市占最大的裝置作為考量，以便在最小成本中謀取最大利益，有而外的經費才去針對不同的硬體調整程式碼。

但相較於應用程式相容性，小編其實比較在意Intel Atom的續航力，目前市面上採用Intel Atom的手機都還在Z24x0和Z25x0的規格，就筆者的測試經驗來說，續航力普遍都比採用ARM處理器的手機短。

來源網站：http://www.techbang.com/posts/17981-come-on-guys-secrets-of-the-x86-processor-arm-compatible-applications

verilog

發展歷史

Verilogs是由Gateway設計自動化公司的工程師於1983年末創立的。當時Gateway設計自動化公司還叫做自動集成設計系統（Automated Integrated Design Systems），1985年公司將名字改成了前者。該公司的菲爾·莫比（Phil Moorby）完成了Verilog的主要設計工作。1990年，Gateway設計自動化被Cadence公司收購。

1990年代初，開放Verilog國際（Open Verilog International, OVI）組織（即現在的Accellera）成立，Verilog面向公有領域開放。1992年，該組織尋求將Verilog納入電氣電子工程師學會標準 。最終，Verilog成為了電氣電子工程師學會1364-1995標準，即通常所說的Verilog-95。

設計人員在使用這個版本的Verilog的過程中發現了一些可改進之處。為了解決用戶在使用此版本Verilog過程中反映的問題，Verilog進行了修正和擴展，這部分內容後來再次被提交給電氣電子工程師學會。這個擴展後的版本後來成為了電氣電子工程師學會1364-2001標準，即通常所說的Verilog-2001。Verilog-2001是對Verilog-95的一個重大改進版本，它具備一些新的實用功能，例如敏感列表、多維數組、生成語句塊、命名埠連接等。目前，Verilog-2001是Verilog的最主流版本，被大多數商業電子設計自動化軟體包支持。

2005年，Verilog再次進行了更新，即電氣電子工程師學會1364-2005標準。該版本只是對上一版本的細微修正。這個版本還包括了一個相對獨立的新部分，即Verilog-AMS。這個擴展使得傳統的Verilog可以對集成的類比和混合訊號系統進行建模。容易與電氣電子工程師學會1364-2005標準混淆的是加強硬體驗證語言特性的SystemVerilog（電氣電子工程師學會1800-2005標準），它是Verilog-2005的一個超集，它是硬體描述語言、硬體驗證語言（針對驗證的需求，特別加強了物件導向特性）的一個集成。

2009年，IEEE 1364-2005和IEEE 1800-2005兩個部分合併為IEEE 1800-2009，成為了一個新的、統一的SystemVerilog硬體描述驗證語言（hardware description and verification language, HDVL）。

語言要素

Verilog的設計初衷是成為一種基本語法與C語言相近的硬體描述語言。這是因為C語言在Verilog設計之初，已經在許多領域得到廣泛應用，C語言的許多語言要素已經被許多人習慣。一種與C語言相似的硬體描述語言，可以讓電路設計人員更容易學習和接受。不過，Verilog與C語言還是存在許多差別。另外，作為一種與普通計算機程式語言不同的硬體描述語言，它還具有一些獨特的語言要素，例如向量形式的線網和暫存器、過程中的非阻塞賦值等。總的來說，具備C語言的設計人員將能夠很快掌握Verilog硬體描述語言。

與VHDL的比較

Verilog硬體描述語言（Verilog Hardware Description Language）的英語縮寫Verilog HDL和另一種類似的硬體描述語言VHDL在名稱上容易混淆，實際上二者是兩種不同的硬體描述語言。一些高級的電子設計自動化工具支持用戶在項目內同時使用Verilog和VHDL來進行硬體設計。

VHDL是由美國國防部主持研發的硬體描述語言，成為了第一個成為電氣電子工程師學會標準的硬體描述語言，美國政府相關的項目都是基於VHDL；而Verilog由民間商業公司的私有產品發展為IEEE標準的，因此在商用領域的市場占有量更大，設計人員和支持資源比VHDL更廣。在美國大約有10萬設計人員、200所大學教授採用Verilog硬體描述語言。

Verilog和VHDL作為業界廣泛認可、同為電氣電子工程師學會標準的硬體描述語言，有著各自的特點。VHDL的設計之初就更加針對標準化進行設計，Verilog則具有簡明、高效的代碼風格。兩種語言都能夠在多個抽象層次對數位電路建模，並且可以與驗證、仿真、綜合工具協同工作。其中，Verilog的邏輯閘級、電晶體級級電路描述能力更強，VHDL不具備這樣低級的描述能力，但是另一方面，VHDL的系統級抽象描述能力則比Verilog強。另外，由於Verilog與C語言在語法上有相似之處，因此具有C語言基礎的設計人員更容易掌握它，而VHDL設計人員需要具有Ada語言編程基礎，並且學習周期比Verilog更長。相關學術文獻顯示，在美國的高級數位系統設計領域，Verilog和VHDL的使用比率大約分別為80%和20%，這項比率在日本和台灣地區和美國相似。隨著Verilog-A被合併到Verilog標準之中，而該部分後來成為了Verilog-AMS的一部分，該語言增加了對類比電子系統的描述能力，因此它在混合訊號積體電路中有著更廣泛的應用。

數位IC設計能力鑑定資訊

■ 證照重要性與舉辦目的：

    (1)考生具備熟悉數位電路邏輯設計之各種輔助工具與設計流程(包含Verilog coding, logic synthesis, simulation, DFT, FEC, STA, cell library…等等)。

    (2)考生具備Verilog硬體描述語言設計IC能力。

    (3)鑑定成績可提供各校參考做為未來學生畢業之條件。

    (4)鑑定成績可提供未來學生入學面試及工作面試的能力依據。

    (5)鑑定及格之考生可證明自己在數位IC設計上擁有基本的知識與專業能力。

 

■ 報考資格：

    (1)大專以上在學學生

    (2)業界人士（已經或想要從事設計相關產業之工程師）

 ■ 測驗內容：(詳細內容依簡章公告為主)

科目	鑑定內容
學科筆試	以數位電路邏輯設計概念(包含大專院校教科書之Digital System, Logic Design, Logic Synthesis and Verification, VLSI Testing…等)、Verilog語法以及數位IC設計EDA工具流程為主；內容包含:  1. Logic design  2. Verilog coding  3. Logic Synthesis  4. Logic Verification  5.Testing  6.Power & Timing Analysis
術科實作	由主辦單位提供指定題目、設計規格、設計方塊圖及相對應之測試向量，考生在考試時間內利用標準元件數位電路設計方式完成符合規格之晶片設計。 術科實作評分之4個主要項目為： (A)Verilog coding須符合題目所要求之功能規格 (B)Verilog coding須通過主辦單位所提供之nLint rule檢查 (C)邏輯合成後之gate-level simulation驗證完全無誤 (D)電路合成軟體時序分析驗證須符合題目所要求之規格

 CIC 針對含有數位與類比的混合訊號 IC 提 出 一個混合 訊號設計流程 (Mixed-signal Design Flow)。本流程包含混合訊號 IC 設計前段 (Front End) 到後 段 (Back End) 的實現及驗證方法。驗證的目的是確保各個實現階段結果的正確 性，項目包括有 Function、Timing、Power、DRC 等，越到實體階段所須驗證的 項目就越多。 設計者於系統分析分離出數位部分與類比部份之後，混合訊號 IC 的設計流程分 成 5 大部分：

 1. 數位電路部份的設計流程(Cell-based)

 2. 類比電路部分的設計流程(Full-custom) 

3. 數位/類比電路混合模擬 (Co-simulation) 

4. 數位/類比 Layout 整合與驗證 

5. 晶片下線及量測 

邏輯綜合

概念簡介

設計人員編寫的Verilog代碼通常是在較高抽象級別的，例如暫存器傳輸級。這一抽象級別包含了對電路訊號在暫存器之間傳輸情況的描述。但是邏輯閘級的網表，即邏輯閘的相互連接形式，才最接近真實的硬體電路。這一形式與暫存器傳輸級的描述，在功能上是等效的。為了給後續硬體製造人員提供這種低抽象級別的描述，需要將高抽象級別的Verilog代碼轉換為低抽象級別的邏輯閘級網表。這一過程稱為邏輯綜合（Logic Synthesis）。

在自動化邏輯綜合工具出現之前，儘管人們可以用硬體描述語言進行設計，但是還是需要人工進行邏輯綜合。例如，如果電路模塊只有少數幾個輸入端，我們可以使用類似卡諾圖的方法來對邏輯函數進行化簡。隨著電路規模不斷增加，人工邏輯綜合的容易出錯、耗費大量時間的缺點逐漸凸顯。同時，在某種特殊器件製程下最優化的綜合結果不一定在另一種製程下還合適，如果需要採用另外的製程，設計人員需要花費很長時間重新進行邏輯綜合。隨著自動化邏輯綜合工具的出現，硬體描述語言、所需器件製程信息（製程庫）可以直接被邏輯綜合工具讀取，通過其內部的自動綜合算法，輸出符合設計約束（通常包括時序、功耗、面積的約束）的邏輯閘級網表。藉助自動綜合工具，設計人員可以將更多的精力放在高抽象級別的硬體描述語言設計。

參考網頁：https://zh.wikipedia.org/wiki/Verilog

                 http://ebs.cic.org.tw/ics/info/icdigital.action

                 http://www.cic.narl.org.tw/techpaper/pdf/CIC-DSD-RD-08-02.pdf