Changeset 3a7356dc in mainline

Timestamp:

2012-08-18T03:58:10Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1f9c9a4

Parents:

681a985

Message:

Bithenge: make concatenation lazier

Location:

uspace

Files:

• dist/src/bithenge/fat.bh (modified) (1 diff)
• lib/bithenge/blob.c (modified) (1 diff)
• lib/bithenge/blob.h (modified) (1 diff)
• lib/bithenge/expression.c (modified) (4 diffs)
• lib/bithenge/expression.h (modified) (2 diffs)

uspace/dist/src/bithenge/fat.bh

@@ -55 +55 @@
                 .data <- (.cluster);
         } else {
-                .rest <- file_data(data, bits, fat, cluster_size, .next);
+                .rest <- file_data(data, bits, fat, cluster_size, .next) <- known_length(0);
                 .data <- (.cluster ++ .rest);
         }

uspace/lib/bithenge/blob.c

@@ -459 +459 @@
 }
 
-typedef struct {
-        bithenge_blob_t base;
-        bithenge_blob_t *a, *b;
-        aoff64_t a_size;
-} concat_blob_t;
-
-static inline concat_blob_t *blob_as_concat(bithenge_blob_t *base)
-{
-        return (concat_blob_t *)base;
-}
-
-static inline bithenge_blob_t *concat_as_blob(concat_blob_t *blob)
-{
-        return &blob->base;
-}
-
-static int concat_blob_size(bithenge_blob_t *base, aoff64_t *size)
-{
-        concat_blob_t *self = blob_as_concat(base);
-        int rc = bithenge_blob_size(self->b, size);
-        *size += self->a_size;
-        return rc;
-}
-
-static int concat_blob_read(bithenge_blob_t *base, aoff64_t offset,
-    char *buffer, aoff64_t *size)
-{
-        int rc = EOK;
-        concat_blob_t *self = blob_as_concat(base);
-
-        aoff64_t a_size = 0, b_size = 0;
-        if (offset < self->a_size) {
-                a_size = *size;
-                rc = bithenge_blob_read(self->a, offset, buffer, &a_size);
-                if (rc != EOK)
-                        return rc;
-        }
-        if (offset + *size > self->a_size) {
-                b_size = *size - a_size;
-                rc = bithenge_blob_read(self->b,
-                    offset + a_size - self->a_size, buffer + a_size, &b_size);
-                if (rc != EOK)
-                        return rc;
-        }
-        assert(a_size + b_size <= *size);
-        *size = a_size + b_size;
-        return rc;
-}
-
-static int concat_blob_read_bits(bithenge_blob_t *base, aoff64_t offset,
-    char *buffer, aoff64_t *size, bool little_endian)
-{
-        int rc = EOK;
-        concat_blob_t *self = blob_as_concat(base);
-
-        aoff64_t a_size = 0, b_size = 0;
-        if (offset < self->a_size) {
-                a_size = *size;
-                rc = bithenge_blob_read_bits(self->a, offset, buffer, &a_size,
-                    little_endian);
-                if (rc != EOK)
-                        return rc;
-        }
-        if (offset + *size > self->a_size) {
-                b_size = offset + *size - self->a_size;
-                rc = bithenge_blob_read_bits(self->b,
-                    offset + a_size - self->a_size, buffer + a_size, &b_size,
-                    little_endian);
-                if (rc != EOK)
-                        return rc;
-        }
-        *size = a_size + b_size;
-        return rc;
-}
-
-static void concat_blob_destroy(bithenge_blob_t *base)
-{
-        concat_blob_t *self = blob_as_concat(base);
-        bithenge_blob_dec_ref(self->a);
-        bithenge_blob_dec_ref(self->b);
-        free(self);
-}
-
-static const bithenge_random_access_blob_ops_t concat_blob_ops = {
-        .size = concat_blob_size,
-        .read = concat_blob_read,
-        .read_bits = concat_blob_read_bits,
-        .destroy = concat_blob_destroy,
-};
-
-/** Create a concatenated blob. Takes references to @a a and @a b.
- * @param[out] out Holds the new blob.
- * @param a The first blob.
- * @param b The second blob.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_concat_blob(bithenge_node_t **out, bithenge_blob_t *a,
-    bithenge_blob_t *b)
-{
-        assert(out);
-        assert(a);
-        assert(b);
-        int rc;
-        concat_blob_t *self = malloc(sizeof(*self));
-        if (!self) {
-                rc = ENOMEM;
-                goto error;
-        }
-
-        rc = bithenge_blob_size(a, &self->a_size);
-        if (rc != EOK)
-                goto error;
-
-        rc = bithenge_init_random_access_blob(concat_as_blob(self),
-            &concat_blob_ops);
-        if (rc != EOK)
-                goto error;
-        self->a = a;
-        self->b = b;
-        *out = bithenge_blob_as_node(concat_as_blob(self));
-        return EOK;
-
-error:
-        bithenge_blob_dec_ref(a);
-        bithenge_blob_dec_ref(b);
-        free(self);
-        return rc;
-}
-
 /** Check whether the contents of two blobs are equal.
  * @memberof bithenge_blob_t

uspace/lib/bithenge/blob.h

@@ -243 +243 @@
 int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
     aoff64_t);
-int bithenge_concat_blob(bithenge_node_t **, bithenge_blob_t *,
-    bithenge_blob_t *);
 bool bithenge_blob_equal(bithenge_blob_t *, bithenge_blob_t *);
 

uspace/lib/bithenge/expression.c

@@ -88 +88 @@
     bithenge_scope_t *scope, bithenge_node_t **out)
 {
+        int rc;
         binary_expression_t *self = expression_as_binary(base);
         bithenge_node_t *a, *b;
-        int rc = bithenge_expression_evaluate(self->a, scope, &a);
+        rc = bithenge_expression_evaluate(self->a, scope, &a);
         if (rc != EOK)
                 return rc;
-        rc = bithenge_expression_evaluate(self->b, scope, &b);
-        if (rc != EOK) {
-                bithenge_node_dec_ref(a);
-                return rc;
+        if (self->op != BITHENGE_EXPRESSION_CONCAT) {
+                rc = bithenge_expression_evaluate(self->b, scope, &b);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(a);
+                        return rc;
+                }
         }
 
@@ -133 +136 @@
                 if (bithenge_node_type(a) != BITHENGE_NODE_BLOB)
                         goto error;
-                if (bithenge_node_type(b) != BITHENGE_NODE_BLOB)
-                        goto error;
                 break;
         default:
@@ -203 +204 @@
                 break;
         case BITHENGE_EXPRESSION_CONCAT:
-                rc = bithenge_concat_blob(out, bithenge_node_as_blob(a),
-                    bithenge_node_as_blob(b));
+                bithenge_expression_inc_ref(self->b);
+                bithenge_scope_inc_ref(scope);
+                rc = bithenge_concat_blob_lazy(out, bithenge_node_as_blob(a),
+                    self->b, scope);
                 a = NULL;
                 b = NULL;
@@ -962 +965 @@
 }
 
+
+
+/***************** concat_blob                    *****************/
+
+typedef struct {
+        bithenge_blob_t base;
+        bithenge_blob_t *a, *b;
+        aoff64_t a_size;
+        bithenge_expression_t *b_expr;
+        bithenge_scope_t *scope;
+} concat_blob_t;
+
+static inline concat_blob_t *blob_as_concat(bithenge_blob_t *base)
+{
+        return (concat_blob_t *)base;
+}
+
+static inline bithenge_blob_t *concat_as_blob(concat_blob_t *blob)
+{
+        return &blob->base;
+}
+
+static int concat_blob_evaluate_b(concat_blob_t *self)
+{
+        if (self->b)
+                return EOK;
+        bithenge_node_t *b_node;
+        int rc = bithenge_expression_evaluate(self->b_expr, self->scope,
+            &b_node);
+        if (rc != EOK)
+                return rc;
+        if (bithenge_node_type(b_node) != BITHENGE_NODE_BLOB) {
+                bithenge_node_dec_ref(b_node);
+                return bithenge_scope_error(self->scope,
+                    "Concatenation arguments must be blobs");
+        }
+        self->b = bithenge_node_as_blob(b_node);
+        bithenge_expression_dec_ref(self->b_expr);
+        bithenge_scope_dec_ref(self->scope);
+        self->b_expr = NULL;
+        self->scope = NULL;
+        return EOK;
+}
+
+static int concat_blob_size(bithenge_blob_t *base, aoff64_t *size)
+{
+        concat_blob_t *self = blob_as_concat(base);
+        int rc = concat_blob_evaluate_b(self);
+        if (rc != EOK)
+                return rc;
+        rc = bithenge_blob_size(self->b, size);
+        *size += self->a_size;
+        return rc;
+}
+
+static int concat_blob_read(bithenge_blob_t *base, aoff64_t offset,
+    char *buffer, aoff64_t *size)
+{
+        int rc;
+        concat_blob_t *self = blob_as_concat(base);
+
+        aoff64_t a_size = 0, b_size = 0;
+        if (offset < self->a_size) {
+                a_size = *size;
+                rc = bithenge_blob_read(self->a, offset, buffer, &a_size);
+                if (rc != EOK)
+                        return rc;
+        }
+        if (offset + *size > self->a_size) {
+                rc = concat_blob_evaluate_b(self);
+                if (rc != EOK)
+                        return rc;
+                b_size = *size - a_size;
+                rc = bithenge_blob_read(self->b,
+                    offset + a_size - self->a_size, buffer + a_size, &b_size);
+                if (rc != EOK)
+                        return rc;
+        }
+        assert(a_size + b_size <= *size);
+        *size = a_size + b_size;
+        return EOK;
+}
+
+static int concat_blob_read_bits(bithenge_blob_t *base, aoff64_t offset,
+    char *buffer, aoff64_t *size, bool little_endian)
+{
+        int rc;
+        concat_blob_t *self = blob_as_concat(base);
+
+        aoff64_t a_size = 0, b_size = 0;
+        if (offset < self->a_size) {
+                a_size = *size;
+                rc = bithenge_blob_read_bits(self->a, offset, buffer, &a_size,
+                    little_endian);
+                if (rc != EOK)
+                        return rc;
+        }
+        if (offset + *size > self->a_size) {
+                rc = concat_blob_evaluate_b(self);
+                if (rc != EOK)
+                        return rc;
+                b_size = offset + *size - self->a_size;
+                rc = bithenge_blob_read_bits(self->b,
+                    offset + a_size - self->a_size, buffer + a_size, &b_size,
+                    little_endian);
+                if (rc != EOK)
+                        return rc;
+        }
+        assert(a_size + b_size <= *size);
+        *size = a_size + b_size;
+        return EOK;
+}
+
+static void concat_blob_destroy(bithenge_blob_t *base)
+{
+        concat_blob_t *self = blob_as_concat(base);
+        bithenge_blob_dec_ref(self->a);
+        bithenge_blob_dec_ref(self->b);
+        bithenge_expression_dec_ref(self->b_expr);
+        bithenge_scope_dec_ref(self->scope);
+        free(self);
+}
+
+static const bithenge_random_access_blob_ops_t concat_blob_ops = {
+        .size = concat_blob_size,
+        .read = concat_blob_read,
+        .read_bits = concat_blob_read_bits,
+        .destroy = concat_blob_destroy,
+};
+
+/** Create a concatenated blob. Takes references to @a a and @a b.
+ * @param[out] out Holds the new blob.
+ * @param a The first blob.
+ * @param b The second blob.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_concat_blob(bithenge_node_t **out, bithenge_blob_t *a,
+    bithenge_blob_t *b)
+{
+        assert(out);
+        assert(a);
+        assert(b);
+        int rc;
+        concat_blob_t *self = malloc(sizeof(*self));
+        if (!self) {
+                rc = ENOMEM;
+                goto error;
+        }
+
+        rc = bithenge_blob_size(a, &self->a_size);
+        if (rc != EOK)
+                goto error;
+
+        rc = bithenge_init_random_access_blob(concat_as_blob(self),
+            &concat_blob_ops);
+        if (rc != EOK)
+                goto error;
+        self->a = a;
+        self->b = b;
+        self->b_expr = NULL;
+        self->scope = NULL;
+        *out = bithenge_blob_as_node(concat_as_blob(self));
+        return EOK;
+
+error:
+        bithenge_blob_dec_ref(a);
+        bithenge_blob_dec_ref(b);
+        free(self);
+        return rc;
+}
+
+/** Create a lazy concatenated blob. Takes references to @a a, @a b_expr, and
+ * @a scope.
+ * @param[out] out Holds the new blob.
+ * @param a The first blob.
+ * @param b_expr An expression to calculate the second blob.
+ * @param scope The scope in which @a b_expr should be evaluated.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_concat_blob_lazy(bithenge_node_t **out, bithenge_blob_t *a,
+    bithenge_expression_t *b_expr, bithenge_scope_t *scope)
+{
+        assert(out);
+        assert(a);
+        assert(b_expr);
+        assert(scope);
+        int rc;
+        concat_blob_t *self = malloc(sizeof(*self));
+        if (!self) {
+                rc = ENOMEM;
+                goto error;
+        }
+
+        rc = bithenge_blob_size(a, &self->a_size);
+        if (rc != EOK)
+                goto error;
+
+        rc = bithenge_init_random_access_blob(concat_as_blob(self),
+            &concat_blob_ops);
+        if (rc != EOK)
+                goto error;
+        self->a = a;
+        self->b = NULL;
+        self->b_expr = b_expr;
+        self->scope = scope;
+        *out = bithenge_blob_as_node(concat_as_blob(self));
+        return EOK;
+
+error:
+        bithenge_blob_dec_ref(a);
+        bithenge_expression_dec_ref(b_expr);
+        bithenge_scope_dec_ref(scope);
+        free(self);
+        return rc;
+}
+
 /** @}
  */

uspace/lib/bithenge/expression.h

@@ -38 +38 @@
 #define BITHENGE_EXPRESSION_H_
 
+#include "blob.h"
 #include "transform.h"
 #include "tree.h"
@@ -135 +136 @@
     bithenge_expression_t *);
 
+int bithenge_concat_blob(bithenge_node_t **, bithenge_blob_t *,
+    bithenge_blob_t *);
+int bithenge_concat_blob_lazy(bithenge_node_t **, bithenge_blob_t *,
+    bithenge_expression_t *, bithenge_scope_t *);
+
 #endif