���١������쥯�����μ���ˡ��ɾ��

�ͥåȥ�������ƥฦ�漼
��Ƴ���� : ���� ľ�� �ڶ���
04KC009 : ���� �

�ܼ�


1.�Ϥ����

�ץ�����ߥ󥰸���Ȥϥ����ƥಽ�����о�ʪ����ݲ���������ԥ塼���ǽ�����ǽ�ʥ����ɤ򵭽Ҥ��뤿����Ѥ���͹�����Ǥ��롣�ץ�����ߥ󥰸���ϥ���ԥ塼���ε�����Ȱ��а���б����ä�������֥餫��Ϥޤꡢ����ѥ�����Ѥ��Ƶ�������������뤳�Ȥ�����Ȥ�������ѥ�����졢���󥿥ץ꥿�ȸƤФ��ץ�����ब�����������ɤ��ᤷ�¹Ԥ��륹����ץȸ���ȡ����ҤǤ�������٤���������ؤȿʲ����Ƥ�����

�ץ�����ߥ󥰸���Ϥ���¸����ͳ���顢�������٤ι⤤���Ҥ��Ԥ��뤳�ȡ����Ф䤤��ȯ��Ԥ�����������롣����٤ι⤤���ҤȤϡ��ץ�����ब�ɤ�����������Ԥ���(HOW)�ǤϤʤ����ν�����Ԥ���(WHAT)�򵭽Ҥ��䤹����ʸ����ǽ����äƤ��뤳�Ȥ򡢤��Ф䤤��ȯ�Ȥϵ������ι⤵�������ɤ�̩�٤ι⤵���Х���ȯ�����ˤ�����ʸ����ǽ����äƤ��뤳�Ȥ򤵤���

��������٤ι⤤���ҡ����Ф䤤��ȯ��Ԥ�˸���ˤʤ�Τ������ΰ�δ����Ǥ��롣�����ΰ��ưŪ���ݤ�Ԥ����ʤɡ�����ԥ塼������ݲ�����Ƥ��ʤ���ʬ��ľ�ܥץ�����ޤ�����ɬ�פ������롣�����ΰ�������ΰ��������������������˺��ˤ�����꡼���ʤɤΥХ��Ⱦ���٤��碌�Ǥ��롣��������Ϥι�ʸ�ڤʤɡ�ʣ���ʻ��Ȥ��Ԥ��Ƥ���ǡ�����¤�ǤϤȤ��˵����ΰ�γ���������Ȥʤ롣

������������褹�뤿��ε��������١������쥯�����Ǥ��롣���١������쥯�����ϵ����ΰ��ưŪ���ݡ���������ݲ������ץ�����ޤ�����Ū�˴�����Ԥ�ɬ�פ򸺤餹���ܸ���Ǥϡ����١������쥯������LISP�Ȥ����ץ�����ߥ󥰸�������Ϥ˼������뤳�Ȥˤ�ꡢ������ˡ�ʤɤθ�Ƥ��Ԥä���

2.���١������쥯�����

���١������쥯������GC��ά���ˤϥץ�����ߥ󥰸�������ϡʰʲ���������ϡˤΰ����⤷���ϥ饤�֥��Ȥ����󶡤���롢ưŪ�˳��ݤ��������ΰ�Τ������Ѥ���Ƥ��ʤ������ΰ��ưŪ�˲�����������Ѥޤ��ϳ�����Ԥ������Ǥ��롣

GC��Ƴ�����뤳�Ȥˤ��ץ�����ޤϼ�ư�Ǥε����ΰ�δ������鳫������롣

2.1.���١������쥯������ɬ����

GC�϶�ǯ�θ�������ϤǤ�ɬ�ܤε�ǽ�Ȥ����󶡤���Ƥ��뤬�������װ��Ȥ��Ƥϡ�

�ʤɤ��ͤ����롣

2.1.1.�� : �㳰

�㳰�Ȥϥץ������¹���ˤ��������Թ��������뤿���ʬ���Ǥ��롣���Թ���н褵���Ȥν��������Ф褤�����ե���������ʤɤλ񸻳��ݤμ��Ԥʤɼ���֤��ΤĤ��ʤ����Թ���Ф��ƤϽ����η�³�򤢤����ʤ���Фʤ�ʤ������ξ�硢����ޤǤν����dz��ݤ����񸻤γ���������Ȥʤ롣

�����Ǥ�GC��¸�ߤ��㳰�����Ѥ����ץ�����ߥ󥰤ˤɤΤ褦�ʱƶ���Ϳ���뤫��Ҥ٤롣�ץ���������Ȥ���C++��Java�򤢤����㳰�����Ѥ����ץ������Ȥ��ƥ��󥹥ȥ饯�����㳰��ȯ�������륯�饹��������롣

2.1.1.1.C++

Figure 1.��Figure 2.�ϥե������������륯�饹�����Ѥ����ץ������Ǥ��롣

C++��ɸ��饤�֥��Ͻ������Ǥ��㳰��ȯ�������뤳�Ȥ�̵�����ᡢ�̾���㳰��ȯ�������ʤ�Figure 1.�Τ褦�ʥץ�����ߥ󥰥������뤬��ή�Ǥ��뤬�������Ǥ�Figure 2.�Τ褦�˰տ�Ū���㳰��ȯ������Ĥ��Ƥ��롣Figure 2.�����Ƥ��㳰����ª���ƥ��󥹥ȥ饯�������㳰��ϳ��ʤ��褦���Ҥ��Ƥ��롣

C++�Ǥϥ��󥹥ȥ饯�����㳰��ȯ�����ƽ��������Ǥ��Ƥ��ޤä����˥ǥ��ȥ饯�����ƤӽФ���ʤ��Ȥ���ͭ̾�ʥХ���¸�ߤ��롣�ޤ����ǥ��ȥ饯�����㳰��ȯ��������硢�㳰���饹������㳰��ȯ���������Ƹ����񤷤��Х��ˤʤ롣�㳰���饹������㳰��ȯ��������ɽŪ����Ȥ��Ƥϡ�bad_alloc�㳰��ȯ�����������ǡ��㳰���֥������Ȥ�������뤿���new��Ȥ�������bad_alloc��ȯ����������ʤɤ����롣�����ΥХ���ȯ�����뤳�Ȥ��񤷤���

���Τ��ᡢ���󥹥ȥ饯�����ǥ��ȥ饯���ν������㳰�ˤ�����Ǥ��뤳�Ȥϵ�����ʤ����ĤޤꡢC++�Ǥ��㳰����(�㳰��ȯ�����Ƥ���������Ǥ���ʤ�����)�ʥ��󥹥ȥ饯�������饹��������뤳�Ȥ������ʥץ��������������ɬ�׾��Ǥ��롣�����Τ��Ȥ��顢C++���㳰�Ȥ��������������줿��������㳰�����Ѥ��뤿��λ񸻴�����ץ�����ޤ˶�����褦�ˤʤäƤ��ޤä�����

�����ϻ񸻴�����ץ�����ޤ��Ԥ�ɬ�פ��������롣GC��¸�ߤ���Ф��Τ褦�˻񸻤β����ˤĤ������դ�����륳���Ȥ��ڸ�����롣

#include <iostream>
#include <fstream>
#include <string>

class file_io {
private:
    std::ifstream *ifs_;
    std::ofstream *ofs_;
    bool is_fail_;
public:
    file_io() : is_fail_(false), ifs_(NULL), ofs_(NULL) {}
    file_io(std::string input_file, std::string output_file)
        : is_fail_(false) , ifs_(NULL), ofs_(NULL)
    {
        ifs_ = new std::ifstream();
        ofs_ = new std::ofstream();
        if (ifs_ == NULL || ofs_ == NULL) {
            is_fail_ = true;
            return ;
        }
        ifs_->open(input_file.c_str());
        ofs_->open(output_file.c_str());
        if (ifs_->fail() || ofs_->fail()) {
            is_fail_ = true;
        }
    }
    ~file_io() { delete ifs_; delete ofs_; }
    bool fail() { return is_fail_; }
    /* and more definitions ... */
};
int main(int argc, char **argv) {
    if (argc < 3) { return -1; }
    file_io fio = file_io(argv[1], argv[2]);
    std::cout << fio.fail() << std::endl;
}
Figure 1. WithoutExceptionWithoutGC.cpp
#include <iostream>
#include <fstream>
#include <string>
#include <new> // new �黻�Ҥ��㳰ȯ������Ĥ���

class file_io {
private:
    std::ifstream *ifs_;
    std::ofstream *ofs_;
    bool is_fail_;
public:
    file_io() : is_fail_(false), ifs_(NULL), ofs_(NULL) {}
    file_io(std::string input_file, std::string output_file)
        : is_fail_(false) , ifs_(NULL), ofs_(NULL)
    {
        try {
            ifs_ = new std::ifstream();
            ofs_ = new std::ofstream();
        } catch (std::bad_alloc) {
            is_fail_ = true;
            return ;
        }
        // �㳰����Ĥ���
        ifs_->exceptions(std::ios_base::failbit);
        ofs_->exceptions(std::ios_base::failbit);
        try {
            ifs_->open(input_file.c_str());
            ofs_->open(output_file.c_str());
        } catch (std::ios_base::failure) {
            is_fail_ = true;
        }
    }
    ~file_io() { delete ifs_; delete ofs_; }
    bool fail() { return is_fail_; }
    /* and more definitions ... */
};
int main(int argc, char **argv) {
    if (argc < 3) { return -1; }
    file_io fio = file_io(argv[1], argv[2]);
    std::cout << fio.fail() << std::endl;
}
Figure 2. WithExceptionWithoutGC.cpp
2.1.1.2.Java

Figure 3.��Java�Ǥ���Ǥ��롣���Υץ������Ǥ�FileIO���饹�Υ��֥������Ȥ�����Ȥ��˥��󥹥ȥ饯�����ƤФ�롣���󥹥ȥ饯���ϥե�����̾������˼�ꡢFileInputStream��������롣�ե����뤬¸�ߤ��ʤ����ˤ�java.io.FileNotFoundException��ȯ�����롣Java�Ǥϥ��󥹥ȥ饯����Ǥ��㳰�θƤӽФ�������Ƥ�ǥ��ȥ饯���Ժߤˤ褦����꡼����GC��¸�ߤ��뤿��ȯ�����ʤ���

import java.io.*;

