{"id":225,"date":"2019-08-22T16:52:53","date_gmt":"2019-08-22T11:22:53","guid":{"rendered":"https:\/\/binaryterms.com\/?p=225"},"modified":"2021-03-19T15:39:06","modified_gmt":"2021-03-19T10:09:06","slug":"contiguous-memory-allocation-in-operating-system","status":"publish","type":"post","link":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html","title":{"rendered":"Contiguous Memory Allocation"},"content":{"rendered":"

Contiguous memory allocation<\/strong> is a memory allocation method that allocates a single contiguous section of memory<\/strong> to a process or a file. This method takes into account the size of the file or a process and also estimates the maximum size, up to what the file or process can grow?<\/p>\n

Taking into account the future growth of the file and its request for memory, the operating system allocates sufficient contiguous memory blocks to that file.\u00a0 Considering this future expansion and the file\u2019s request for memory, the operating system will allocate those many contiguous blocks of memory to that file.<\/p>\n

In this section, we will discuss contiguous memory allocation in detail along with its advantages and disadvantages. So let us start<\/p>\n

Content: Contiguous Memory Allocation<\/h3>\n
    \n
  1. Memory Allocation<\/a><\/li>\n
  2. Memory Management<\/a><\/li>\n
  3. Fragmentation<\/a><\/li>\n
  4. Advantages and Disadvantages<\/a><\/li>\n
  5. Key Takeaways<\/a><\/li>\n<\/ol>\n

    <\/a>
    \nMemory Allocation<\/h2>\n

    The main memory has to accommodate both the operating system<\/strong> and userspace<\/strong>. Now, here the userspace has to accommodate various user processes. We also want these several user processes must reside in the main memory at the same time.<\/p>\n

    Now, the question arises how to allocate the available memory space to the user processes that are waiting in a ready queue?<\/p>\n

    In Contiguous memory allocation,\u00a0 when the process arrives from the ready queue to the main memory for execution, the contiguous memory blocks are allocated to the process according to its requirement. Now, to allocate the contiguous<\/strong> space to user processes, the memory can be divide either in the fixed-sized partition or in the variable-sized partition.<\/p>\n

    \"contiguous<\/p>\n

    Fixed-Sized Partition: <\/strong>In the fixed-sized partition, the memory is divided into fixed-sized blocks and each block contains exactly one process. But, the fixed-sized partition will limit the degree of multiprogramming as the number of the partition will decide the number of processes.<\/p>\n

    Variable-Size Partition: <\/strong>In\u00a0the variable size partition method, the operating system maintains a table that contains the information about all memory parts that are occupied<\/strong> by the processes and all memory parts that are still available<\/strong> for the processes.<\/p>\n

    How holes are created in the memory?<\/h3>\n

    Initially, the whole memory space is available for the user processes as a large block, a hole<\/strong>. Eventually, when the processes arrive in the memory, executes, terminates and leaves the memory you will see the set of holes of variable sizes.<\/p>\n

    In the figure above, you can see that when file A and file C release the memory allocated to them, creates the holes in the memory of variable size.<\/p>\n

    In the variable size partition<\/strong> method, the operating system analyses the memory requirement of the process and see whether it has a memory block of the required size. If it finds the match, then it allocates that memory block to the process. If not, then it searches the ready queue for the process that has a smaller memory requirement.<\/p>\n

    The operating system allocates the memory to the process until it cannot satisfy the memory requirement of the next process in the ready queue. It stops allocating memory to the process if it does not have a memory block (hole<\/strong>) that is large enough to hold that process.<\/p>\n

    If the memory block (hole<\/strong>) is too large<\/strong> for the process it gets spilt<\/strong> into two parts. One part of the memory block is allocated to the arrived process and the other part is returned to the set of holes. When a process terminates and releases the memory allocated to it, the released memory is then placed back to the set of holes. The two holes that are adjacent<\/strong> to each other, in the set of holes, are merged to form one large hole<\/strong>.<\/p>\n

    Now, at this point, the operating system checks whether this newly formed free large hole is able to satisfy the memory requirement of any process waiting in the ready queue. And the process goes on.
    \n    <\/a><\/p>\n

    Memory Management<\/h3>\n

    In the above section, we have seen, how the operating system allocates the contiguous memory to the processes. Here, we will see how the operating system selects a free hole from the set of holes?<\/p>\n

    The operating system uses either the block allocation list or the bit map to select the hole from the set of holes.<\/p>\n

    Block Allocation List<\/strong><\/h4>\n

    Block allocation list maintains two tables. One table contains the entries of the blocks that are allocated to the various files. The other table contains the entries of the holes that are free and can be allocated to the process in the waiting queue.<\/p>\n

    Now, as we have entries of free blocks which one must be chosen can be decided using either of these strategies: first-fit, best-fit, worst-fit strategies.<\/p>\n

    1. First-fit<\/strong><\/p>\n

    Here, the searching starts either at the beginning of the table or from where the previous first-fit search has ended. While searching, the first hole that is found to be large enough for a process to accommodate is selected.<\/p>\n

    2. Best-fit<\/strong><\/p>\n

    This method needs the list of free holes to be sorted according to their size. Then the smallest hole that is large enough for the process to accommodate is selected from the list of free holes. This strategy reduces the wastage of memory as it does not allocate a hole of larger size which leaves some amount of memory even after the process accommodates the space.<\/p>\n

    3. Worst-fit<\/strong><\/p>\n

    This method requires the entire list of free holes to be sorted. Here, again the largest hole among the free holes is selected. This strategy leaves the largest leftover hole which may be useful for the other process.<\/p>\n

    Bit Map<\/strong><\/h4>\n

    The bit map method only keeps track of the free or allocated block. One block is represented by one bit, bit 0 resembles the free block and bit 1 resembles that the block is allocated to a file or a process.<\/p>\n

    \"Bit<\/p>\n

    It does not have entries of the files or processes to which the specific blocks are allocated. Normally, implementing the first fit will search the number of consecutive zeros\/free blocks required by a file of process. Having found that much of consecutive zeros it allocates a file or process to those blocks.<\/p>\n

    But implementing best-fit or worse-fit will be expensive, as the table of free blocks sorted according to the hole size has to be maintained. But the bit map method is easy to implement.
    \n    <\/a><\/p>\n

    Fragmentation<\/h3>\n

    Fragmentation can either be external fragmentation or internal fragmentation. External fragmentation<\/strong> is when the free memory blocks available in memory are too small and even non-contiguous. Whereas, the internal fragmentation<\/strong> occurs when the process does not fully utilize the memory allocated to it.<\/p>\n

    The solution to the problem of external fragmentation is memory compaction<\/strong>. Here, all the memory contents are shuffled to the one area of memory thereby creating a large block of memory which can be allocated to one or more new processes.<\/p>\n

    As in the figure below, you can see at the last process C, B, D are moved downwards to make a large hole.
    \n\"Memory
    \n    <\/a><\/p>\n

    Advantages and Disadvantages<\/h2>\n

    The main disadvantage<\/strong> of contiguous memory allocation is memory wastage<\/strong> and inflexibility<\/strong>. As the memory is allocated to a file or a process keeping in mind that it will grow during the run. But until a process or a file grows many blocks allocated to it remains unutilized. And they even they cannot be allocated to the other process leading to wastage of memory.<\/p>\n

    In case, the process or the file grows beyond the expectation i.e. beyond the allocated memory block, then it will abort with the message \u201cNo disk space\u201d leading to inflexibility.<\/p>\n

    The advantage<\/strong> of contiguous memory allocation is it increases the processing speed. As the operating system uses the buffered I\/O and reads the process memory blocks consecutively it reduces the head movements. This speed ups the processing.
    \n    <\/a><\/p>\n

    \n

    Key Takeaways<\/h3>\n
      \n
    • Memory allocation can be done either by a fixed-sized partition scheme or by variable-sized partition scheme.<\/li>\n
    • Block allocation list has three methods to select a hole from the list of free holes first-fit, best-fit and worse-fit.<\/li>\n
    • Bit map keeps track of free blocks in memory, it has one bit for one memory block, bit 0 shows that the block is free and bit 1 shows the block is allocated to some file or a process.<\/li>\n
    • Contiguous memory allocation leads to fragmentation. Further fragmentation can either be external or internal.<\/li>\n
    • Contiguous memory allocation leads to memory wastage and inflexibility.<\/li>\n
    • If the operating system uses buffered I\/O during processing, then contiguous memory allocation can enhance processing speed.<\/li>\n<\/ul>\n<\/div>\n

      So, this is all about contiguous memory allocation. We have discussed how the memory is allocated, managed. How does fragmentation occur in contiguous memory allocation? Its advantages and disadvantages.<\/p>\n","protected":false},"excerpt":{"rendered":"

      Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file. This method takes into account the size of the file or a process and also estimates the maximum size, up to what the file or process can grow? Taking into account the future […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","footnotes":""},"categories":[2],"tags":[],"class_list":{"0":"post-225","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-operating-system","7":"entry"},"yoast_head":"\nWhat is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms<\/title>\n<meta name=\"description\" content=\"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\" \/>\n<meta property=\"og:locale\" content=\"en_GB\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"What is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms\" \/>\n<meta property=\"og:description\" content=\"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\" \/>\n<meta property=\"og:site_name\" content=\"Binary Terms\" \/>\n<meta property=\"article:published_time\" content=\"2019-08-22T11:22:53+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-03-19T10:09:06+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg\" \/>\n<meta name=\"author\" content=\"Neha T\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Neha T\" \/>\n\t<meta name=\"twitter:label2\" content=\"Estimated reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#article\",\"isPartOf\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\"},\"author\":{\"name\":\"Neha T\",\"@id\":\"https:\/\/binaryterms.com\/#\/schema\/person\/e495f1d57f5c0a4c521cc3dba95661fe\"},\"headline\":\"Contiguous Memory Allocation\",\"datePublished\":\"2019-08-22T11:22:53+00:00\",\"dateModified\":\"2021-03-19T10:09:06+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\"},\"wordCount\":1433,\"commentCount\":2,\"publisher\":{\"@id\":\"https:\/\/binaryterms.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage\"},\"thumbnailUrl\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg\",\"articleSection\":[\"Operating System\"],\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\",\"url\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\",\"name\":\"What is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms\",\"isPartOf\":{\"@id\":\"https:\/\/binaryterms.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage\"},\"image\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage\"},\"thumbnailUrl\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg\",\"datePublished\":\"2019-08-22T11:22:53+00:00\",\"dateModified\":\"2021-03-19T10:09:06+00:00\",\"description\":\"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.\",\"breadcrumb\":{\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#breadcrumb\"},\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage\",\"url\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg\",\"contentUrl\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg\",\"width\":600,\"height\":373,\"caption\":\"contiguous memory allocation\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/binaryterms.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Contiguous Memory Allocation\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/binaryterms.com\/#website\",\"url\":\"https:\/\/binaryterms.com\/\",\"name\":\"Binary Terms\",\"description\":\"The Computer Science & IT Guide\",\"publisher\":{\"@id\":\"https:\/\/binaryterms.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/binaryterms.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-GB\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/binaryterms.com\/#organization\",\"name\":\"Binary Terms\",\"url\":\"https:\/\/binaryterms.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/binaryterms.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2020\/05\/binary-terms-logo1.png\",\"contentUrl\":\"https:\/\/binaryterms.com\/wp-content\/uploads\/2020\/05\/binary-terms-logo1.png\",\"width\":400,\"height\":63,\"caption\":\"Binary Terms\"},\"image\":{\"@id\":\"https:\/\/binaryterms.com\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/binaryterms.com\/#\/schema\/person\/e495f1d57f5c0a4c521cc3dba95661fe\",\"name\":\"Neha T\",\"url\":\"https:\/\/binaryterms.com\/author\/author\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"What is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms","description":"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html","og_locale":"en_GB","og_type":"article","og_title":"What is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms","og_description":"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.","og_url":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html","og_site_name":"Binary Terms","article_published_time":"2019-08-22T11:22:53+00:00","article_modified_time":"2021-03-19T10:09:06+00:00","og_image":[{"url":"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg","type":"","width":"","height":""}],"author":"Neha T","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Neha T","Estimated reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#article","isPartOf":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html"},"author":{"name":"Neha T","@id":"https:\/\/binaryterms.com\/#\/schema\/person\/e495f1d57f5c0a4c521cc3dba95661fe"},"headline":"Contiguous Memory Allocation","datePublished":"2019-08-22T11:22:53+00:00","dateModified":"2021-03-19T10:09:06+00:00","mainEntityOfPage":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html"},"wordCount":1433,"commentCount":2,"publisher":{"@id":"https:\/\/binaryterms.com\/#organization"},"image":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage"},"thumbnailUrl":"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg","articleSection":["Operating System"],"inLanguage":"en-GB","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html","url":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html","name":"What is Contiguous Memory Allocation in Operating System (OS)? Advantages and Disadvantages & Fragmentation - Binary Terms","isPartOf":{"@id":"https:\/\/binaryterms.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage"},"image":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage"},"thumbnailUrl":"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg","datePublished":"2019-08-22T11:22:53+00:00","dateModified":"2021-03-19T10:09:06+00:00","description":"Contiguous memory allocation is a memory allocation method that allocates a single contiguous section of memory to a process or a file.","breadcrumb":{"@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#breadcrumb"},"inLanguage":"en-GB","potentialAction":[{"@type":"ReadAction","target":["https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html"]}]},{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#primaryimage","url":"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg","contentUrl":"https:\/\/binaryterms.com\/wp-content\/uploads\/2019\/08\/contiguous-memory-allocation.jpg","width":600,"height":373,"caption":"contiguous memory allocation"},{"@type":"BreadcrumbList","@id":"https:\/\/binaryterms.com\/contiguous-memory-allocation-in-operating-system.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/binaryterms.com\/"},{"@type":"ListItem","position":2,"name":"Contiguous Memory Allocation"}]},{"@type":"WebSite","@id":"https:\/\/binaryterms.com\/#website","url":"https:\/\/binaryterms.com\/","name":"Binary Terms","description":"The Computer Science & IT Guide","publisher":{"@id":"https:\/\/binaryterms.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/binaryterms.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-GB"},{"@type":"Organization","@id":"https:\/\/binaryterms.com\/#organization","name":"Binary Terms","url":"https:\/\/binaryterms.com\/","logo":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/binaryterms.com\/#\/schema\/logo\/image\/","url":"https:\/\/binaryterms.com\/wp-content\/uploads\/2020\/05\/binary-terms-logo1.png","contentUrl":"https:\/\/binaryterms.com\/wp-content\/uploads\/2020\/05\/binary-terms-logo1.png","width":400,"height":63,"caption":"Binary Terms"},"image":{"@id":"https:\/\/binaryterms.com\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/binaryterms.com\/#\/schema\/person\/e495f1d57f5c0a4c521cc3dba95661fe","name":"Neha T","url":"https:\/\/binaryterms.com\/author\/author"}]}},"_links":{"self":[{"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/posts\/225","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/comments?post=225"}],"version-history":[{"count":2,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/posts\/225\/revisions"}],"predecessor-version":[{"id":2447,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/posts\/225\/revisions\/2447"}],"wp:attachment":[{"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/media?parent=225"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/categories?post=225"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/binaryterms.com\/wp-json\/wp\/v2\/tags?post=225"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}