/INSTALL.md

https://github.com/pfq/PFQ · Markdown · 112 lines · 77 code · 35 blank · 0 comment · 0 complexity · 332c62331f3d59232432b60b1e005ce6 MD5 · raw file 

    

  1. PFQ
    2. 

  2. ===
    3. 

  3. 

  4. The following Guide is also available at [Getting-Starte-Guide](https://github.com/pfq/PFQ/wiki/Getting-Started-Guide).
    5. 

  5. 

  6. # Table of Contents                                                                                                                                                                           
    7. 

  7.                                                                                                                                                                                               
    8. 

  8. This guide covers the following topics:                                                                                                                                                       
    9. 

  9.                                                                                                                                                                                               
    10. 

  10. 1. What is PFQ?                                                                                                                                                                               
    11. 

  11. 2. HW and SW Requirements.                                                                                                                                                                    
    12. 

  12. 3. Haskell and Linux Distributions.                                                                                                                                                           
    13. 

  13. 4. Obtaining source codes.                                                                                                                                                                    
    14. 

  14. 5. Satisfy library dependencies.                                                                                                                                                              
    15. 

  15. 6. Build the software.                                                                                                                                                                        
    16. 

  16. 7. Software components.                                                                                                                                                                       
    17. 

  17.                                                                                                                                                                                               
    18. 

  18. ## What is PFQ                                                                                                                                                                                
    19. 

  19.                                                                                                                                                                                               
    20. 

  20. PFQ is a multi-language network framework designed for the Linux Operating System and the Linux Kernel 3.x (or higher). It is highly optimized for multi-core processors,                     
    21. 

  21. as well as for network devices equipped with multiple hardware queues (i.e. Intel 82599 10G).                                                                                                 
    22. 

  22.                                                                                                                                                                                               
    23. 

  23. PFQ consists in a Linux Kernel module, user-space libraries, for the C, C++11/14, Haskell languages and native support for the accelerated libpcap library with programmable fanout.                                                                                                                                                                     
    24. 

  24.                                                                                                                                                                                               
    25. 

  25.                                                                                                                                                                                               
    26. 

  26. ## HW and SW Requirements                                                                                                                                                                     
    27. 

  27.                                                                                                                                                                                               
    28. 

  28. * A 32/64-bit Linux operating system (Intel/AMD architectures are supported).                                                                                                                 
    29. 

  29. * Linux Kernel 3.5 or higher.                                                                                                                                                                 
    30. 

  30. * Kernel headers, required to compile modules for your kernel.                                                                                                                                
    31. 

  31. * A gcc compiler, the one used to compile the kernel in use.                                                                                                                                  
    32. 

  32. * A g++ compiler (g++-4.8/clang-3.4 or higher), for user-space tools and libraries.                                                                                                           
    33. 

  33. * The Haskell stack tool [haskell-stack](https://docs.haskellstack.org/en/stable/README/)                                                                                                                                                                                                                                                                       
    34. 

  34. * CMake, make, autoconf.                                                                                                                                                                      
    35. 

  35. * Flex and bison.                                                                                                                                                                             
    36. 

  36.                                                                                                                                                                                               
    37. 

  37.                                                                                                                                                                                               
    38. 

  38. ### Haskell and Linux Distributions (PIE)                                                                                                                                                     
    39. 

  39.                                                                                                                                                                                               
    40. 

  40. We recommend you to install the stack Haskell tool following the instructions at [Stackage](http://www.stackage.org/install) site.                                                                      
    41. 

  41.                                                                                                                                                                                               
    42. 

  42. However, if you plan to install the Haskell platform from [Haskell-Platform](https://www.haskell.org/platform/), you may encounter compilation problems if you have a system with PIE (position independent executables) enabled by default (such as Ubuntu, Debian etc.).                                                                                         
    43. 

  43.                                                                                                                                                                                               
    44. 

  44. If it is your case, you have to edit the GHC settings file at:                                                                                                                                
    45. 

  45.                                                                                                                                                                                               
    46. 

  46. `/usr/local/haskell/ghc-___/lib/ghc-___/settings`                                                                                                                                             
    47. 

  47.                                                                                                                                                                                               
    48. 

  48. and change the `compiler supports -no-pie` flag from "NO" to "YES".                                                                                                                           
    49. 

  49.                                                                                                                                                                                               
    50. 

  50.                                                                                                                                                                                             
    51. 

  51. ## Obtaining the Source Codes                                                                                                                                                                    
    52. 

  52.                                                                                                                                                                                              
    53. 

  53. Clone the source codes of PFQ from the GitHub repository with the following command:                                                                                                                
    54. 

  54.                                                                                                                                                                                              
    55. 

  55. `git clone https://github.com/pfq/PFQ.git`                                                                                                                                                   
    56. 

  56.                                                                                                                                                                                              
    57. 

  57.                                                                                                                                                                                              
    58. 

  58. ## Build the software                                                                                                                                                                        
    59. 

  59.                                                                                                                                                                                              
    60. 

  60. * To build and install the framework:                                                                                                                                                        
    61. 

  61.                                                                                                                                                                                              
    62. 

  62. `stack Build.hs --build-type=Release install`                                                                                                                                                
    63. 

  63.                                                                                                                                                                                              
    64. 

  64. The command will configure, compile and install the framework satisfying the dependencies of the libraries and the correct order for building the various components.                                                   
    65. 

  65.                                                                                                                                                                                              
    66. 

  66. * Alternatively, you can specify the list of components you want to build from the command line. The following command shows the targets available:                                          
    67. 

  67.                                                                                                                                                                                              
    68. 

  68. ```                                                                                                                                                                                          
    69. 

  69. stack Build.hs show                                                                                                                                                                          
    70. 

  70.                                                                                                                                                                                              
    71. 

  71. targets:                                                                                                                                                                                     
    72. 

  72.     pfq.ko                                                                                                                                                                                   
    73. 

  73.     pfq-clib                                                                                                                                                                                 
    74. 

  74.     pfq-cpplib                                                                                                                                                                               
    75. 

  75.     pfq-haskell-lib                                                                                                                                                                          
    76. 

  76.     pfq-pcap-1.8.1-fanout                                                                                                                                                                    
    77. 

  77.     pfq-hcounters                                                                                                                                                                            
    78. 

  78.     pfq-lang                                                                                                                                                                                 
    79. 

  79.     pfq-affinity                                                                                                                                                                             
    80. 

  80.     pfq-omatic                                                                                                                                                                               
    81. 

  81.     pfq-load                                                                                                                                                                                 
    82. 

  82.     pfq-stress                                                                                                                                                                               
    83. 

  83.     pfqd                                                                                                                                                                                     
    84. 

  84.     regression                                                                                                                                                                               
    85. 

  85.     h-regression                                                                                                                                                                             
    86. 

  86.     tools                                                                                                                                                                                    
    87. 

  87. ```                                                                                                                                                                                          
    88. 

  88.                                                                                                                                                                                              
    89. 

  89. For example, to install pfq.ko and pfqd:                                                                                                                                                     
    90. 

  90.                                                                                                                                                                                              
    91. 

  91. `stack Build.hs -j3 --build-type=Release install pfq.ko pfqd`                                                                                                                                
    92. 

  92.                                                                                                                                                                                              
    93. 

  93.                                                                                                                                                                                              
    94. 

  94. ## Software Components                                                                                                                                                                       
    95. 

  95.                                                                                                                                                                                              
    96. 

  96. The following components are currently part of the framework:                                                                                                                                
    97. 

  97.                                                                                                                                                                                              
    98. 

  98. * pfq.ko                                                                                                                                                                                     
    99. 

  99. * pfq-clib                                                                                                                                                                                   
    100. 

  100. * pfq-cpplib                                                                                                                                                                                 
    101. 

  101. * pfq-haskell-lib                                                                                                                                                                            
    102. 

  102. * pfq-pcap-1.8.1-fanout                                                                                                                                                                      
    103. 

  103. * pfq-hcounters                                                                                                                                                                              
    104. 

  104. * pfq-lang                                                                                                                                                                                   
    105. 

  105. * pfq-affinity                                                                                                                                                                               
    106. 

  106. * pfq-omatic                                                                                                                                                                                 
    107. 

  107. * pfq-load                                                                                                                                                                                   
    108. 

  108. * pfq-stress                                                                                                                                                                                 
    109. 

  109. * pfqd                                                                                                                                                                                       
    110. 

  110. * regression                                                                                                                                                                                 
    111. 

  111. * h-regression                                                                                                                                                                               
    112. 

  112. * tools
    113.