class FileIO {
    FileInputStream fis;
    FileOutputStream fos;
    FileIO(String input, String output)
        throws Exception
    {
        fis = new FileInputStream(input);
        fos = new FileOutputStream(output)
    }  
}
class ExceptionWithGC {
    static public void main(String[] args) {
        try {
            FileIO fio = new FileIO(args[0], args[1]);
        } catch (Exception e) {
            System.out.println("Exception occurred");
            System.out.println(e);
        }
    }
}
Figure 3. ExceptionWithGC.java

2.1.2.�� : �ץ�����ߥ󥰥�������

ʸ����γ�ĥ�����󤲤롣Java�Ǥ�ʸ����γ�ĥ��C�Ǥγ�ĥ����򼨤���

2.1.2.1.C

Figure 4.��ɸ�����Ϥ�����ʸ������ɤ߹���ץ������Ǥ��롣

���Υץ������ϰ�ʸ���ɤ߹������Хåե����ĥ���ơ���ʸ���ɲä��Ƥ��������Ԥ⤷����EOF��ã�����顢�Хåե�����strdup��ʸ�����ʣ����������ʣ������ʸ������֤��Ƥ��롣

C�Υץ������Ǥ�ʸ����ؤ�ʸ�����ɲäȵ����ΰ�δ�����ʬΥ�Ǥ����ˡ�����ΰ�̣������Ƥ��ޤäƤ��롣

#include <stdio.h>
#include <stdlib.h>
/* read line */
char *freadline(FILE* in)
{
  char *buffer, *tmp;
  int c;

  buffer = malloc(1);
  if (buffer == NULL) goto END;
  buffer[0] = ��\0��;

  while ((c = fgetchar(in)) != EOF) {
    tmp = realloc(buffer, strlen(buffer) + 2);
    if (tmp == NULL) break;
    buffer = tmp;
    tmp = tmp + strlen(buffer);
    *tmp++  = c;
    *tmp = ��\0��;
    if (c == ��\n��) break;
  }
END:
  return buffer;
}

int main(void)
{
  char * line = readline(stdin);
  printf(��%s��, line);
  free(line);
}
Figure 4. readline.c
2.1.2.2.Java

Figure 5.��Figure 4.��Java�ǽ�ľ�����ץ������Ǥ��롣

��ʸ���ɤ߹��ऴ�Ȥ˲��Ѥ�ʸ�����ʸ�����ɲä��Ƥ��������ʬ�ɤ߹���������Ĺʸ���󤫤�ʸ������Ѵ���Ԥäơ�ʸ������֤��Ƥ��롣���Υץ������Υ���������ϥ��������ԤäƤ�����ʬ�ϱ��ä��졢���ˤ狼��䤹�������������ɤȤʤäƤ��롣

class ReadLine {
  static public String readline(InputStream is) {
    StringBuilder sb = new StringBuilder();
    int ch = 0;
    while((ch = is.read()) != -1 || ch == '\n') {
      sb.appned((char)ch);
    }
    return sb.toString();
  }
  static public void main(String [] args) {
    Stirng line = ReadLine.readline(System.in);
    System.out.println(line);
  }
}
Figure 5. ReadLine.java

������Ǥϥץ������ε���������������������֤��Ƥ��롣�ºݤΥץ�����೫ȯ�Ǥϥץ��������ݼ顢��ĥ�ʳ��Ǥ�����Ĥ����Ǥ��礤�˱ƶ����Ƥ��롣�ݼ��Ԥ��ˤ��ݼ餹��ץ�����������ɬ�פȤʤ롣Figure 5.�Τ褦�˵����ΰ�δ��������ä���Ƥ���ȡ�����Υץ������ΰ�̣�����򤷤䤹���ʤ롣

������Ĥ���ΤȤ��ꡢGC�����Ѥ��뤳�Ȥˤ��ץ�����ߥ󥰤μ�֤������˾ʤ��졢GC�Τʤ���������ϤǤϹԤ��ˤ�������Ū�ν������������ܤ����ץ�����ߥ󥰤����ѤǤ���褦�ˤʤ롣

�ޤ������������GC�˰�Ǥ���뤳�Ȥˤ�ꡢʸ�������ʤɤ������䤹���ץ�����ޤΥߥ��ˤ�������ΰ�ؤΥ�����������������ΰ�γ������ΰ����ų���������꡼����ڸ��Ǥ��뤳�Ȥ�Ǥ��롣������ˤ�ꡢ��������ѥ����ɤ�ɬ�פʤ��ʤ뤳�Ȥˤ�륽���������ɤδʷ餵�θ��塢�����Ϣ�ΥǥХå��Υ����Ȥηڸ��ʤɳ�ȯ��Ψ�θ��夬�����롣

2.2.���١������쥯������®��

����Ū��malloc/free�����Ѥ�����ư�ǤΥ�����������GC����������®�٤��٤��ȹͤ���줬����������ϴְ㤤�Ǥ��롣���곫���Υ����Ȥ��Ѳ�����ΤǤϤʤ�����ư�ǥ��������Ԥ������Ȥ�ʬ�����뤫��GC�����Ѥ��ƽ��椷�ƹԤ����κ��Ǥ��롣�������äơ�®�٤Τ褷������ʬ��������ˤ����åȤ���Ӥ�������˰�¸���롣

����Ȥ��̤ˡ�����ξ�ﲼ�Ǥ�GC��malloc/free�ȤǤ�®�٤κ��������˸�����㤬���롣

GC��®�٤��Ǥ���Ȥ��Ƥ�malloc/free�μ����˼��Ԥ��Ƥ��Ƥ����礬���롣�̾�GC�Ǥϵ���ʵ����ΰ����ݤ��Ƥ����ΰ�Τ���ɬ�פ��ΰ��GC���ڤ���ꤷ�ƴ�����Ԥ������Τ���malloc/free�μ����˺������줺�������ǽ���������ǽ�����⤤��

malloc/free���ᤤ��Ȥ��Ƥϡ����̤ε����ΰ�����Ѥ�������ˤ��ε����ΰ�ΤۤȤ�ɤ����Ѥ������Ǥ��롣���ξ�硢GC��ȯ�������٤����̤ε����ΰ���������ʤ���Фʤ�ʤ������ξ�硢malloc/free��ɬ�פʤ��ΰ��������������ˡ��®�٤������롣

���Τ褦�ˡ����򤽤�����к��������뤬�������Ȥ������̤�Ϥ��������ˤ��뤿�ᡢ�������줿�����ǤϺ��������ʤ��ȹͤ��뤳�Ȥ��Ǥ��롣

2.3.GC�Υ��르�ꥺ��

GC�δ���Ū�ʥ��르�ꥺ����礭��ʬ������Ĥ�ʬ�����롣

2.3.1.���ȥ������

���ȥ������(Reference counting)�ϥ��֥������ȡ�ưŪ�˳��ݤ��������ΰ��ñ�̡ˤ����Ȥ���Ƥ�����򸵤��ΰ�γ�����Ԥ�GC�Ǥ��롣���ƤΥ��֥������Ȥ��Ф��ƻ��ȥ�����ȤȸƤФ�������ͤ��ղä��롣���ȥ�����Ȥϥץ���������Τˤ��Υ��֥������Ȥ�ؤ������ݥ��󥿤�������¸�ߤ��뤫��Ͽ�����Τǡ��ѿ��������ʤɤˤ�ä��Ѳ����롣�����ơ����λ��ȥ�����Ȥ�0�ˤʤä���硢�Ĥޤꡢ�ɤ�����⻲�Ȥ���ʤ��ʤä����ˤ��Υ��֥������Ȥ�������Ȥ�����ΤǤ��롣

»²¾È¥«¥¦¥ó¥È
Figure 6. ���ȥ������

���ȥ�����Ȥ������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣

�դ˷����Ȥ��Ƥϡ�

�ʤɤ������롣

½Û´Ä»²¾È¡Ê²ó¼ý¤Ï¹Ô¤¨¤Ê¤¤¡Ë
Figure 7. �۴Ļ��ȡʲ���ϹԤ��ʤ���

2.3.2.Tracing collectors

Tracing collectors�ϼ��Τ褦���ʳ���ޤ�GC�ǡ�����Ū��GC�ȸƤФ�Ƥ���ΤϤ�����Υ��르�ꥺ��Ǥ��롣

  1. �����(�㡢�ޡ�����Ϥ���)
  2. �ȥ졼��(�㡢�ޡ����⤷���ϥ��ԡ�)
  3. ���
  4. ���ݤ����ΰ�κ�����
���르�ꥺ�ࣱ Tracing collector

Tracing collectors��̾���ΤȤ��ꥪ�֥������Ȥ˴ޤޤ��ݥ��󥿤�ȥ졼���������Ѥ��Ƥ��륪�֥������ȡ����Ƥ��ʤ����֥������Ȥ�Ƚ�̤��롣���ΤȤ����ȥ졼���ΤϤ���Ȥʤ륪�֥������Ȥ�롼��(Root)�ȸƤӡ���ã�Ǥ������֥������Ȥϥץ�����ब������Υ��֥������ȡ���ã�Ǥ��ʤ��ä����֥������ȤϤ��ߤȤߤʤ������Ԥ����������äơ����르�ꥺ��β���ʳ��Ǥϳ��ݤ������ƤΥ��֥������Ȥ˲��餫����ˡ�ǥ��������Ǥ���ɬ�פ����롣

�ȥ졼���Υ��르�ꥺ��ˤϥޡ�������ɥ�������(Mark and Sweep)�����ԡ�(Copying)�Ȥ�����Ĥ���ˡ��¸�ߤ��롣

2.3.2.1.�ޡ�������ɥ�������

�ޡ�������ɥ������פϥȥ졼���ʳ��Ȳ���ʳ������Τ�ʬ���줿���르�ꥺ��Ǥ��롣

���르�ꥺ��1�Υȥ졼���ʳ��Ǥϥ롼�Ȥ�����ã�Ǥ��륪�֥������Ȥ˰���Ĥ��Ƥ�����

¥Þ¡¼¥¯
Figure 8. �ޡ���

���르�ꥺ��1�β���ʳ��Ǥϡ����ƤΥ��֥������Ȥ�Ĵ�٥ޡ����ΤĤ��Ƥ��ʤ����֥������Ȥ������롣

¥¹¥¤¡¼¥×
Figure 9. ��������

�ޡ�������ɥ���������GC�������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣

�����Ȥ��Ƥϡ�

�ʤɤ����롣

����ʸ�ǤϤ��Υޡ�������ɥ������פ������Ǥ����ݼ�Ū�ޡ�������ɥ������פ����Ѥ��Ƥ��롣�ݼ�Ū�ޡ�������ɥ������פˤĤ��ƤϽ����Ϥμ����ι�Ǻ��ټ��夲�롣

2.3.2.2.���ԡ�

���ԡ����ΰ��Ⱦʬ�ˤ���GC��Ԥ����르�ꥺ��Ǥ��롣

���르�ꥺ��1�Υȥ졼���ʳ��Ǥϥ롼�Ȥ�����ã�Ǥ��륪�֥������Ȥ򿷤����ΰ�˥��ԡ����Ƥ������ȥ졼��������ꡢ����������ƤΥ��֥������Ȥ򿷤����ΰ�˥��ԡ��Ǥ����顢�Ť��ΰ����Ƥ��˴�����(���르�ꥺ��1�β���ʳ�)��

¥³¥Ô¡¼Á°
Figure 10. ���ԡ���
¥³¥Ô¡¼¸å
Figure 11. ���ԡ���

���֥������Ȥ��ư�����뤿�ᡢ�ݥ��󥿤��դ��ؤ���Ԥ������ץ��������Ǥϥݥ��󥿤Ȥ��̤�ID���Ѥ���ɬ�פ����롣

���ԡ�GC�������Ȥ��Ƥϰʲ��Τ��Ȥ��������롣

�����Ȥ��Ƥϡ�

�ʤɤ����롣

2.4.���� vs �ݼ�Ū

���Ѥ��Ƥ��륪�֥������Ȥ򤿤ɤ���ˡ�Ȥ��̤ˡ����Ѥ��Ƥ��륪�֥������Ȥ�Ƚ��ˡ�ˤĤ������Τ�GC(precise GC)���ݼ�ŪGC(conservative GC)�Ȥ������̤����롣

���Τ�GC�ϡ�������Υ��֥������Ȥ����Τ˵�ᡢ���Ѥ��Ƥ��ʤ����֥������Ȥ����Ʋ������GC�Ǥ��롣�̾�GC�Ȥ��������Τ�GC�򼨤���

�ݼ�ŪGC��������餷��ۣ��ʥ��֥������Ȥ��ݻ����Ʋ����Ԥ�ʤ�GC�Ǥ��롣����Ū�ˤϥ��֥������ȤΥ롼�Ȥ˴������륪�֥������Ȥ��ΰ�(�ҡ��פʤ�)�򤵤��ݥ��󥿤��˴ޤޤ줿���ˤϡ����Υݥ��󥿤��������֥������Ȥβ���ϹԤ�ʤ��ʤɤ����ˤ�Τ롣��̤Ȥ������襴�ߤǤ��륪�֥������Ȥ��ݻ����Ƥ��ޤ��������Υ��֥������Ȥ�̵���ʥݥ��󥿤򤵤����ȤϤʤ��ΤǼ㴳�Υ���꡼���������뤬��ñ��ʳ��˰����Ǥ��롣�̾�롼�Ȥϥ쥸�����������å�������ΰ衢�ҡ����ΰ�ʤɤ����뤬����������Ƥ�ۣ��Ȥ����ݼ�ŪGC��Ԥ������ä����ݼ�(fully conservative)��������ۣ��Ȥ��ƹԤ�����Ⱦ�ݼ�(partially conservative)�Ȥ�����

�ݼ�Ū�����ΤȤ����ͤ����ϵ����ΰ��ޡ����������ˤǤ��뤿�ᡢ����Ū�ʥ��르�ꥺ��ϵ��ꤷ�ʤ���

�ݼ�ŪGC�ϥޡ�������ɥ�������GC���Ȥ߹�碌�����Ѥ���뤳�Ȥ�¿�����ޤ�������GC�򥵥ݡ��Ȥ��ʤ�C�ʤɤθ���Ǥμ������ưפǤ��뤿�ᡢRuby�ʤɤθ�������ϤǤϤ����ݼ�Ū�ޡ�������ɥ�������GC�����Ѥ���Ƥ��롣

3.Lisp

�ܸ���ǤϤ��ޤ��ޤ�GC�θ�Ψ��Ĵ�٤뤿��˥ץ�����ߥ󥰸�����ꡢGC��������롣�����ƥ٥���ޡ����ƥ��Ȥˤ�ä���Ӥ�Ԥ��������ǡ�GC����ǽ��ȿ�Ǥ���䤹���������䤵������¤����LISP������������

LISP(LISt Processing��ά)��1958ǯ�˥���󡦥ޥå��������ˤ�ä�ȯ�����줿�ץ�����ߥ󥰸���Ǥ��롣�����黻�η׻���ǥ���ξ��ɽ�����뤿��ε�ˡ��FORTRAN�ξ�˰ܿ����뤳�Ȥˤ����LISP���󥿥ץ꥿������������

����LISP��Common Lisp��Scheme�Ȥ�����Ĥ���������ή�Ǥ��뤬�������Ǥ�LISP���Ƥ����ƤϤޤ��������夲�롣

3.1.��ħ�ȥץ���������

3.1.1.Atom

LISP�ǰ����ǡ�������ǡ��ͤ��Τ�Τ򼨤��ǡ�����Atom�ȸƤ֡�Atom�ˤ�̾���򤢤�魯����ܥ�(Symbol)�������͡����ͤ�ɽ���������Τ�Ρ�ʸ���󡢴ؿ��򤢤�魯�ץ���������(Procedure)�ʤɤ��ޤޤ�롣

Atom��LISP�ץ�������ľ�ܥ�ƥ��Ȥ��Ƶ��ҤǤ�����(���͡�ʸ������)�䡢LISP�μ���¹Ԥ�����̤Ȥ����������Ρʥ���ܥ롢�ץ���������ˡ�����¾LISP�����Ϥγ�ĥ���Ѱդ��줿�ǡ�����¤�ʤɤ��ޤޤ�롣

��ƥ��⤷���ϼ� �¹Ԥ������ Atom�μ���
10 10 ����
"the string" "the string" ʸ����
'symbol symbol ����ܥ�
(quote symbol) symbol ����ܥ�
(lambda (x) x) procedure(���餫������ɽ��) �ץ���������
Figure 12. Atom���

3.1.2.Cons Cell

LISP�ˤϤ⤦�ҤȤ�Cons Cell(�⤷����Pair)�ȸƤ֥ǡ�����¸�ߤ��롣Cons Cell����ĤΥǡ�����ޤȤ��ǡ����Ǥ��롣Cons Cell����Ƭ��Car�ʥ����ˡ��Ǹ��Cdr(������)�ȸƤ֡�Car��Cdr��Atom�� Cons Cell�ɤ���Υǡ����⼨�����Ȥ��Ǥ��롣

Cons Cell
Figure 13. Cons Cell

A��B��Cons�ʤ⤷����Pair�ˤȸ��ä���硢Car��A��Cdr��B�򼨤�Cons Cell�Τ��Ȥ������Cons Cell��������뤳�Ȥ�cons����ȸ�����

3.1.3.S��

LISP�ϥץ������ε���ˡ��S��(Symbol-Expression)�ȸƤФ�뵭����������Ѥ��Ƥ��롣S���ϼ��Τ褦���������롣

S�� ::= Atom
S�� ::= S����S����Cons
Figure 14. S�������

S����Atom��ޤबcons����Ƥ����Τ�Atom�ǤϤʤ���S���򵭽Ҥ����硢��ƥ��ɽ���Ǥ���Atom�Ϥ��Τޤ޵��Ҥ���Cons Cell�ϥɥå���(A . B)�Τ褦��ɽ�����롣A��Car��B��Cdr�ˤ����롣

ñ½ã¤ÊS¼°¤Î¹½Â¤
Figure 15. ñ���S���ι�¤

LISP�Ǥ�Cons Cell��ɥå��Ф�ɽ������S�����⼡�Τ褦��Ϣ³����". ("���б�����")"���ά�����ꥹ��ɽ���������Ѥ��롣�ꥹ��ɽ�����줿S���Τ�����(<S��> ... <S�� n>)�Ȥ������ˤʤäƤ����Τ�ꥹ�ȤȸƤӡ��ꥹ�ȤκǸ夬�ɥå��ФˤʤäƤ����Τ�ɥåȥꥹ�ȤȸƤ֡�

S�� �ꥹ��ɽ�� ����
(a . b) (a . b) �ɥåȥꥹ��
(a . (b . c)) (a b .c) �ɥåȥꥹ��
(a . (b . ())) (a b) �ꥹ��
((a . b) . (c . (d . e))) ((a . b) c d . e) �ɥåȥꥹ��
((a . b) . (c . (d . ()))) ((a . b) c d) �ꥹ��
((a . (b . ())) . (c . (d . ()))) ((a b) c d) �ꥹ��
Figure 16. S�����б�����ꥹ��ɽ��

���̤���Ȥ��Ƥϡ�����ʤ��ꥹ�Ȥ�nil��Common Lisp�Ǥ�ɽ�����˥�ˤ�()��Scheme�Ǥ�ɽ�������ꥹ�ȡˤʤɤ�ɽ����nil��()��Atom�Ǥ⤢�롣

3.1.4.�ץ������

LISP�Ǥ�S���ʥꥹ�Ȥ�Atom�ˤ򼰤Ȥ���ɾ��(Eval)���Ƥ�����ɾ���Ȥϼ������ͤ���뤳�Ȥ������LISP�Ǥϼ��μ���˱����Ƽ��Τ褦��ɾ����Ԥ���

���μ��� ɾ������ˡ
�ꥹ�� (<�ؿ�> <����> ... <����>)�Τ褦�ʴؿ��ƤӽФ��Ȥߤʤ���ɾ�����롣
����ܥ� ����ܥ���б��դ���줿�ͤ���Ф���
����ܥ�ʳ���Atom Atom���Ȥ��֤���
Figure 17. LISP�μ���ɾ��ˡ

�ؿ��ˤϰ��������Ƥ�ɾ�����ʤ��ü����(special form, macro)�Ȱ���������ɾ������ץ��������������ब¸�ߤ��롣�ؿ��˰������Ϥ����ͤ���뤳�Ȥ������ؿ���Ŭ��(apply)���롢�⤷����ñ��Ŭ������ȸ�����

3.1.4.1.�ü����

��ɽŪ���ü�����ˤ�quote��set!��cond��lambda�ʤɤ�¸�ߤ��롣��ʸ(syntax)�Ȥ�ƤФ�롣

3.1.4.1.1.quote

quote������ɾ�������ˤ��Τޤ��֤��ü�����Ǥ��롣�������ĤȤ롣�ꥹ�Ȥ�ǡ�����¤�Ȥ��ư���������硢����ܥ뼫�Τ���Ф��������ʤɤ����Ѥ��롣'(��������)�����Ѥ�����ά��ˡ�򥵥ݡ��Ȥ���LISP�����Ϥ�¿����

(quote 10) ; =>10
(quote a) ; => a
(quote (this is the list)) :=> (this is the list)
'symbol ; => symbol
'(another list) ; => (another list)
Figure 18. quote��ư��
3.1.4.1.2.set!

set!�ϥ���ܥ���ͤ��б��դ����ü�����Ǥ��롣�������Ȥ롣�������ϥ���ܥ��Ȥꡢ���������ɾ�������ͤ��������Υ���ܥ���б��դ��롣�ʤ�LISP�Ǥ��ͤ򥷥�ܥ���б��դ��뤳�Ȥ�«������Ȥ�����

(set! a 10) 
a ; => 10
(set! b '(the list))
b ;=> (the list)
Figure 19. set!��ư��
3.1.4.1.3.cond

cond��ʬ����ɽ���ü�����Ǥ��롣ʣ���ΰ�����Ȥꡢ�����ι�¤�ϼ��Τ褦�ˤʤäƤ���ɬ�פ����롣

(cond <condition clause1> <condition clause> ...)
<condition clause n> := (<condition> <expression> ...)
Figure 20. cond�����

cond�Ǥ�<condition clause>����֤�ɾ�����Ƥ�����<condition clause>�Τ�����<condition>��ɾ�����ƿ��򼨤��ͤǤ����³��<expression>����֤�ɾ������<condition>�����򼨤��ͤǤ����³��<expression>��ɾ�������˼���<condition clause>��ɾ�����롣

�Ǹ��<condition clause>��<test>��else�ʤɤ����̤ʥ���ܥ뤬�Ȥ�����������Ƥ��ꡢ���ξ���̵����³��<expression>��ɾ������롣

(set! a 10)
(cond ((<= 1 a) 1)
      ((= 0 a) 0)
      (else    -1)) ; => 1
(set! b -1)
(cond ((<= 1 b) 1)
      ((= 0 b) 0)
      (else    -1)) ; => -1
Figure 21. cond��ư��
3.1.4.1.4.lambda

lambda�ϥץ�������������ü�����Ǥ��롣�������ˤϥץ���������ΰ����Υꥹ�Ȥ���������ʹߤˤϥץ������������Ȥ򵭽Ҥ��롣�ץ����������ƤӽФ������ϡ���ȤΤ������ֺǸ��ɾ�����������ͤ��֤���lambda���Ȥ������

(lambda (x) x) ; => procedure
(set! identity (lambda (x) x))
(identity 10) ; => 10
((lambda (x y) (+ x y)) 10 20) ; => 30
((lambda (x y) x (+ x y) y) 10 20) ; => 20
Figure 22. lambda��ư��
3.1.4.1.5.�ץ���������

�ץ�����������ü�����Ȥϰۤʤ������ɾ����ԤäƤ���ؿ����ͤ����ؿ��Τ��ȤǤ��롣�ץ���������ˤ��礭��ʬ����Cons Cell���������cons����§�黻��+��*����Ӵؿ�<�Ȥ��ä���������Ϥ��Ȥ߹��ޤ�Ƥ����Ȥ߹��ߥץ���������ȡ��ץ�����ޤ�lambda���Ǻ�����������ץ������������Ĥμ��ब¸�ߤ��롣

�ץ���������Ǥ����Ƥΰ�����ɾ�����Ƥ���ؿ���ɾ����Ԥ����ᡢ�ü�����Ȱۤʤ깽ʸ�ǤϤʤ���LISP�ˤ��ü�����ȥץ���������������δؿ�����¸�ߤ��ʤ��Ȥ⤤���롣

(set! a 10)
(cons 'a 'b) ; => (a . b)
(cons a (cons 'b nil)) ; => (10 b)
(* a 4) ; => 40
(< a 2) ; => ����ɽ����(nil��#f�ʤ�)
(+ a (* 3 4)) ; => 22
(set! add-1 ((lambda (x) (lambda (y) (+ x y))) 1))
(add-1 10) ; => 11
Figure 23. �ץ������������

3.1.5.�Ķ�

LISP�Ǥ�C����ʤɤǸ����������פ�Ķ��ȸƤӡ��ޤ����ֳ�¦�δĶ���ȥåץ�٥�(Top-Level)�ȸƤ֡�LISP�Ǥ�lambda�Ǻ�������ץ���������Τߤ��������Ķ���������롣

�ץ���������Ϻ������줿�Ȥ��δĶ���������ץ��������㤬���IJ������ȡ��°�����«����������Ĥޤ�ɾ��������˺������줿�Ȥ��δĶ����ĥ������ǿ������Ķ���������롣

lambda¼°¤¬ºî¤ê½Ð¤¹¿·¤·¤¤´Ä¶­¡ÊÏȤ¬´Ä¶­¤òɽ¤¹¡Ë
Figure 23. lambda�������Ф��������Ķ����Ȥ��Ķ���ɽ����

���ߤ�LISP�Ǥϥ����ƥ��å��������פ����Ѥ���Ƥ��뤬�������ƥ��å��������פ�������줿���δĶ���ץ��������㤬��¸���뤳�Ȥˤ��¸����Ƥ��롣Figure 23��x��y�ʤɡ��ȥåץ�٥�ʳ����������Ƥ���lambda�β������ȤʤäƤ����ѿ���쥭�������ѿ��ȸƤ֡�

�쥭�������ѿ�x��(lambda (y) (+ x y))����������ץ��������㤬�˴������ޤǥץ�������������Ⱦ�ʵ�Ū�����ѤǤ��뤬�����Τ褦�˥쥭�������ѿ������Ѥ��Ƥ���ץ�����������ä˥���������ȸƤ֡�

3.2.LISP��GC

GC��LISP��Ʊ�����������������Ǥ��롣LISP�Ǥϥץ��������ɤ߹��ߡ��ꥹ�Ȥ�����������Υꥹ�Ȥ�ɾ�����ƥץ�������¹Ԥ��롣ɾ��������Υꥹ�Ȥ䡢ɾ�������Ѥ�������ΰ�Ϥ��ߤȤʤ뤬��LISP�Ǥϥץ�����ޤ�����Ū�˥������ݡ�����������ˡ���Ѱդ���Ƥ��ʤ����ᤳ���Τ��ߤϤ�����Ϸ׻����λ񸻤򿩤��Ĥ����Ƥ��ޤ��������������Υꥹ�Ȥ�������Cons Cell��Atom�Ϥ��ߤȤʤäƤ�����Ѥ���ǽ�Ǥ���ΤǺ����Ѥ�Ԥ���

LISP�ʳ��Υ��󥿥ץ꥿�θ�������Ϥ�Ʊ�ͤ˥ץ��������ɤ߹��ߡ��¹Ԥ���ݤ˸�����ͭ�Υǡ�����¤(ʸ���󡢥ե�����ݥ��󥿡���ʸ�ڤʤ�)��������롣�����ǹ�ʸ�ڤȤ�Ϳ����줿�ץ��������᤹�뤿��˥��󥿥ץ꥿������ΰ�˺��ǡ�����¤�Ǥ��롣̾�����ѿ������󡢴ؿ������ȶ��̤����ꡢ���ä���̵���Ƥ�黻�Ҥ�ͥ���̤����򤷤ƿ����β�ᤷ���ꤹ�롣

��ʸ�ڤ�LISP�Ϥ��Ǥ˼������褦�ˤ��ä����ڹ�¤�Τߤǹ�ʸ�����ꤵ��뤿�ᡢ¿����Ȱ㤤��ʸ���Ϥ��ä�ɽ���������ꥹ�ȹ�¤���Ѵ���������Ǥ��롢�Ĥޤ깽ʸ�ڤϥꥹ�Ȥˡ���ʸ�ڤ�������ǡ�����¤��Cons Cell�����Ǥ�Atom���������롣LISP��Ʊ�ͤ˥��󥿥ץ꥿�θ�������Ϥ����Ѥ�����ˤϹ�ʸ�ڤ��������ɬ�פ����롣���δ����ˤ��Ф���GC�����Ѥ���롣

�ꥹ�ȡ���ʸ�ڤϥץ�����ޤ�ľ�ܴ�����Ԥ����Ȥ��ǽ�ʾ�礬���롣�����������ξ��ϸ�������Ϥ������˼��ä��뤳�Ȥˤʤ��������Ϥ򤷤�����٤���夵������Ū��ȿ���Ƥ��ޤ���

���Τ褦�ˡ�����٤ι⤤���󥿥ץ꥿�θ�������Ϥ����Ѥ�������٤ι⤤�ץ����������������ˤ�GC��ɬ�ܤε�ǽ�ȤʤäƤ��롣

4.GC��°LISP������

����ʸ�Ǥ�GC��°��LISP�����Ϥκ������롣LISP�����Ϥλ��ͤ�Scheme�Υ��֥��åȤȤ��롣�����Ϥι�¤�ˤϸ�ŵŪ��S���Υ��󥿥ץ꥿�ʲ��ϡˡ�GC�Υ��르�ꥺ��ˤ��ݼ�ŪMark and Sweep����Ѥ��롣

4.1.LISP�����Ϥι�¤

��ŵŪ��S���Υ��󥿥ץ꥿�Ȥ��Ƥ�LISP�����Ϥ����������˴ΤȤʤ뵡ǽ��read-eval-print-loop(repl��ά��)��GC�Ǥ��롣����repl�Ϥ���̾�ΤȤ��ꡢ���Ϥ��ɤ߼�ꡢɾ��(evalute)�������Ϥ��뤳�Ȥ򷫤��֤������Ǥ��롣

read��Ԥ�reader��ʸ����Ȥ��Ƥ�S�����ɤ߼�ꡢLISP�����Ϥ�����ɽ���Ȥ��Ƥ�S��(�ꥹ��)���Ȥ�Ω�Ƥ롣eval��reader�����Ф����ꥹ�Ȥ��ᤷ�ץ�������¹Ԥ��롣print�ϼ¹Է�̤��ܤ˸�������ǽ��Ϥ��롣

read-eval-print-loop
Figure 24. read-eval-print-loop

4.2.��������

�ܸ���Ǥ�GC��������뤳�Ȥ⤢�ꡢ���餫����GC����ܤ��줿�ץ�����ߥ󥰸���ǤϤʤ�C����ˤ�äƺ�����Ԥä���C++�������Ѥ��ʤ��ä���ͳ�ϡ��ݼ�ŪGC�ȥ��󥹥��󥹤Υե����ʥ饤���ζ�Ĵ��Ԥ����Ȥˤ�ꡢ�ܼ��Ǥʤ���ʬ�����դ򤽤�����Ƥ��ޤ��Τ��ɤ�����Ǥ��롣

4.3.����

�ܸ���Ǻ�������LISP������(�ʲ�������)�β����Ԥ���

4.3.1.�ǡ�����¤

�����������������Τ����Ѥ���ǡ�����¤��scheme.h��������Ƥ��롣��ŵŪ��LISP�����ϤǤ�Cell�ȸƤФ��ʣ���Υǡ�����¤��union�ǤޤȤ᤿���ФȤ���union���̤�����Ф���ĥǡ�����¤�����Ѥ���Τ���ή�Ǥ��롣

Cell�����union�ǤޤȤ᤿���ФΥǡ�����¤�ˤ�S���ι�ǽҤ٤�cons(Cell�Υݥ��󥿤���Ļ��ĥǡ�����¤)��atom��ޤࡣ���������������Ϥ�atom��symbol��integer�� primitive��closure��macro�Ǥ��롣

Cell��LISP�����Ϥ����Ѥ���ǡ�����¤��ͤ������ͳ�ˤϡ�Cell�Ȥ����ҤȤĤΥǡ�����¤�ǽ����Ϥ����Ѥ���S��������ɽ���Ǥ��뤳�Ȥ�¾�ˡ��ǡ����Υ����������ˤ���GC�ǤΥ����ΰ�����Ҳ����ɤ���̣��ޤޤ�Ƥ롣

�������������ϤǤ�Cell��SCM�Ȥ���̾����typedef���Ƥ���

typedef struct _Cell* SCM; /* scheme cell object interface */
struct _Cell {
    struct _Header {
        enum SchemeCellType type;
        short gc_flag;
    } header; /* cell header */
    union {
        struct _Cons {
            SCM car;
            SCM cdr;
        } cons;
        struct _Integer {
            int value;
        } integer;
        struct _Symbol {
            char *name;
            int length;
            SCM value;
        } symbol;
        struct _Primitive {
            enum PrimitiveType type;
            char *name;
            SCM (*proc)();
        } primitive;
        struct _Closure {
            SCM args;
            SCM body;
            SCM env;            
        } closure;
        struct _Macro {
            SCM closure;
        } macro;
        /* more ... */
    } object; /* cell object */
};
Figure 25. Cell�������ȴ��(scheme.h)

�ʤ�Cell�Τ���ε����ΰ�γ��ݤˤ�GC������������äƤ���롣���ʳ��Ǥ����̤ʴ���������malloc�ΤߤǺѤޤ��롣Cell�γ��ݤˤĤ��Ƥ�GC�ι�(4.4.1)�Ǿܤ����Ҥ٤롣

4.3.2.����ܥ�ơ��֥�

����ܥ�Ȥ����ǡ�����¤��scheme.h�ǡ�����ܥ롢����ܥ�ơ��֥�Ȥ�������Ԥ��ؿ���symbol.c�ˤ�������Ƥ��롣

����ܥ�Ȥ�LISP��atom��̾����Ĥ����ɤ�ǡ�����¤�Ǥ��롣Ʊ��̾������ĥ���ܥ�Ͼ��Ʊ�����֥������Ȥ����Ѥ��뤳�ȡ��Ĥޤ�Ʊ������ܥ��Ʊ�����ɥ쥹����Ĥ��Ȥ�LISP�����ϤǤϵ����롣�����¸����뤿��˥���ܥ�ơ��֥�����Ѥ��롣�ܽ����ϤǤϥ���ܥ�ơ��֥�ϥ�������ϥå���Ǽ¸����Ƥ��롣����ܥ��̾��(ʸ����)������롣�Ϥ����̾���Υϥå����ͤ��ᡢ��������ϥå���ΰ��֤���ꤹ�롣����S����Ʊ�ͤ�Cons Cell�����Ѥ��Ƥ��������ꥹ�Ȥ򤿤ɤꡢʸ�����Ʊ�ͤ�̾������ĥ���ܥ����롣̾�����б����륷��ܥ뤬¸�ߤ��ʤ����Ͽ����˥���ܥ��������ƥ���ܥ�ơ��֥���ɲä�Ԥ���

̾�����饷��ܥ����뤳�Ȥ�intern�ȸƤ֡�

¥·¥ó¥Ü¥ë¥Æ¡¼¥Ö¥ë
Figure 26. ����ܥ�ơ��֥�

4.3.3.reader

reader��read.c��������Ƥ��롣S�����ɤ߼��Cell�����Ѥ��ƥꥹ�Ȥ�������롣

�ɤ߹����S���λ�����ϤˤĤ��Ƥ�R5RS[1]�򻲹ͤ˺����������Ƶ��߲����Υѡ����ȤʤäƤ��롣������reader����������ꥹ�Ȥ��̾�primitive��closure��macro�ʤɤΤ�ޤޤʤ�Cell�����ǤǤ�����Τ��֤���primitive��closure��macro�ʤɤ�4.3.5����������eval�ˤơ�symbol��«�����줿�ͤ���Ф����ꡢ�ؿ���¹Ԥ��뤳�Ȥˤ���������Τ���Ǥ��롣

4.3.4.print

print��print.c��������Ƥ��롣

print��S����ɽ�����뤿��ε����Ǥ��롣print�����Τϵ����if-elseʸ�Ǥ��롣�����Ȥ���Ϳ����줿S�������Ǥˤ��碌�ư�����Ԥ������Ǥ�Atom�ξ���print������Atom���б����������Ԥ��������Ǥ�Cons Cell�ꥹ�Ȥ�ɽ���ξ���pirnt��print_list��������Ϥ���(Figure 27. (1))��

print_list��Cons Cell�򤿤ɤꤽ�줾������Ǥ������print���Ӥ������ꥹ�Ȥ�ɽ����Ԥ�(Figure 28. (1))��

SCM print(SCM sexp, FILE *file)
{
    if (SCM_CONSTANT_P(sexp)) {
        switch(AS_UINT(sexp)) {
        case AS_UINT(SCM_NULL):       fprintf(file, "()"); break;
        case AS_UINT(SCM_FALSE):      fprintf(file, "#f"); break;
        case AS_UINT(SCM_TRUE):       fprintf(file, "#t"); break;
        case AS_UINT(SCM_EOF):        fprintf(file, "#eof"); break;
        case AS_UINT(SCM_UNDEFINED):
            fprintf(file, "#undefined"); break;
        default:
            scheme_error("bad constant"); break;
        }
        return SCM_UNDEFINED;
    }
    if (SYMBOL_P(sexp)) {
        fprintf(file, "%s", SYMBOL_NAME(sexp));
    } else if (INTEGER_P(sexp)) {
        fprintf(file, "%d", INTEGER_VALUE(sexp));
    } else if (STRING_P(sexp)) {
        fprintf(file, "\"%s\"", STRING_VALUE(sexp));
    } else if (CONS_P(sexp)) {
        print_list(sexp, file);                                /*  (1)  */
    } else if (PRIMITIVE_P(sexp)) {
        fprintf(file, "#<primitive %s>", PRIMITIVE_NAME(sexp));
    } else if (CLOSURE_P(sexp)) {
        fprintf(file, "#<closure>");
        print(CLOSURE_ARGS(sexp), file);
        print(CLOSURE_BODY(sexp), file);
    } else if (MACRO_P(sexp)) {
        fprintf(file, "#<macro>");
        print(MACRO_CLOSURE(sexp), file);
    } else {
        printf("print unsupported: %p", sexp);
    }
    return SCM_UNDEFINED;
}
Figure 27. print�ؿ�(print.c)
static SCM print_list(SCM sexp, FILE *file)
{
    SCM lst = sexp;
    putc('(', file);
    for(;;) {
        print(CAR(lst), file);
        lst = CDR(lst);
        if (NULL_P(lst)) break;
        else if (CONS_P(lst)) putc(' ', file);
        else { fprintf(file, " . "); print(lst, file); break;}   /*  (1)  */
    }
    putc(')', file);
    return SCM_NULL;
}
Figure 28. print_list�ؿ�(print.c)

4.3.5.�Ķ�

�Ķ��ˤĤ��Ƥμ�����env.c��������Ƥ��롣eval�ǥץ�������ɾ������ݤ��ѿ����ͤ���Ф��褬�Ķ��Ǥ��롣���Τ���Ķ��ϥ������פ������Ǥ���Ȥ⤤���롣

´Ä¶­¤«¤éÃͤò¼è¤ê½Ð¤¹
Figure 29. �Ķ������ͤ���Ф�

���ֳ�¦�δĶ��ϥȥåץ�٥�ȸƤФ�LISP�����Ϥ���ǥ������Х�ʤ�ΤǤ��롣�ȥåץ�٥�Ǥϥ���ܥ���ͤ����а�δط��Ȥʤ뤿�ᡢ����ܥ뤽�Τ�Τ��ͤ��Ϣ�դ��뤳�Ȥˤ��ȥåץ�٥�Ķ���¸����롣�ȥåץ�٥�ʳ��δĶ��ˤĤ��Ƥϡ�Figure 30.�Τ褦�˥���ܥ���ͤΥꥹ�ȤΥڥ���ꥹ�ȤȤ��ƻ��Ĥ��Ȥˤ��¸����롣�������Ķ���lambda���ǥץ�����������������Ȥ��˺�������롣

environment = ((var1 var2 var3 ...)
                     (val1 val2 val3 ...))
environments =  (environmentN environmentN-1 ... )
Figure 30. �ꥹ�Ȥˤ��Ķ��μ¸���ˡ

�Ķ������Figure 31.�ˡ����ΤȤ��δĶ��Υꥹ��ɽ����Figure 32.�ˡ�Atom��Cons Cell���Ѥ����ǡ�����¤��Figure 33.�˼�����(lambda (x) ...)�����Ф��Ķ���Ķ�����(lambda (y) ... )�����Ф��Ķ���Ķ�2�Ȥ��롣������ǤϴĶ�1�ˤ�x��20���б��դ���졢�Ķ�2�ˤ�y��10���б��դ�����롣���δĶ�����(+ x y)��ɾ����Ԥ��ȼ���(+ 20 10)�Ȥʤꡢ30�������롣

lambda¼°¤¬ºî¤ê½Ð¤¹¿·¤·¤¤´Ä¶­¡ÊÏȤ¬´Ä¶­¤òɽ¤¹¡Ë
Figure 31. lambda�������Ф��������Ķ����Ȥ��Ķ���ɽ����
( ((y) . (10)) // �Ķ�2
  ((x) . (20)) // �Ķ�1
)
Figure 32. (+ x y)��ɾ�����δĶ�(�ꥹ��ɽ��)
(+ x y)¤Îɾ²Á»þ¤Î´Ä¶­(ÆâÉô¹½Â¤)
Figure 33. (+ x y)��ɾ�����δĶ�(������¤)

4.3.6.Static scope

�����ƥ��å���������(Static scope)�Ȥ�4.3.5�Ǽ������Ķ���Ȥä��ѿ����ͤ���Ф���ˡ�Ǥ��롣�����������Ǥ⼨�����Ȥ��ꡢ�����ƥ��å��������פǤ�ʣ���δĶ���Ʊ�ͤ��ѿ����Ȥ��Ƥ������ϡ����˰��ֶᤤ�Ķ����ͤ����Ѥ��롣�ޤ��������ƥ��å��������פ�lambda�����ͤ���������Ȥ��δĶ�����¸����Τǡ��ץ������������ȤǤϡ���������Ȥ��δĶ����ѿ������ѤǤ��롣Scheme��LISP�����ϤȤ��ƤϤ���ƥ����ƥ��å��������פ���Ѥ��ư��衢���ߤǤϥ����ƥ��å��������פ���ή�Ǥ��롣

����Ȥϰۤʤꡢ�����LISP�ϥ����ʥߥå��������פ���Ѥ��Ƥ�����lambda���ǥץ���������Ϥ����Υ����ɤ����ҤȤ��ư���������������δĶ�����¸������Ŭ���������δĶ����ѿ������Ѥ��Ƥ�����

�ܽ����ϤǤϥ����ƥ��å��������פ�¸����뤿��ˡ�lambda�������Ф��ץ��������㤬�Ķ�����¸���롣�ץ��������㤬�Ķ�����¸���뤳�Ȥˤ�ꡢ���������Τ�ư��򥹥��ƥ��å��������פˤ��뤳�Ȥ��Ǥ��롣

4.3.7.ɾ��

eval��apply��eval.c��������Ƥ��롣�����Ϥο�¡��ʬ�Ǥ��롣reader�����������ꥹ�Ȥ��ᡢɾ����evaluation�ˡ��ؿ���Ŭ����apply�ˤ�Ԥ���3.1.4��Figure 17.����ټ�����

���μ��� ɾ������ˡ
�ꥹ�� (<�ؿ�> <����> ... <����>)�Τ褦�ʴؿ��ƤӽФ��Ȥߤʤ���ɾ�����롣
����ܥ� ����ܥ���б��դ���줿�ͤ���Ф���
����ܥ�ʳ���Atom Atom���Ȥ��֤���
Figure 34. LISP�μ���ɾ��ˡ

eval�ǤϿ��ͤΤ褦��¨�ͤ䥷��ܥ��«�����줿�ͤ���Ф����ꤹ��(Figure 35. (1),(2))��

�ޤ����ꥹ�Ȥ���Ƭ��atom��ɾ�������Ȥ����ͤ��ؿ��Ȥ��Ƽ¹Ԥ��뤬�����δؿ��������Ŭ��������ˤ�apply�����Ѥ���(Figure 35. (3))��apply�Ϥ������apply_primitive(Figure 36.)��apply_closure(Figure 37.)��ƤӽФ��������δؿ�����Ǥ����eval���ƤӽФ���롣eval��apply����ߺƵ��ƤӽФ���Ԥ��ʤ���ץ�������¹Ԥ��롣

SCM eval(SCM sexp, SCM env)
{
    SCM kar = SCM_NULL;
    SCM result = NULL;
    struct EvalState state = { env, EVAL_STATUS_RETURN_VALUE};
 eval_loop:
    set_current_sexp(sexp);
    if (SYMBOL_P(sexp)) return symbol_value(sexp, state.env); /*  (2)  */
    if (! CONS_P(sexp)) return sexp;                          /*  (1) */
    if (CONS_P(sexp)) {
        SCM subr;
        state.status = EVAL_STATUS_RETURN_VALUE;
        kar = CAR(sexp);

        if (SYMBOL_P(kar))    { subr = symbol_value(kar, state.env); }
        else if (CONS_P(kar)) { subr = eval(kar, state.env);         }
        result = apply(subr, CDR(sexp), &state, SCM_TRUE); /*  (3)  */
        sexp = result;
        if (state.status == EVAL_STATUS_NEED_EVAL) {
            goto eval_loop;
        }
    }
    return sexp;
}
Figure 35. eval��ȴ��(eval.c)
static SCM apply(SCM subr, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
    if (PRIMITIVE_P(subr)) {
        return apply_primitive(subr, arg, state, need_argument_eval);
    } else if (CLOSURE_P(subr)) {
        return apply_closure(subr, arg, state, need_argument_eval);
    }/* ... */ else {
        scheme_error("subroutine type error");
        return NULL;
    }
}
Figure 36. apply��ȴ��(eval.c)
static SCM apply_closure(SCM closure, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
    SCM closure_env = NULL;
    SCM result = SCM_NULL;
    SCM evaled_arg = SCM_NULL;
    SCM body = CLOSURE_BODY(closure);

    if (length(CLOSURE_ARGS(closure)) > length(arg)) {
        scheme_error("argument error");
    }
    if (FALSE_P(need_argument_eval) ) { evaled_arg = arg; }
    else { evaled_arg = eval_list(arg, state->env);    }
    closure_env = extend_environment(CLOSURE_ARGS(closure), evaled_arg, CLOSURE_ENV(closure));
    while (! NULL_P(body)) {
        // need_argument_eval�������Ƶ� /*  (1)  */
        if (LIST_1_P(body) && FALSE_P(need_argument_eval)) {
            state->status = EVAL_STATUS_NEED_EVAL;
            state->env=closure_env;
            result = CAR(body);
            break;
        }
        result = eval(CAR(body), closure_env);
        body = CDR(body);
    }
    return result;
}
Figure 37. apply_closure��ȴ��(eval.c)
static SCM apply_primitive(SCM subr, SCM arg, struct EvalState *state, SCM need_argument_eval)
{
    if (SPECIAL_FORM_P(subr)) {
        return PRIMITIVE_PROC(subr)(arg, state);
    } else if (LIST_EXPR_P(subr)) {
        SCM evaled_arg;
        if (FALSE_P(need_argument_eval) ) { evaled_arg = arg;
        } else {                            evaled_arg = eval_list(arg, state->env); }
        return PRIMITIVE_PROC(subr)(evaled_arg);
    } else {
        SCM result, evaled_arg;
        if (FALSE_P(need_argument_eval) ) { evaled_arg = arg;
        } else {                            evaled_arg = eval_list(arg, state->env); }
        switch(PRIMITIVE_TYPE(subr)) {
        case PRIMITIVE_TYPE_EXPR_0:
            if (length(arg) != 0)  goto ARG_ERROR;
            result = PRIMITIVE_PROC(subr)();
            break;
        /* ... */
        case PRIMITIVE_TYPE_EXPR_4:
            if (length(arg) != 4)  goto ARG_ERROR;
            result = PRIMITIVE_PROC(subr)(CAR(evaled_arg),
                CADR(evaled_arg), CADDR(evaled_arg), CAR(CDDDR(evaled_arg)));
        case PRIMITIVE_TYPE_EXPR_5:
            if (length(arg) != 5) goto ARG_ERROR;
        default:
            return SCM_NULL;
        }
        return result;
    ARG_ERROR:
        scheme_error("eval unsupported :");
    }
    return SCM_NULL;
}
Figure 38. apply_primitive��ȴ��(eval.c)

4.3.8.�����Ƶ��κ�Ŭ��

Lisp����Scheme�Ǥϡ������Ƶ��κ�Ŭ����������ѤȤ��ƴޤޤ�Ƥ��ꡢ��Ŭ���Τ���Υ��르�ꥺ��Ϥ���eval��apply�˵��Ҥ��롣

����ѥ��뤷��VM��CPU�Ǽ¹Ԥ�������ϤʤɤǤϡ��Ƶ���롼�פ��Ѵ��������Ū�ʥ��르�ꥺ�ब���ѤǤ��롣�����������������������ϤΤ褦��S����ľ�ܲ�ᤷ���Ƶ��˥ͥ��ƥ��֥����å������Ѥ�������ϤǤϤ�����ˡ�����ѤǤ��ʤ���

��äơ�����κ�Ŭ���ˤϡ�SIOD�ʤɸŤ������ϤǺ��Ѥ���Ƥ�����ˡ�����Ѥ��롣���르�ꥺ��ϡ��Ǹ��ɾ������ꥹ�Ȥ򤤤ä���eval���֤������Υꥹ�Ȥ����eval���뤳�Ȥˤ�äƼ¸�����(Figure 38. (1))��Figure 39.�Ϥ��Υ��르�ꥺ��Υ����å��Ǥ��롣

ËöÈøºÆµ¢ºÇŬ²½¥¢¥ë¥´¥ê¥º¥à¤Î¥¹¥±¥Ã¥Á¡Êa¡¢b¤Ï¤½¤ì¤¾¤ì10¡¢5¤¬Â«Çû¤µ¤ì¤Æ¤¤¤ë¾ì¹ç)
Figure 39. �����Ƶ���Ŭ�����르�ꥺ��Υ����å���a��b�Ϥ��줾��10��5��«������Ƥ�����)

�ꥹ�Ȥκ�ɾ����ɾ����ɬ�פ��ɤ����Υե饰�Ǵ������롣�ե饰���ͤ򼨤����(Figure39,40.�Ǥ�is as value���ץ������Ǥ�EVAL_STATUS_RETURN_VALUE�ˤξ���apply�ؿ�������ͤ��ͤȤߤʤ����Τޤޡ�eval�ؿ�������ͤȤ�����ɾ���򼨤����(Figure 39,40.�ξ���is need eval���ץ������Ǥ�EVAL_STATUS_NEED_EVAL�ˤξ��Ϻ�ɾ����Ԥ���

���κ�ɾ���δĶ��ϺǸ�Υꥹ�Ȥ�ɾ��������δĶ��Ȱ��פ��Ƥ���ɬ�פ����뤿�ᡢ���餫����ˡ�����Ѥ���Ķ��򿷤����Ķ��˹�������ɬ�פ����롣����������������ϤǤ�eval�ؿ��ΰ����ˤϴĶ��������eval�ؿ����餤�ä����᤹���˴Ķ��򹹿����Ƥ���(Figure 40.)��

´Ä¶­¤Î¹¹¿·¤ò¹Íθ¤·¤¿¾Ü¤·¤¤Æ°ºî¤Î¥¹¥±¥Ã¥Á
Figure 40. �Ķ��ι������θ�����ܤ���ư��Υ����å�

LISP���������Τ������Ƶ��κ�Ŭ�����б�����ˤϡ��ü�������Ƥȥץ���������������Ƶ��κ�Ŭ����Ԥ��褦���ѹ�����Ф褤������ϡ�LISP�Υץ������Ϻǽ�Ū�ˤ��ü�����ȥץ������������Ĥδؿ��μ¹Ԥ˴��󤵤�뤫��Ǥ��롣

4.4.GC������

4.3.1�����������褦��Cell�γ��ݤ˴ؤ��Ƥ�������������롣����Ū�ˤ�alloc.c�ˤ�����Cell�γ��ݤ�GC��Ԥ���³���򵭽Ҥ��롣�ʤ�GC�ˤ��ݼ�Ū�ޡ�������ɥ���������GC����Ѥ��롣

4.4.1.Cell allocator

GC�Ǥ�ưŪ�˳��ݤ����ǡ��������ƴ�������ɬ�פ����롣���Τ��ᡢGC�����Ѥ�����ˤ�GC���б��������ѤΥ��ꥢ������������������Υ��������������Ѥ���ɬ�פ��롣���Τ���Cell����ݤ������ѤΥ�����������������롣

����Cell�����������ϰ��٤����̤Υҡ��פ���ݤ���Cell��ñ�̤��ڤ���ꤹ����Ȥߤ�������Ƥ��롣�ҡ��פκǽ�����Ǥ�ƥҡ��ץڡ�����free Cell�δ��������Ѥ��Ƥ��롣

Cell�����������Ǥ�free Cell�λĤ�������0�ˤʤ�Ȥޤ�GC��Cell�������롣���θ�free Cell������ʾ����Ǥ��ʤ��ä���硢malloc�ǥҡ��פ��ɲó��ݤ��ơ�free Cell���ɲä��롣

Cell¤Î´ÉÍý
Figure 41. Cell���

4.4.2.�ޡ�������ɥ�������

GC�μ����ˤ��ݼ�Ū�ޡ�������ɥ��������פ����Ѥ��롣�ݼ�Ū��GC�μ���ˡ�ˤĤ��Ƥϼ��ξϤ�������Ԥ��������ǤϤ��δ��äǤ���ޡ�������ɥ��������פμ����ˤĤ���������Ԥ���

�ޡ�������ɥ���������GC�Ȥϼ������ʳ��Υ��르�ꥺ������Ѥ���GC�Ǥ��롣

  1. ���ƤλȤ��Ƥ���Cell�˥ޡ����򤹤롣
  2. �ޡ������դ��Ƥ��ʤ�Cell�������롣

�ʲ��Τ���ư���ܤ����������Ƥ�����

�ޡ�������ɥ��������פǥޡ�����Ԥ������Ȥʤ륪�֥������Ȥ�Root�Ȥ�֡�LISP�����ϤǤ�Root�Ȥʤ륪�֥������Ȥ��ͤ�«������Ƥ��륷��ܥ롢�������Х��ѿ����������줿Cell���������ݼ�ŪGC���оݤȤʤ�ޥ��󥹥��å��ȥ쥸�����ˤ���Cell�Ǥ��롣GC�ǤϤޤ������Root���������������Ǥ������ƤΥ��֥������Ȥ˥ޡ�����Ĥ��Ƥ����������μ��ϥޡ����ΤĤ��Ƥ��ʤ����֥������Ȥβ����Ԥ��������ơ�����Ǥ������֥������Ȥ������˱����ƥҡ��פγ�ĥ��Ԥ���

static void scheme_gc(void)
{
    int collect_cells;
    gc_mark_stack();
    gc_mark_symbol_table();
    /* ... */
    collect_cells = gc_sweep();
    /* ... */
    if (collect_cells < 600) {
        add_heap();
    }
    current_search_page = page_list;
}
Figure 42. scheme_gc��ȴ��(alloc.c)

���֥������ȤΥޡ�����Ԥ�gc_mark_object�Ǥ�Root�Ȥʤ륪�֥������Ȥ���˺Ƶ�Ū�˥ꥹ�Ȥ򤿤ɤꥪ�֥������Ȥ˥ޡ������Ƥ����������Ǥ������֥������Ȥ�Cell�Τ��ȤǤ��롣����䤹�Ǥ˥ޡ������Ĥ��Ƥ��륪�֥������ȤϤ���ʾ��������ʤ��褦�ˤϤ����Ƥ���(Figure 43. (1))���ޤ���Cell����η��ˤ��碌�Ƽ��Υ��֥������Ȥؤ���������ˡ���Ѥ��Ƥ���(Figure 43. (2))������˼����������륪�֥������Ȥ��ҤȤĤˤʤä�����gotoʬ�������Ƶ��κ�Ŭ����Ԥ��������å��ξ�����ޤ��Ƥ���(Figure 43. (3))��

�����֥������Ȥβ����Ԥ�gc_sweep�Ǥϳƥҡ��ץڡ������������������ޡ����ΤĤ��Ƥ��ʤ�Cell��Freelist���ɲä���(Figure 44. (1))���ޡ����ΤĤ��Ƥ���Cell�ϥޡ����򳰤��ơ�����β���������Ƥ���(Figure 44. (2))��

static void gc_mark_object(SCM obj)
{
 loop:
    if (obj == NULL) return;
    /*  (1)  */
    if (SCM_CONSTANT_P(obj)) return ; /* scm constant is not marking */
    if (FREE_CELL_P(obj)) return ; /* free cell is not marking */
    if (GC_MARK_P(obj)) return ; /* already marked. */
    
    GC_MARK(obj);
    /*  (2)  */
    if (CONS_P(obj)) {
        gc_mark_object(CAR(obj));
        obj = CDR(obj);
        goto loop; /*  (3)  */
    } else if (INTEGER_P(obj)) {
        return ;
    } else if (SYMBOL_P(obj)) {
        gc_mark_object(SYMBOL_VCELL(obj));
    } else if (STRING_P(obj)) {
        return ;
    } else if (PRIMITIVE_P(obj)) {
        return ;
    } else if (CLOSURE_P(obj)) {
        gc_mark_object(CLOSURE_ARGS(obj));
        gc_mark_object(CLOSURE_BODY(obj));
        obj = CLOSURE_ENV(obj);
        goto loop; /*  (3)  */
    } else if (MACRO_P(obj)) {
        obj = MACRO_CLOSURE(obj);
        goto loop; /*  (3)  */
    }
}
Figure 43. gc_mark_object��ȴ��(alloc.c)
static int gc_sweep(void) {
    SCM page = page_list;
    int collect = 0;
    gc_sweep_symbol_table_free_cell_remove();
    while(page != NULL) {
        SCM cell = page;
        SCM last_cell = page + ALLOCATE_HEAP_PAGE_OBJECT_SIZE - 1;
        while (AS_UINT(cell) <= AS_UINT(last_cell)) {
            if (FREE_CELL_P(cell)) { /* through */
            } else if (GC_MARK_P(cell)) {
                if (! GC_FOREVER_MARK_P(cell)) { GC_UNMARK(cell); }  /*  (2)  */
            } else { /* unmarked */                                  /*  (1)  */
                cell_finalize(cell);
                int cell_index = 0;
                if (PAGES_FREE_CELL_LIST(page) != NULL) {
                    cell_index = AS_UINT(FREE_CELL_INDEX(PAGES_FREE_CELL_LIST(page)));
                }
                cell_index++;
                FREE_CELL_CONSTRUCT(cell, AS_SCM(cell_index), PAGES_FREE_CELL_LIST(page));
                PAGES_FREE_CELL_LIST(page) = cell;
                free_cell_total_size++;
                collect++;
            }
            cell++;
        }
        page = NEXT_PAGE(page);
    }
    return collect;
}
Figure 44. gc_sweep��ȴ��(alloc.c)

4.4.3.�ݼ�ŪGC����ˡ

�ݼ�Ū��GC�Ȥϥ����å����ɥ쥹����Ȥʤɤ����ҡ��פ˳��ݤ���GC�δ������ˤ��륪�֥������Ȥ򤵤��Ƥ�����ˡ����Υ��֥������Ȥ�������Ǥ���ȹͤ�GC��Ԥ���ˡ�Ǥ��롣���Τ�GC�Ȥϰۤʤꡢ������Υ��֥������Ȥ餷����Τϲ����Ԥ�ʤ������ݼ�Ū�ȸƤФ�롣

C����ʤɤǥ����å�����Υ��ɥ쥹������ˡ�LISP��Ԥ��ץ���������Ƭ�ǥ��������ѿ���������롣���Υ��������ѿ��Υ��ɥ쥹�򥹥��å�����Υ��ɥ쥹�Ȥ��롣

#define SCHEME_STACK_INITIALIZE                        \
  SCM __dummy_scheme_stack_start_object;           \
  stack_initialize(&__dummy_scheme_stack_start_object)
Figure 45. �����å��ν������ȴ��(scheme.h)
int main(int argc, char **argv) {
    {
        SCHEME_STACK_INITIALIZE;
        scheme_initialize();
            read_eval_print_loop();
        scheme_finalize();
        exit(EXIT_SUCCESS);
    }
}
Figure 46. �����å��ν������ȴ��(main.c)

���˥����å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��ˡ������å���GC��Ԥ������ɤ�ľ�����ѿ�����κǸ�˥����å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��Υ��������ѿ���������롣���Υ��������ѿ��Υ��ɥ쥹�򥹥��å�����ü�Υ��ɥ쥹�Ȥ��롣

�����å����ɥ쥹�Ϥ���Ǽ����Ǥ����ΤǼ��˥쥸���������Ƥ���¸��Ԥ�(Figure 47. (1))���쥸���������Ƥ���¸����ˤ�C�����ɸ��饤�֥���setjmp�����Ѥ��롣jmp_buf�򥹥��å�����ü�Υ��ɥ쥹�γ��ݤ��뤿��Υ��������ѿ�������������롣���ݤ���jmp_buf���Ф���setjmp�ؿ���¹Ԥ����쥸��������Ȥ�jmp_buf����¸����(Figure 47. (2))��

�Ǹ�ˤ����ξ��󤫤�ޥ��󥹥��å����ϰϤ��ᡢ�����ΰ���ͤ�GC���������Ƥ���ҡ��פΥ��ɥ쥹���ä����gc_mark_object��¹Ԥ��롣

static void gc_mark_stack(void) {
    jmp_buf save_register_for_gc_mark;
    void *start;
    void *end;
    int i;
    void *end_of_stack;
    /* (2) register value dump */
    setjmp(save_register_for_gc_mark);
    /* (1) �����å�����ü��Ͽ */
    SCHEME_SET_STACK_END(&end_of_stack);
    if (AS_UINT(stack_start) < AS_UINT(stack_end)) {
        start = stack_start;  end = stack_end;
    } else {
        start = stack_end;   end = stack_start;
    }
    /* �ݼ�ŪGC��Ԥ� */
    for (i = 0; i < sizeof(void *); i++) { gc_mark_memory(start, end, i); }
    return ;
}
Figure 47. �ݼ�ŪGC�Υ����å��ΰ�ȥ쥸�����μ�����ȴ��(alloc.c)
static void gc_mark_memory(void *start, void *end, int offset) {
    SCM *obj;
    for (obj = (SCM *) (char *) start + offset; (void *) obj < end; obj++) {
        gc_mark_maybe_object(*obj);
    }
}
Figure 48. �ݼ�ŪGC��ȴ��(alloc.c)

5.ɾ��

���餤�ޤ路�ؿ��μ¹����¾�Υ��󥿥ץ꥿����Ӥ�Ԥ����ޤ�����������Ϥκ�����GC�κ����η��ط����ݼ���ưפ��ˤĤ���ɾ����Ԥ���

5.1.��ǽ���

��ǽ��Ӥ򤿤餤�ޤ路�ؿ��μ¹Ի��֤ˤ��Ԥ�������оݤˤ�Ʊ�����󥿥ץ꥿��Scheme�����Ϥ�SigScheme[3]�����Ѥ��롣

¤¿¤é¤¤¤Þ¤ï¤·´Ø¿ô¤ÎÄêµÁ
Figure 49. ���餤�ޤ路�ؿ������

��Ӥ����Ѥ��������������ɤ򼨤���

(define tak
 (lambda (x y z)
   (cond ((< y x)
          (tak (tak (- x 1) y z)
               (tak (- y 1) z x)
               (tak (- z 1) x y)))
         (#t y))))
(tak 10 5 0)
(exit 0)
Figure 50. tarai.scm
(set! tak
      (lambda (x y z)
        (cond ((< y x)
               (tak (tak (- x 1) y z)
                    (tak (- y 1) z x)
                    (tak (- z 1) x y)))
              (#t y))))
(tak 10 5 0)
(exit 0)
Figure 51. tarai.lisp

�¹Է�̤�ʲ��˼�����

% time cat tarai.scm | sscm > /dev/null
cat tarai.scm  0.01s user 0.00s system 71% cpu 0.017 total
sscm > /dev/null  0.69s user 0.07s system 98% cpu 0.774 total
Figure 52. SigScheme�μ¹Է��
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp  0.00s user 0.00s system 19% cpu 0.020 total
./thesischeme > /dev/null  5.82s user 0.04s system 97% cpu 5.990 total
Figure 53. �����������(HeapSize=500)
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp  0.00s user 0.01s system 20% cpu 0.040 total
./thesischeme > /dev/null  4.52s user 0.06s system 95% cpu 4.810 total
Figure 54. �����������(HeapSize=1000)
% time cat tarai.lisp | ./thesischeme > /dev/null
cat tarai.lisp  0.00s user 0.00s system 35% cpu 0.011 total
./thesischeme > /dev/null  2.14s user 0.02s system 99% cpu 2.173 total
Figure 55. �����������(HeapSize=5000)

���η�̤�ꡢ���٤˳��ݤ���ҡ��ץ��������礭������ۤ�®�٤��Ф뤳�Ȥ��狼�롣���������ҡ��ץ��������礭�����Ƥ�������������Ϥ�SigScheme�����2�ܰʾ�������٤����Ȥ��狼�롣

5.2.��������Ϥ�GC�η��ط�

�̾�θ�������Ϥϥ��ꥢ�������������񸻤򰮤äƤ���Ȳ��ꤹ�롣���Υ��ꥢ����������ޤ൭���ΰ�����������Ф������פʥ����ưŪ�˲�����뤫�����줫�������뤫��ͤ��롣����ȸ��줫��������ˤϸ���˵����ΰ��������򰷤���ǽ��ɬ�פȤʤ롣����ϸ��줬��������ԥ塼���ε���������٤��㤯�ʤ뤿�ᡢ����٤ι⤤�ץ�����ߥ󥰸���ˤϤդ��������ʤ���ǽ�Ǥ��롣�������äơ�GC�ΰ�¸�٤ϸ��������٤ȴ�Ϣ����ȹͤ����롣

�����������ΰ���������ϸ�����׵ᤵ�쵭���ΰ���Ϥ��ФɤΤ褦�ʼ�ˡ��ȤäƤ�褤�֥�å��ܥå����ˤʤäƤ롣���Τ��ᥢ�르�ꥺ��β��ɤʤɤ��ȼ��˹Ԥ��롣�����������줬�׵᤹�뵭���ΰ�˰���ε�§(Ʊ�쥵�����ʤ�)�������硢���르�ꥺ��θ�Ψ�����ޤ�롣

�������äƵ����ΰ���������ϸ���ΰ����ǡ����˰�¸���롣���������ΰ�����ˤ�������֤ϥץ�����ޡ����鸫���ͽ������������Τ����뤿�ᡢ���λ��֤�����ǤϤʤ��Ф�Ĥ����ϥץ������¹Ի��Υꥢ�륿�������������롣���Τ������¹Ԥ˴ؤ������󤬤����硢�����ΰ�μ�ˡ�����󤬲ݤ����뤳�Ȥ����롣

5.3.�ץ��������ݼ�

��������Ϥ�GC�Ȥΰ�¸�ط����θ����ȡ������Ϥ˿������ǡ�����¤���ɲä�����硢�������롼�Ȥ��ɲä������Τ�GC�˼��ä���ɬ�פ����뤳�Ȥ��狼�롣�롼�Ȥ���������¦�ǥ�󥯥ȥꥹ�ȤʤɤǴ�������Ф�����ѹ��������ꡢ�������ǡ�����¤�ΤȤ��Τ�GC��������Ф褤���Ȥ��狼�롣�ޤ�GC���ѹ�����gc_mark_object�����ҤȤĤǤ���Τǡ�GC��°�θ�������Ϥ��ݼ�Υ����Ȥϸ�������ϤΤߤξ����ݼ�Υ����Ȥȸ¤�ʤ��ᤤ���Ȥ���¬�Ǥ��롣

6.�ޤȤ�

GC��°��LISP�����Ϥ��������������ˤ�ꡢ�ݼ�ŪGC����Ѥ���¤��������Ϥ�GC�ϴ�����ʬΥ���Ƽ�����Ԥ��뤳�Ȥ��ǧ�Ǥ��������������ޡ�������ɥ���������GC�ʳ���GC�Υ��르�ꥺ����ݼ�Ū�Ǥʤ�GC�ξ���Ʊ�ͤ�ʬΥ���Ƽ�����Ԥ��뤫�μ¾ڤ��Ǥ��ʤ��ä���

GC�Υ��르�ꥺ��ˤ��ץ�����ߥ󥰥�������ˤɤΤ褦�����¤������뤫�򤢤餫�����ǧ�Ǥ���С�������GC��������볫ȯ�ԤˤȤäƸ��Ѥ�꤬���䤹���ʤ롣

����θ���Ǻ������������Ϥϰ�����GC���������Ǥ��ʤ��ä����ᡢ�⤦�ҤȤĤ����Ū��GC�Ǥ��륳�ԡ�GC�μ�����Ԥ����Ȥ䡢GC�μ¹Ի��֤�ʬ�����ƥꥢ�륿����������夵����ꥢ�륿����GC�ʤɤμ�����Ԥ����Ȥ�����θ������Ǥ��롣

7.����ʸ��

[1] Revised5 Report on the Algorithmic Language Scheme http://schemers.org/Documents/Standards/R5RS/HTML/
[2] SIOD: Scheme in One Defun http://www.cs.indiana.edu/scheme-repository/imp/siod.html
[3] sigscheme http://code.google.com/p/sigscheme/
[4] �ץ�����ߥ󥰸���SCHEME R.����� �ǥ������� �� ¼�� ���� ���� �ԥ����󥨥ǥ奱�������
[5] ANSI Common Lisp �ݡ��� ���쥢�� ��, ���� ���� , �ܲ� ů�� �������ԥ����󥨥ǥ奱�������
[6] �׻����ץ������ι�¤�Ȳ�� �������ɡ������� �����ޥ� , ����꡼ �����ޥ� , �ϥ���� �����֥륽�� ��, ���� �Ѱ� ���� �ԥ����󥨥ǥ奱�������
[7] Ruby�����������ɴ������� HTML�� http://i.loveruby.net/ja/rhg/book/
[8] GC FAQ draft http://www.iecc.com/gclist/GC-faq.html
[9] Slides for talk on memory allocation myths. http://www.hpl.hp.com/personal/Hans_Boehm/gc/myths.ps
[10] McCarthy's Original Lisp http://lib.store.yahoo.net/lib/paulgraham/jmc.lisp

��Ͽ1 ��������LISP�����ϤΥ�����������

thesischeme.tar.gz